Open MPI logo

Open MPI Development Mailing List Archives

  |   Home   |   Support   |   FAQ   |  

This web mail archive is frozen.

This page is part of a frozen web archive of this mailing list.

You can still navigate around this archive, but know that no new mails have been added to it since July of 2016.

Click here to be taken to the new web archives of this list; it includes all the mails that are in this frozen archive plus all new mails that have been sent to the list since it was migrated to the new archives.

Subject: Re: [OMPI devel] opal / fortran / Flogical
From: Brian W. Barrett (brbarret_at_[hidden])
Date: 2009-06-01 13:23:15


Well, this may just be another sign that the push of the DDT to OPAL is a
bad idea. That's been my opinion from the start, so I'm biased. But OPAL
was intended to be single process systems portability, not MPI crud.

Brian

On Mon, 1 Jun 2009, Rainer Keller wrote:

> Hmm, OK, I see.
> However, I do see potentially a problem with work getting ddt on the OPAL
> layer when we do have a fortran compiler with different alignment requirements
> for the same-sized basic types...
>
> As far as I understand the OPAL layer to abstract away from underlying system
> portability, libc-quirks, and compiler information.
>
> But I am perfectly fine with reverting this!
> Let's discuss, maybe phone?
>
> Thanks,
> Rainer
>
>
> On Monday 01 June 2009 10:38:51 am Jeff Squyres wrote:
>> Hmm. I'm not sure that I like this commit.
>>
>> George, Brian, and I specifically kept Fortran out of (the non-
>> generated code in) opal because the MPI layer is the *only* layer that
>> uses Fortran. There was one or two minor abstraction breaks (you
>> cited opal/util/arch.c), but now we have Fortran all throughout Opal.
>> Hmmm... :-\
>>
>> Is MPI_Flogical a real type? I don't see it defined in the MPI-2.2
>> latex sources, but I could be missing it. I *thought* we used
>> ompi_fortran_logical_t internally because there was no officially
>> sanctioned MPI_<foo> type for it...?
>>
>>
>>
>> On May 30, 2009, at 11:54 AM, <rusraink_at_[hidden]>
>>
>> <rusraink_at_[hidden]> wrote:
>>> Author: rusraink
>>> Date: 2009-05-30 11:54:29 EDT (Sat, 30 May 2009)
>>> New Revision: 21330
>>> URL: https://svn.open-mpi.org/trac/ompi/changeset/21330
>>>
>>> Log:
>>> - Move alignment and size output generated by configure-tests
>>> into the OPAL namespace, eliminating cases like opal/util/arch.c
>>> testing for ompi_fortran_logical_t.
>>> As this is processor- and compiler-related information
>>> (e.g. does the compiler/architecture support REAL*16)
>>> this should have been on the OPAL layer.
>>> - Unifies f77 code using MPI_Flogical instead of
>>> opal_fortran_logical_t
>>>
>>> - Tested locally (Linux/x86-64) with mpich and intel testsuite
>>> but would like to get this week-ends MTT output
>>>
>>>
>>> - PLEASE NOTE: configure-internal macro-names and
>>> ompi_cv_ variables have not been changed, so that
>>> external platform (not in contrib/) files still work.
>>>
>>>
>>> Text files modified:
>>> trunk/config/
>>> f77_check.m4 | 20
>>> trunk/config/
>>> f77_check_logical_array.m4 | 6
>>> trunk/config/
>>> f77_check_real16_c_equiv.m4 | 14
>>> trunk/config/
>>> f77_get_fortran_handle_max.m4 | 4
>>> trunk/config/
>>> f77_get_value_true.m4 | 14
>>> trunk/config/
>>> f77_purge_unsupported_kind.m4 | 8
>>> trunk/config/
>>> f90_check.m4 | 10
>>> trunk/
>>> configure.ac
>>>
>>> | 20
>>>
>>> trunk/contrib/platform/win32/CMakeModules/
>>> f77_check.cmake | 24
>>> trunk/contrib/platform/win32/CMakeModules/
>>> f77_check_real16_c_equiv.cmake | 12
>>> trunk/contrib/platform/win32/CMakeModules/
>>> ompi_configure.cmake | 154 ++++----
>>> trunk/contrib/platform/win32/ConfigFiles/
>>> mpi.h.cmake | 96 ++--
>>> trunk/contrib/platform/win32/ConfigFiles/
>>> opal_config.h.cmake | 222 ++++++------
>>> trunk/ompi/attribute/
>>> attribute.c | 6
>>> trunk/ompi/attribute/
>>> attribute.h | 4
>>> trunk/ompi/communicator/
>>> comm_init.c | 2
>>> trunk/ompi/datatype/
>>> copy_functions.c | 10
>>> trunk/ompi/datatype/
>>> copy_functions_heterogeneous.c | 14
>>> trunk/ompi/datatype/
>>> dt_module.c | 224 +++++
>>> +------
>>> trunk/ompi/errhandler/errcode-
>>> internal.c | 2
>>> trunk/ompi/errhandler/
>>> errcode.c | 2
>>> trunk/ompi/errhandler/
>>> errhandler.c | 2
>>> trunk/ompi/file/
>>> file.c | 2
>>> trunk/ompi/group/
>>> group_init.c | 2
>>> trunk/ompi/include/
>>> mpi.h.in | 96 ++--
>>> trunk/ompi/include/
>>> ompi_config.h.in | 48 +-
>>> trunk/ompi/info/
>>> info.c | 2
>>> trunk/ompi/mca/op/base/
>>> functions.h | 56 +-
>>> trunk/ompi/mca/op/base/
>>> op_base_functions.c | 722 +++++++++++
>>> +++++++++--------------------
>>> trunk/ompi/mca/osc/base/
>>> osc_base_obj_convert.c | 8
>>> trunk/ompi/mpi/c/
>>> type_create_f90_integer.c | 4
>>> trunk/ompi/mpi/f77/base/
>>> attr_fn_f.c | 48 +-
>>> trunk/ompi/mpi/f77/
>>> file_read_all_end_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_all_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_at_all_end_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_at_all_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_at_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_ordered_end_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_ordered_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_read_shared_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_all_end_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_all_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_at_all_end_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_at_all_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_at_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_ordered_end_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_ordered_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> file_write_shared_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> fint_2_int.h | 16
>>> trunk/ompi/mpi/f77/
>>> iprobe_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> probe_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> recv_f.c | 6
>>> trunk/ompi/mpi/f77/
>>> testsome_f.c | 4
>>> trunk/ompi/mpi/f90/
>>> fortran_sizes.h.in | 64 +-
>>> trunk/ompi/mpi/f90/scripts/
>>> mpi_sizeof.f90.sh | 16
>>> trunk/ompi/request/
>>> request.c | 2
>>> trunk/ompi/tools/ompi_info/
>>> param.cc | 96 ++--
>>> trunk/ompi/win/
>>> win.c | 2
>>> trunk/opal/class/
>>> opal_bitmap.c | 2
>>> trunk/opal/class/
>>> opal_bitmap.h | 2
>>> trunk/opal/class/
>>> opal_pointer_array.c | 4
>>> trunk/opal/include/
>>> opal_config_bottom.h | 10
>>> trunk/opal/util/
>>> arch.c | 6
>>> 65 files changed, 1104 insertions(+), 1104 deletions(-)
>>>
>>> Modified: trunk/config/f77_check.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f77_check.m4 (original)
>>> +++ trunk/config/f77_check.m4 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -36,7 +36,7 @@
>>> ofc_have_type=0
>>> ofc_type_size=$ac_cv_sizeof_int
>>> ofc_type_alignment=$ac_cv_sizeof_int
>>> - ofc_c_type=ompi_fortran_bogus_type_t
>>> + ofc_c_type=opal_fortran_bogus_type_t
>>>
>>> # Only check if we actually want the F77 bindings / have a F77
>>> # compiler. This allows us to call this macro, even if there is
>>> @@ -87,27 +87,27 @@
>>>
>>> # We always need these defines -- even if we don't have a given
>>> type,
>>> # there are some places in the code where we have to have
>>> *something*.
>>> -
>>> AC_DEFINE_UNQUOTED
>>> ([OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_]),
>>> +
>>> AC_DEFINE_UNQUOTED
>>> ([OPAL_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_]),
>>> [$ofc_have_type],
>>> [Whether we have Fortran 77 $1 or not])
>>> -
>>> AC_DEFINE_UNQUOTED
>>> ([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_]),
>>> +
>>> AC_DEFINE_UNQUOTED
>>> ([OPAL_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_]),
>>> [$ofc_type_size],
>>> [Size of Fortran 77 $1])
>>> -
>>> AC_DEFINE_UNQUOTED
>>> ([OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_]),
>>> +
>>> AC_DEFINE_UNQUOTED
>>> ([OPAL_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_]),
>>> [$ofc_type_alignment],
>>> [Alignment of Fortran 77 $1])
>>> if test "$3" != ""; then
>>> -
>>> AC_DEFINE_UNQUOTED
>>> ([ompi_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t],
>>> +
>>> AC_DEFINE_UNQUOTED
>>> ([opal_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t],
>>> [$ofc_c_type],
>>> [C type corresponding to Fortran 77 $1])
>>> fi
>>>
>>> # Save some in shell variables for later use (e.g., need
>>> - # OMPI_SIZEOF_FORTRAN_INTEGER in OMPI_F77_GET_FORTRAN_HANDLE_MAX)
>>> - [OMPI_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_])[_C_TYPE=$ofc_c_type]
>>> - [OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_])[=$ofc_have_type]
>>> - [OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_])[=$ofc_type_size]
>>> - [OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_alignment]
>>> + # OPAL_SIZEOF_FORTRAN_INTEGER in OMPI_F77_GET_FORTRAN_HANDLE_MAX)
>>> + [OPAL_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_])[_C_TYPE=$ofc_c_type]
>>> + [OPAL_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_])[=$ofc_have_type]
>>> + [OPAL_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []),
>>> [[^a-zA-Z0-9_]], [_])[=$ofc_type_size]
>>> + [OPAL_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_alignment]
>>>
>>> # Clean up
>>> OMPI_VAR_SCOPE_POP
>>>
>>> Modified: trunk/config/f77_check_logical_array.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f77_check_logical_array.m4 (original)
>>> +++ trunk/config/f77_check_logical_array.m4 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -36,7 +36,7 @@
>>>
>>> # C module
>>> # We really need the confdefs.h Header file for
>>> - # the ompi_fortran_logical_t definition
>>> + # the opal_fortran_logical_t definition
>>> if test \! -f confdefs.h ; then
>>> AC_MSG_WARN([*** Problem running configure test!])
>>> AC_MSG_WARN([*** Cannot find confdefs.h file for
>>> config test])
>>> @@ -52,9 +52,9 @@
>>> #ifdef __cplusplus
>>> extern "C" {
>>> #endif
>>> -void $ompi_check_logical_fn(ompi_fortran_logical_t * logical);
>>> +void $ompi_check_logical_fn(opal_fortran_logical_t * logical);
>>>
>>> -void $ompi_check_logical_fn(ompi_fortran_logical_t * logical)
>>> +void $ompi_check_logical_fn(opal_fortran_logical_t * logical)
>>> {
>>> int result = 0;
>>> FILE *f=fopen("conftestval", "w");
>>>
>>> Modified: trunk/config/f77_check_real16_c_equiv.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f77_check_real16_c_equiv.m4 (original)
>>> +++ trunk/config/f77_check_real16_c_equiv.m4 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -29,13 +29,13 @@
>>> # We have to do this as a cache check for cross-compilation
>>> platforms
>>> AC_CACHE_CHECK([for C type matching bit representation of
>>> REAL*16],
>>> [real16_matches_c_var],
>>> - [AS_IF([test "$OMPI_WANT_F77_BINDINGS" = "1" -a
>>> "$OMPI_HAVE_FORTRAN_REAL16" = "1"],[
>>> + [AS_IF([test "$OMPI_WANT_F77_BINDINGS" = "1" -a
>>> "$OPAL_HAVE_FORTRAN_REAL16" = "1"],[
>>> # AC_CACHE_CHECK automatically does its own
>>> AC_MSG_CHECKING, so close it out
>>> AC_MSG_RESULT([pending])
>>>
>>> # First check the type that we found was the same
>>> length in C
>>> - AC_MSG_CHECKING([if $OMPI_FORTRAN_REAL16_C_TYPE ==
>>> REAL*16])
>>> -
>>> OMPI_F77_CHECK_REAL16_EQUIV_TYPE([$OMPI_FORTRAN_REAL16_C_TYPE], [L])
>>> + AC_MSG_CHECKING([if $OPAL_FORTRAN_REAL16_C_TYPE ==
>>> REAL*16])
>>> +
>>> OMPI_F77_CHECK_REAL16_EQUIV_TYPE([$OPAL_FORTRAN_REAL16_C_TYPE], [L])
>>> # If that didn't work, see if we have a compiler-specific
>>> # time that might work
>>> AS_IF([test "$happy" = "no"],
>>> @@ -48,7 +48,7 @@
>>> OMPI_UNIQ([CFLAGS])
>>> OMPI_F77_CHECK_REAL16_EQUIV_TYPE([_Quad],
>>> [q])
>>> AS_IF([test "$happy" = "yes"],
>>> - [OMPI_FORTRAN_REAL16_C_TYPE="_Quad"
>>> + [OPAL_FORTRAN_REAL16_C_TYPE="_Quad"
>>> AC_MSG_RESULT([works!])],
>>> [CFLAGS="$CFLAGS_save"
>>> AC_MSG_RESULT([does not work])])
>>> @@ -67,14 +67,14 @@
>>> ])
>>> ])
>>>
>>> - ompi_real16_matches_c=AS_VAR_GET([real16_matches_c_var])
>>> + opal_real16_matches_c=AS_VAR_GET([real16_matches_c_var])
>>> AS_VAR_POPDEF([real16_matches_c_var])
>>>
>>> - AS_IF([test "$ompi_real16_matches_c" = "yes"],
>>> + AS_IF([test "$opal_real16_matches_c" = "yes"],
>>> [define_value=1],
>>> [define_value=0
>>> AC_MSG_WARN([MPI_REAL16 and MPI_COMPLEX32 support have
>>> been disabled])])
>>> - AC_DEFINE_UNQUOTED([OMPI_REAL16_MATCHES_C], [$define_value],
>>> + AC_DEFINE_UNQUOTED([OPAL_REAL16_MATCHES_C], [$define_value],
>>> [Whether Fortran REAL*16 matches the bit
>>> format of the equivalent C type])
>>> OMPI_VAR_SCOPE_POP
>>> ])
>>>
>>> Modified: trunk/config/f77_get_fortran_handle_max.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f77_get_fortran_handle_max.m4 (original)
>>> +++ trunk/config/f77_get_fortran_handle_max.m4 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -33,7 +33,7 @@
>>> # Calculate the number of f's that we need to append
>>> to the hex
>>> # value. Do one less than we really need becaue we
>>> assume the
>>> # top nybble is 0x7 to avoid sign issues.
>>> - ompi_numf=`expr $OMPI_SIZEOF_FORTRAN_INTEGER \* 2 - 1`
>>> + ompi_numf=`expr $OPAL_SIZEOF_FORTRAN_INTEGER \* 2 - 1`
>>> ompi_fint_max=0x7
>>> while test "$ompi_numf" -gt "0"; do
>>> ompi_fint_max=${ompi_fint_max}f
>>> @@ -76,7 +76,7 @@
>>> fi
>>> rm -f conftest.out > /dev/null 2>&1 ])
>>>
>>> - AC_DEFINE_UNQUOTED([OMPI_FORTRAN_HANDLE_MAX],
>>> + AC_DEFINE_UNQUOTED([OPAL_FORTRAN_HANDLE_MAX],
>>> [$ompi_cv_f77_fortran_handle_max],
>>> [Max handle value for fortran MPI handles, effectively
>>> min(INT_MAX, max fortran INTEGER value)])
>>> ])dnl
>>>
>>> Modified: trunk/config/f77_get_value_true.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f77_get_value_true.m4 (original)
>>> +++ trunk/config/f77_get_value_true.m4 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -35,7 +35,7 @@
>>> #
>>> # C module
>>> # We really need the confdefs.h Header file for
>>> - # the ompi_fortran_logical_t definition
>>> + # the opal_fortran_logical_t definition
>>> #
>>> if test \! -f confdefs.h ; then
>>> AC_MSG_WARN([*** Problem running configure test!])
>>> @@ -53,19 +53,19 @@
>>> extern "C" {
>>> #endif
>>>
>>> -void $ompi_print_logical_fn(ompi_fortran_logical_t * logical);
>>> +void $ompi_print_logical_fn(opal_fortran_logical_t * logical);
>>>
>>> -void $ompi_print_logical_fn(ompi_fortran_logical_t * logical)
>>> +void $ompi_print_logical_fn(opal_fortran_logical_t * logical)
>>> {
>>> FILE *f=fopen("conftestval", "w");
>>> if (!f) exit(1);
>>>
>>> - if( SIZEOF_INT >= sizeof(ompi_fortran_logical_t) ) {
>>> + if( SIZEOF_INT >= sizeof(opal_fortran_logical_t) ) {
>>> fprintf(f, "%d\n", (int)*logical);
>>> - } else if (SIZEOF_LONG >= sizeof(ompi_fortran_logical_t) ) {
>>> + } else if (SIZEOF_LONG >= sizeof(opal_fortran_logical_t) ) {
>>> fprintf(f, "%ld\n", (long) *logical);
>>> #ifdef HAVE_LONG_LONG
>>> - } else if (SIZEOF_LONG_LONG >= sizeof(ompi_fortran_logical_t) ) {
>>> + } else if (SIZEOF_LONG_LONG >= sizeof(opal_fortran_logical_t) ) {
>>> fprintf(f, "%lld\n", (long long) *logical);
>>> #endif
>>> } else {
>>> @@ -105,7 +105,7 @@
>>> [AC_MSG_ERROR([Could not determine value of
>>> Fotran .TRUE.. Aborting.])])])
>>> fi])
>>>
>>> - AC_DEFINE_UNQUOTED([OMPI_FORTRAN_VALUE_TRUE],
>>> + AC_DEFINE_UNQUOTED([OPAL_FORTRAN_VALUE_TRUE],
>>> [$ompi_cv_f77_true_value],
>>> [Fortran value for LOGICAL .TRUE. value])
>>>
>>>
>>> Modified: trunk/config/f77_purge_unsupported_kind.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f77_purge_unsupported_kind.m4 (original)
>>> +++ trunk/config/f77_purge_unsupported_kind.m4 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -24,10 +24,10 @@
>>>
>>> val=`echo $1 | cut -f2 -d'*'`
>>> type=`echo $1 | cut -f1 -d'*'`
>>> - if test "x$((OMPI_SIZEOF_FORTRAN_$type$val))" != "x$val" ; then
>>> - eval "OMPI_SIZEOF_FORTRAN_$type$val=0"
>>> - # eval "OMPI_ALIGNMENT_FORTRAN_$type$val=0"
>>> - eval "OMPI_HAVE_FORTRAN_$type$val=0"
>>> + if test "x$((OPAL_SIZEOF_FORTRAN_$type$val))" != "x$val" ; then
>>> + eval "OPAL_SIZEOF_FORTRAN_$type$val=0"
>>> + # eval "OPAL_ALIGNMENT_FORTRAN_$type$val=0"
>>> + eval "OPAL_HAVE_FORTRAN_$type$val=0"
>>> AC_MSG_RESULT([no])
>>> else
>>> AC_MSG_RESULT([yes])
>>>
>>> Modified: trunk/config/f90_check.m4
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/config/f90_check.m4 (original)
>>> +++ trunk/config/f90_check.m4 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -106,14 +106,14 @@
>>> else
>>> # If this type has an F77 counterpart, see if it's
>>> # supported.
>>> - [ofc_f77_have_type=
>>> $OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_])
>>> + [ofc_f77_have_type=
>>> $OPAL_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_])
>>> if test "$ofc_f77_have_type" = "0"; then
>>> AC_MSG_WARN([*** Corresponding Fortran 77 type ($1)
>>> not supported])
>>> AC_MSG_WARN([*** Skipping Fortran 90 type ($1)])
>>> else
>>>
>>> # Check the size of this type against its F77
>>> counterpart
>>> - [ofc_f77_sizeof=
>>> $OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_])
>>> + [ofc_f77_sizeof=
>>> $OPAL_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-
>>> zA-Z0-9_]], [_])
>>> if test "$ofc_f77_sizeof" != ""; then
>>> AC_MSG_CHECKING([if Fortran 77 and 90 type
>>> sizes match])
>>> if test "$ofc_f77_sizeof" != "$ofc_type_size";
>>> then
>>> @@ -158,15 +158,15 @@
>>> # AC_DEFINE_UNQUOTED), autoheader won't put them in the
>>> # AC_CONFIG_HEADER (or AM_CONFIG_HEADER, in our case).
>>>
>>> -
>>> AC_DEFINE_UNQUOTED
>>> ([OMPI_HAVE_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
>>> +
>>> AC_DEFINE_UNQUOTED
>>> ([OPAL_HAVE_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
>>> [$ofc_have_type],
>>> [Whether we have Fortran 90
>>> $ofc_fortran_type or not])
>>>
>>> # Save some in shell variables for later use. Have to use m4
>>> # functions here (vs. $ompi_upper_var_name, defined above)
>>> because
>>> # these need to be set at autoconf time, not configure time.
>>> - [OMPI_SIZEOF_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1],
>>> [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z])[=$ofc_type_size]
>>> -
>>> AC_SUBST
>>> ([OMPI_SIZEOF_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]))
>>> + [OPAL_SIZEOF_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1],
>>> [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z])[=$ofc_type_size]
>>> +
>>> AC_SUBST
>>> ([OPAL_SIZEOF_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*],
>>> []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]))
>>>
>>> # Clean up
>>> unset ofc_fortran_type ofc_expected_size ofc_want_range
>>> ofc_pretty_name
>>>
>>> Modified: trunk/configure.ac
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/configure.ac (original)
>>> +++ trunk/configure.ac 2009-05-30 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -271,18 +271,18 @@
>>>
>>> OMPI_C_GET_ALIGNMENT(char, OPAL_ALIGNMENT_CHAR)
>>> OMPI_C_GET_ALIGNMENT(short, OPAL_ALIGNMENT_SHORT)
>>> -OMPI_C_GET_ALIGNMENT(wchar_t, OMPI_ALIGNMENT_WCHAR)
>>> +OMPI_C_GET_ALIGNMENT(wchar_t, OPAL_ALIGNMENT_WCHAR)
>>> OMPI_C_GET_ALIGNMENT(int, OPAL_ALIGNMENT_INT)
>>> OMPI_C_GET_ALIGNMENT(long, OPAL_ALIGNMENT_LONG)
>>> if test $ac_cv_type_long_long = yes; then
>>> OMPI_C_GET_ALIGNMENT(long long, OPAL_ALIGNMENT_LONG_LONG)
>>> fi
>>> -OMPI_C_GET_ALIGNMENT(float, OMPI_ALIGNMENT_FLOAT)
>>> -OMPI_C_GET_ALIGNMENT(double, OMPI_ALIGNMENT_DOUBLE)
>>> +OMPI_C_GET_ALIGNMENT(float, OPAL_ALIGNMENT_FLOAT)
>>> +OMPI_C_GET_ALIGNMENT(double, OPAL_ALIGNMENT_DOUBLE)
>>> if test $ac_cv_type_long_double = yes; then
>>> OMPI_C_GET_ALIGNMENT(long double, OPAL_ALIGNMENT_LONG_DOUBLE)
>>> fi
>>> -OMPI_C_GET_ALIGNMENT(void *, OMPI_ALIGNMENT_VOID_P)
>>> +OMPI_C_GET_ALIGNMENT(void *, OPAL_ALIGNMENT_VOID_P)
>>>
>>> #
>>> # Does the C compiler native support "bool"? (i.e., without
>>> @@ -403,7 +403,7 @@
>>>
>>> # check for type alignments
>>>
>>> -OMPI_C_GET_ALIGNMENT(bool, OMPI_ALIGNMENT_CXX_BOOL)
>>> +OMPI_C_GET_ALIGNMENT(bool, OPAL_ALIGNMENT_CXX_BOOL)
>>> AC_LANG_POP(C++)
>>>
>>> # check if we want C++ support
>>> @@ -445,7 +445,7 @@
>>> # This allows us to mark bogus types, but still have them be a valid
>>> # [sentinel] value
>>>
>>> -AC_DEFINE([ompi_fortran_bogus_type_t], [int],
>>> +AC_DEFINE([opal_fortran_bogus_type_t], [int],
>>> [A bogus type that allows us to have sentinel type values
>>> that are still valid])
>>>
>>> # We want to set the #define's for all of these, so invoke the macros
>>> @@ -600,13 +600,13 @@
>>> # whatever is the same size as a F77 INTEGER -- for the
>>> # most-likely-will-never-occur case where F77 INTEGER is smaller than
>>> # an F90 INTEGER; see MPI-2 4.12.6.5
>>> -if test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "2"; then
>>> +if test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "2"; then
>>> OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 4, OMPI_MPI_INTEGER_KIND)
>>> -elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "4"; then
>>> +elif test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "4"; then
>>> OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 9, OMPI_MPI_INTEGER_KIND)
>>> -elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "8"; then
>>> +elif test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "8"; then
>>> OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 18,
>>> OMPI_MPI_INTEGER_KIND)
>>> -elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "16"; then
>>> +elif test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "16"; then
>>> OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 19,
>>> OMPI_MPI_INTEGER_KIND)
>>> AC_MSG_ERROR([Cannot support Fortran MPI_INTEGER_KIND!])
>>> fi
>>>
>>> Modified: trunk/contrib/platform/win32/CMakeModules/f77_check.cmake
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/contrib/platform/win32/CMakeModules/f77_check.cmake
>>> (original)
>>> +++ trunk/contrib/platform/win32/CMakeModules/f77_check.cmake
>>> 2009-05-30 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -28,13 +28,13 @@
>>> SET(NEED_RECHECK TRUE)
>>>
>>> # do we need to check all the features?
>>> - IF(DEFINED OMPI_HAVE_FORTRAN_${TYPE_NAME})
>>> + IF(DEFINED OPAL_HAVE_FORTRAN_${TYPE_NAME})
>>> IF(${F77_SETUP_${TYPE_NAME}} STREQUAL ${OMPI_WANT_F77_BINDINGS})
>>> SET(NEED_RECHECK FALSE)
>>> ELSE(${F77_SETUP_${TYPE_NAME}} STREQUAL $
>>> {OMPI_WANT_F77_BINDINGS})
>>> SET(NEED_RECHECK TRUE)
>>> ENDIF(${F77_SETUP_${TYPE_NAME}} STREQUAL $
>>> {OMPI_WANT_F77_BINDINGS})
>>> - ENDIF(DEFINED OMPI_HAVE_FORTRAN_${TYPE_NAME})
>>> + ENDIF(DEFINED OPAL_HAVE_FORTRAN_${TYPE_NAME})
>>>
>>> # use this variable to check whether user changed F77 option.
>>> # every time OMPI_WANT_F77_BINDINGS got changed, we need to re-
>>> check everything.
>>> @@ -51,7 +51,7 @@
>>> SET(ofc_have_type 0)
>>> SET(ofc_type_size ${SIZEOF_INT})
>>> SET(ofc_type_alignment ${SIZEOF_INT})
>>> - SET(ofc_c_type ${ompi_fortran_bogus_type_t})
>>> + SET(ofc_c_type ${opal_fortran_bogus_type_t})
>>>
>>> # Only check if we actually want the F77 bindings / have a F77
>>> # compiler. This allows us to call this macro, even if there is
>>> @@ -105,19 +105,19 @@
>>>
>>> # We always need these defines -- even if we don't have a given
>>> type,
>>> # there are some places in the code where we have to have
>>> *something*.
>>> - SET(OMPI_HAVE_FORTRAN_${TYPE_NAME} ${ofc_have_type} CACHE
>>> INTERNAL "OMPI_HAVE_FORTRAN_${TYPE_NAME}")
>>> - SET(OMPI_SIZEOF_FORTRAN_${TYPE_NAME} ${ofc_type_size} CACHE
>>> INTERNAL "OMPI_SIZEOF_FORTRAN_${TYPE_NAME}")
>>> - SET(OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME} ${ofc_type_alignment}
>>> CACHE INTERNAL "OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}")
>>> + SET(OPAL_HAVE_FORTRAN_${TYPE_NAME} ${ofc_have_type} CACHE
>>> INTERNAL "OPAL_HAVE_FORTRAN_${TYPE_NAME}")
>>> + SET(OPAL_SIZEOF_FORTRAN_${TYPE_NAME} ${ofc_type_size} CACHE
>>> INTERNAL "OPAL_SIZEOF_FORTRAN_${TYPE_NAME}")
>>> + SET(OPAL_ALIGNMENT_FORTRAN_${TYPE_NAME} ${ofc_type_alignment}
>>> CACHE INTERNAL "OPAL_ALIGNMENT_FORTRAN_${TYPE_NAME}")
>>> IF(NOT "${TYPE_LIST}" STREQUAL "")
>>> STRING(TOLOWER ${TYPE_NAME} TYPE_NAME_L)
>>> - SET(ompi_fortran_${TYPE_NAME_L}_t ${ofc_c_type} CACHE
>>> INTERNAL "ompi_fortran_${TYPE_NAME_L}_t")
>>> + SET(opal_fortran_${TYPE_NAME_L}_t ${ofc_c_type} CACHE
>>> INTERNAL "opal_fortran_${TYPE_NAME_L}_t")
>>> ENDIF(NOT "${TYPE_LIST}" STREQUAL "")
>>>
>>> - #MESSAGE("OMPI_HAVE_FORTRAN_${TYPE_NAME}:${OMPI_HAVE_FORTRAN_$
>>> {TYPE_NAME}}")
>>> - #MESSAGE("OMPI_SIZEOF_FORTRAN_${TYPE_NAME}:$
>>> {OMPI_SIZEOF_FORTRAN_${TYPE_NAME}}")
>>> - #MESSAGE("OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}:$
>>> {OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}}")
>>> - #MESSAGE("ompi_fortran_${TYPE_NAME_L}_t:${ompi_fortran_$
>>> {TYPE_NAME_L}_t}")
>>> + #MESSAGE("OPAL_HAVE_FORTRAN_${TYPE_NAME}:${OPAL_HAVE_FORTRAN_$
>>> {TYPE_NAME}}")
>>> + #MESSAGE("OPAL_SIZEOF_FORTRAN_${TYPE_NAME}:$
>>> {OPAL_SIZEOF_FORTRAN_${TYPE_NAME}}")
>>> + #MESSAGE("OPAL_ALIGNMENT_FORTRAN_${TYPE_NAME}:$
>>> {OPAL_ALIGNMENT_FORTRAN_${TYPE_NAME}}")
>>> + #MESSAGE("opal_fortran_${TYPE_NAME_L}_t:${opal_fortran_$
>>> {TYPE_NAME_L}_t}")
>>>
>>> ENDIF(NEED_RECHECK)
>>>
>>> -ENDMACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
>>> \ No newline at end of file
>>> +ENDMACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
>>>
>>> Modified: trunk/contrib/platform/win32/CMakeModules/
>>> f77_check_real16_c_equiv.cmake
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/contrib/platform/win32/CMakeModules/
>>> f77_check_real16_c_equiv.cmake (original)
>>> +++ trunk/contrib/platform/win32/CMakeModules/
>>> f77_check_real16_c_equiv.cmake 2009-05-30 11:54:29 EDT (Sat, 30
>>> May 2009)
>>> @@ -12,11 +12,11 @@
>>> # OMPI_F77_CHECK_REAL16_C_EQUIV
>>> # ----------------------------------------------------
>>> MACRO(OMPI_F77_CHECK_REAL16_C_EQUIV)
>>> - SET(OMPI_REAL16_MATCHES_C 0)
>>> - #MESSAGE(STATUS "OMPI_HAVE_FORTRAN_REAL16:$
>>> {OMPI_HAVE_FORTRAN_REAL16}")
>>> + SET(OPAL_REAL16_MATCHES_C 0)
>>> + #MESSAGE(STATUS "OPAL_HAVE_FORTRAN_REAL16:$
>>> {OPAL_HAVE_FORTRAN_REAL16}")
>>>
>>> IF(OMPI_WANT_F77_BINDINGS)
>>> - IF(OMPI_HAVE_FORTRAN_REAL16)
>>> + IF(OPAL_HAVE_FORTRAN_REAL16)
>>> OMPI_F77_MAKE_C_FUNCTION(c ompi_ac_c_fn)
>>> FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/
>>> CMakeTmp/conftest_c.c
>>> "#include <stdio.h>"
>>> @@ -67,15 +67,15 @@
>>> # read out type size value from the file, and write back
>>> to the output variable
>>> FILE(READ ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/
>>> CMakeTmp/conftestval ${OUTPUT_VARIABLE})
>>> MESSAGE(STATUS "Check if REAL*16 bit-matches C...$
>>> {OUTPUT_VARIABLE}")
>>> - SET(OMPI_REAL16_MATCHES_C 1)
>>> + SET(OPAL_REAL16_MATCHES_C 1)
>>> ELSE(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/
>>> CMakeTmp/conftestval)
>>> MESSAGE(STATUS "Check if REAL*16 bit-matches C...failed")
>>> ENDIF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/
>>> CMakeTmp/conftestval)
>>> ENDIF(RESULT)
>>>
>>> - ELSE(OMPI_HAVE_FORTRAN_REAL16)
>>> + ELSE(OPAL_HAVE_FORTRAN_REAL16)
>>> MESSAGE(STATUS "Check if REAL*16 bit-matches C...skipped")
>>> - ENDIF(OMPI_HAVE_FORTRAN_REAL16)
>>> + ENDIF(OPAL_HAVE_FORTRAN_REAL16)
>>>
>>> ENDIF(OMPI_WANT_F77_BINDINGS)
>>> ENDMACRO(OMPI_F77_CHECK_REAL16_C_EQUIV)
>>> \ No newline at end of file
>>>
>>> Modified: trunk/contrib/platform/win32/CMakeModules/
>>> ompi_configure.cmake
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/contrib/platform/win32/CMakeModules/
>>> ompi_configure.cmake (original)
>>> +++ trunk/contrib/platform/win32/CMakeModules/
>>> ompi_configure.cmake 2009-05-30 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -1115,7 +1115,7 @@
>>>
>>> # This allows us to mark bogus types, but still have them be a valid
>>> # [sentinel] value
>>> -SET(ompi_fortran_bogus_type_t "int")
>>> +SET(opal_fortran_bogus_type_t "int")
>>>
>>> # We want to set the #define's for all of these, so invoke the macros
>>> # regardless of whether we have F77 support or not.
>>> @@ -1205,17 +1205,17 @@
>>>
>>> #/* Max handle value for fortran MPI handles, effectively
>>> min(INT_MAX, max
>>> # fortran INTEGER value) */
>>> -#/* #undef OMPI_FORTRAN_HANDLE_MAX */
>>> +#/* #undef OPAL_FORTRAN_HANDLE_MAX */
>>> # Need to be fixed.
>>> IF(WIN32)
>>> - SET (OMPI_FORTRAN_HANDLE_MAX "2147483647")
>>> + SET (OPAL_FORTRAN_HANDLE_MAX "2147483647")
>>> ENDIF(WIN32)
>>> #
>>> #/* Fortran value for LOGICAL .TRUE. value */
>>> -#/* #undef OMPI_FORTRAN_VALUE_TRUE */
>>> +#/* #undef OPAL_FORTRAN_VALUE_TRUE */
>>> # Need to be fixed.
>>> IF(WIN32)
>>> - SET (OMPI_FORTRAN_VALUE_TRUE 0)
>>> + SET (OPAL_FORTRAN_VALUE_TRUE 0)
>>> ENDIF(WIN32)
>>>
>>>
>>> @@ -1227,58 +1227,58 @@
>>> #/* #undef OMPI_F90 */
>>>
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_COMPLEX */
>>> +#/* #undef OPAL_HAVE_F90_COMPLEX */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_COMPLEX16 */
>>> +#/* #undef OPAL_HAVE_F90_COMPLEX16 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_COMPLEX32 */
>>> +#/* #undef OPAL_HAVE_F90_COMPLEX32 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_COMPLEX8 */
>>> +#/* #undef OPAL_HAVE_F90_COMPLEX8 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_DOUBLE_COMPLEX */
>>> +#/* #undef OPAL_HAVE_F90_DOUBLE_COMPLEX */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_DOUBLE_PRECISION */
>>> +#/* #undef OPAL_HAVE_F90_DOUBLE_PRECISION */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_INTEGER */
>>> +#/* #undef OPAL_HAVE_F90_INTEGER */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_INTEGER1 */
>>> +#/* #undef OPAL_HAVE_F90_INTEGER1 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_INTEGER16 */
>>> +#/* #undef OPAL_HAVE_F90_INTEGER16 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_INTEGER2 */
>>> +#/* #undef OPAL_HAVE_F90_INTEGER2 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_INTEGER4 */
>>> +#/* #undef OPAL_HAVE_F90_INTEGER4 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_INTEGER8 */
>>> +#/* #undef OPAL_HAVE_F90_INTEGER8 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_LOGICAL */
>>> +#/* #undef OPAL_HAVE_F90_LOGICAL */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_REAL */
>>> +#/* #undef OPAL_HAVE_F90_REAL */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_REAL16 */
>>> +#/* #undef OPAL_HAVE_F90_REAL16 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_REAL2 */
>>> +#/* #undef OPAL_HAVE_F90_REAL2 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_REAL4 */
>>> +#/* #undef OPAL_HAVE_F90_REAL4 */
>>> #
>>> #/* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#/* #undef OMPI_HAVE_F90_REAL8 */
>>> +#/* #undef OPAL_HAVE_F90_REAL8 */
>>> #
>>>
>>>
>>> #########################################################################
>>> ################## @@ -1729,127 +1729,127 @@
>>> #
>>> #/* A bogus type that allows us to have sentinel type values that
>>> are still
>>> # valid */
>>> -#/* #undef ompi_fortran_bogus_type_t */
>>> +#/* #undef opal_fortran_bogus_type_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_bogus_type_t 1)
>>> -# SET(ompi_fortran_bogus_type_t_STRING "int")
>>> +# SET(opal_fortran_bogus_type_t 1)
>>> +# SET(opal_fortran_bogus_type_t_STRING "int")
>>> #ENDIF(WIN32)
>>> #
>>> #/* C type corresponding to Fortran 77 COMPLEX*16 */
>>> -#/* #undef ompi_fortran_complex16_t */
>>> +#/* #undef opal_fortran_complex16_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_complex16_t 1)
>>> -# SET(ompi_fortran_complex16_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_complex16_t 1)
>>> +# SET(opal_fortran_complex16_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 COMPLEX*32 */
>>> -##/* #undef ompi_fortran_complex32_t */
>>> +##/* #undef opal_fortran_complex32_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_complex32_t 1)
>>> -# SET(ompi_fortran_complex32_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_complex32_t 1)
>>> +# SET(opal_fortran_complex32_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 COMPLEX*8 */
>>> -##/* #undef ompi_fortran_complex8_t */
>>> +##/* #undef opal_fortran_complex8_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_complex8_t 1)
>>> -# SET(ompi_fortran_complex8_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_complex8_t 1)
>>> +# SET(opal_fortran_complex8_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 COMPLEX */
>>> -##/* #undef ompi_fortran_complex_t */
>>> +##/* #undef opal_fortran_complex_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_complex_t 1)
>>> -# SET(ompi_fortran_complex_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_complex_t 1)
>>> +# SET(opal_fortran_complex_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 DOUBLE PRECISION */
>>> -##/* #undef ompi_fortran_double_precision_t */
>>> +##/* #undef opal_fortran_double_precision_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_double_precision_t 1)
>>> -# SET(ompi_fortran_double_precision_t_STRING
>>> "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_double_precision_t 1)
>>> +# SET(opal_fortran_double_precision_t_STRING
>>> "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 INTEGER*16 */
>>> -##/* #undef ompi_fortran_integer16_t */
>>> +##/* #undef opal_fortran_integer16_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_integer16_t 1)
>>> -# SET(ompi_fortran_integer16_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_integer16_t 1)
>>> +# SET(opal_fortran_integer16_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 INTEGER*1 */
>>> -##/* #undef ompi_fortran_integer1_t */
>>> +##/* #undef opal_fortran_integer1_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_integer1_t 1)
>>> -# SET(ompi_fortran_integer1_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_integer1_t 1)
>>> +# SET(opal_fortran_integer1_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 INTEGER*2 */
>>> -##/* #undef ompi_fortran_integer2_t */
>>> +##/* #undef opal_fortran_integer2_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_integer2_t 1)
>>> -# SET(ompi_fortran_integer2_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_integer2_t 1)
>>> +# SET(opal_fortran_integer2_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 INTEGER*4 */
>>> -##/* #undef ompi_fortran_integer4_t */
>>> +##/* #undef opal_fortran_integer4_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_integer4_t 1)
>>> -# SET(ompi_fortran_integer4_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_integer4_t 1)
>>> +# SET(opal_fortran_integer4_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 INTEGER*8 */
>>> -##/* #undef ompi_fortran_integer8_t */
>>> +##/* #undef opal_fortran_integer8_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_integer8_t 1)
>>> -# SET(ompi_fortran_integer8_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_integer8_t 1)
>>> +# SET(opal_fortran_integer8_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 INTEGER */
>>> -##/* #undef ompi_fortran_integer_t */
>>> +##/* #undef opal_fortran_integer_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_integer_t 1)
>>> -# SET(ompi_fortran_integer_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_integer_t 1)
>>> +# SET(opal_fortran_integer_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 LOGICAL */
>>> -##/* #undef ompi_fortran_logical_t */
>>> +##/* #undef opal_fortran_logical_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_logical_t 1)
>>> -# SET(ompi_fortran_logical_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_logical_t 1)
>>> +# SET(opal_fortran_logical_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 REAL*16 */
>>> -##/* #undef ompi_fortran_real16_t */
>>> +##/* #undef opal_fortran_real16_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_real16_t 1)
>>> -# SET(ompi_fortran_real16_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_real16_t 1)
>>> +# SET(opal_fortran_real16_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 REAL*2 */
>>> -##/* #undef ompi_fortran_real2_t */
>>> +##/* #undef opal_fortran_real2_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_real2_t 1)
>>> -# SET(ompi_fortran_real2_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_real2_t 1)
>>> +# SET(opal_fortran_real2_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 REAL*4 */
>>> -##/* #undef ompi_fortran_real4_t */
>>> +##/* #undef opal_fortran_real4_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_real4_t 1)
>>> -# SET(ompi_fortran_real4_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_real4_t 1)
>>> +# SET(opal_fortran_real4_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 REAL*8 */
>>> -##/* #undef ompi_fortran_real8_t */
>>> +##/* #undef opal_fortran_real8_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_real8_t 1)
>>> -# SET(ompi_fortran_real8_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_real8_t 1)
>>> +# SET(opal_fortran_real8_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>> ##
>>> ##/* C type corresponding to Fortran 77 REAL */
>>> -##/* #undef ompi_fortran_real_t */
>>> +##/* #undef opal_fortran_real_t */
>>> #IF(WIN32)
>>> -# SET(ompi_fortran_real_t 1)
>>> -# SET(ompi_fortran_real_t_STRING "ompi_fortran_bogus_type_t")
>>> +# SET(opal_fortran_real_t 1)
>>> +# SET(opal_fortran_real_t_STRING "opal_fortran_bogus_type_t")
>>> #ENDIF(WIN32)
>>>
>>> Modified: trunk/contrib/platform/win32/ConfigFiles/mpi.h.cmake
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/contrib/platform/win32/ConfigFiles/mpi.h.cmake
>>> (original)
>>> +++ trunk/contrib/platform/win32/ConfigFiles/mpi.h.cmake
>>> 2009-05-30 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -65,43 +65,43 @@
>>> #cmakedefine OPAL_SIZEOF_INT ${SIZEOF_INT}
>>>
>>> /* Whether we have FORTRAN LOGICAL*1 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL1 ${OMPI_HAVE_FORTRAN_LOGICAL1}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL1 ${OPAL_HAVE_FORTRAN_LOGICAL1}
>>>
>>> /* Whether we have FORTRAN LOGICAL*2 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL2 ${OMPI_HAVE_FORTRAN_LOGICAL2}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL2 ${OPAL_HAVE_FORTRAN_LOGICAL2}
>>>
>>> /* Whether we have FORTRAN LOGICAL*4 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL4 ${OMPI_HAVE_FORTRAN_LOGICAL4}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL4 ${OPAL_HAVE_FORTRAN_LOGICAL4}
>>>
>>> /* Whether we have FORTRAN LOGICAL*8 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL8 ${OMPI_HAVE_FORTRAN_LOGICAL8}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL8 ${OPAL_HAVE_FORTRAN_LOGICAL8}
>>>
>>> /* Whether we have FORTRAN INTEGER*1 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER1 ${OMPI_HAVE_FORTRAN_INTEGER1}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER1 ${OPAL_HAVE_FORTRAN_INTEGER1}
>>>
>>> /* Whether we have FORTRAN INTEGER*16 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER16 ${OMPI_HAVE_FORTRAN_INTEGER16}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER16 ${OPAL_HAVE_FORTRAN_INTEGER16}
>>>
>>> /* Whether we have FORTRAN INTEGER*2 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER2 ${OMPI_HAVE_FORTRAN_INTEGER2}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER2 ${OPAL_HAVE_FORTRAN_INTEGER2}
>>>
>>> /* Whether we have FORTRAN INTEGER*4 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER4 ${OMPI_HAVE_FORTRAN_INTEGER4}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER4 ${OPAL_HAVE_FORTRAN_INTEGER4}
>>>
>>> /* Whether we have FORTRAN INTEGER*8 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER8 ${OMPI_HAVE_FORTRAN_INTEGER8}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER8 ${OPAL_HAVE_FORTRAN_INTEGER8}
>>>
>>> /* Whether we have FORTRAN REAL*16 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL16 ${OMPI_HAVE_FORTRAN_REAL16}
>>> +#define OPAL_HAVE_FORTRAN_REAL16 ${OPAL_HAVE_FORTRAN_REAL16}
>>>
>>> /* Whether we have FORTRAN REAL*2 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL2 ${OMPI_HAVE_FORTRAN_REAL2}
>>> +#define OPAL_HAVE_FORTRAN_REAL2 ${OPAL_HAVE_FORTRAN_REAL2}
>>>
>>> /* Whether we have FORTRAN REAL*4 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL4 ${OMPI_HAVE_FORTRAN_REAL4}
>>> +#define OPAL_HAVE_FORTRAN_REAL4 ${OPAL_HAVE_FORTRAN_REAL4}
>>>
>>> /* Whether we have FORTRAN REAL*8 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL8 ${OMPI_HAVE_FORTRAN_REAL8}
>>> +#define OPAL_HAVE_FORTRAN_REAL8 ${OPAL_HAVE_FORTRAN_REAL8}
>>>
>>> /* Type of MPI_Offset -- has to be defined here and typedef'ed
>>> later because mpi.h does not get AC SUBST's */
>>> #cmakedefine OMPI_MPI_OFFSET_TYPE ${OMPI_MPI_OFFSET_TYPE_STRING}
>>> @@ -144,10 +144,10 @@
>>>
>>> /* A type that allows us to have sentinel type values that are still
>>> valid */
>>> -#cmakedefine ompi_fortran_bogus_type_t ${ompi_fortran_bogus_type_t}
>>> +#cmakedefine opal_fortran_bogus_type_t ${opal_fortran_bogus_type_t}
>>>
>>> /* C type corresponding to FORTRAN INTEGER */
>>> -#cmakedefine ompi_fortran_integer_t ${ompi_fortran_integer_t}
>>> +#cmakedefine opal_fortran_integer_t ${opal_fortran_integer_t}
>>>
>>> /* Whether C compiler supports -fvisibility */
>>> #cmakedefine OPAL_C_HAVE_VISIBILITY ${OPAL_C_HAVE_VISIBILITY}
>>> @@ -175,8 +175,8 @@
>>> #endif
>>>
>>> #ifndef MPI_Fint
>>> -/* MPI_Fint is the same as ompi_fortran_INTEGER_t */
>>> -#define MPI_Fint ompi_fortran_integer_t
>>> +/* MPI_Fint is the same as opal_fortran_integer_t */
>>> +#define MPI_Fint opal_fortran_integer_t
>>> #endif
>>>
>>> #endif /* #ifndef OMPI_CONFIG_H */
>>> @@ -747,52 +747,52 @@
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_cxx_bool;
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_2cplex, ompi_mpi_2dblcplex;
>>> /* other MPI2 datatypes */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL1
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL1
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical1;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL2
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL2
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical2;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL4
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical4;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL8
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer1;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer2;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer4;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer16;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real2;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real4;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real16;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_complex8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_complex16;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_complex32;
>>> #endif
>>>
>>> @@ -866,53 +866,53 @@
>>> /* Fortran datatype bindings */
>>> #define MPI_CHARACTER OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_character)
>>> #define MPI_LOGICAL OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logic)
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL1
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL1
>>> #define MPI_LOGICAL1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical1)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL2
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL2
>>> #define MPI_LOGICAL2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical2)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL4
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL4
>>> #define MPI_LOGICAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical4)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL8
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL8
>>> #define MPI_LOGICAL8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical8)
>>> #endif
>>> #define MPI_INTEGER OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer)
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> #define MPI_INTEGER1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer1)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> #define MPI_INTEGER2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer2)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> #define MPI_INTEGER4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer4)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> #define MPI_INTEGER8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer8)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> #define MPI_INTEGER16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer16)
>>> #endif
>>> #define MPI_REAL OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_real)
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define MPI_REAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_real4)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define MPI_REAL8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_real8)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define MPI_REAL16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_real16)
>>> #endif
>>> #define MPI_DOUBLE_PRECISION OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_dblprec)
>>> #define MPI_COMPLEX OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_cplex)
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define MPI_COMPLEX8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_complex8)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define MPI_COMPLEX16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_complex16)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define MPI_COMPLEX32 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_complex32)
>>> #endif
>>> #define MPI_DOUBLE_COMPLEX OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_dblcplex)
>>>
>>> Modified: trunk/contrib/platform/win32/ConfigFiles/opal_config.h.cmake
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/contrib/platform/win32/ConfigFiles/
>>> opal_config.h.cmake (original)
>>> +++ trunk/contrib/platform/win32/ConfigFiles/
>>> opal_config.h.cmake 2009-05-30 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -637,76 +637,76 @@
>>> #define OPAL_ALIGNMENT_CHAR ${CHAR_ALIGNMENT}
>>>
>>> /* Alignment of type bool */
>>> -#define OMPI_ALIGNMENT_CXX_BOOL ${BOOL_ALIGNMENT}
>>> +#define OPAL_ALIGNMENT_CXX_BOOL ${BOOL_ALIGNMENT}
>>>
>>> /* Alignment of type double */
>>> -#define OMPI_ALIGNMENT_DOUBLE ${DOUBLE_ALIGNMENT}
>>> +#define OPAL_ALIGNMENT_DOUBLE ${DOUBLE_ALIGNMENT}
>>>
>>> /* Alignment of type float */
>>> -#define OMPI_ALIGNMENT_FLOAT ${FLOAT_ALIGNMENT}
>>> +#define OPAL_ALIGNMENT_FLOAT ${FLOAT_ALIGNMENT}
>>>
>>> /* Alignment of Fortran 77 COMPLEX */
>>> -#define OMPI_ALIGNMENT_FORTRAN_COMPLEX $
>>> {OMPI_ALIGNMENT_FORTRAN_COMPLEX}
>>> +#define OPAL_ALIGNMENT_FORTRAN_COMPLEX $
>>> {OPAL_ALIGNMENT_FORTRAN_COMPLEX}
>>>
>>> /* Alignment of Fortran 77 COMPLEX*16 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_COMPLEX16 $
>>> {OMPI_ALIGNMENT_FORTRAN_COMPLEX16}
>>> +#define OPAL_ALIGNMENT_FORTRAN_COMPLEX16 $
>>> {OPAL_ALIGNMENT_FORTRAN_COMPLEX16}
>>>
>>> /* Alignment of Fortran 77 COMPLEX*32 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_COMPLEX32 $
>>> {OMPI_ALIGNMENT_FORTRAN_COMPLEX32}
>>> +#define OPAL_ALIGNMENT_FORTRAN_COMPLEX32 $
>>> {OPAL_ALIGNMENT_FORTRAN_COMPLEX32}
>>>
>>> /* Alignment of Fortran 77 COMPLEX*8 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_COMPLEX8 $
>>> {OMPI_ALIGNMENT_FORTRAN_COMPLEX8}
>>> +#define OPAL_ALIGNMENT_FORTRAN_COMPLEX8 $
>>> {OPAL_ALIGNMENT_FORTRAN_COMPLEX8}
>>>
>>> /* Alignment of Fortran 77 DOUBLE PRECISION */
>>> -#define OMPI_ALIGNMENT_FORTRAN_DOUBLE_PRECISION $
>>> {OMPI_ALIGNMENT_FORTRAN_DOUBLE_PRECISION}
>>> +#define OPAL_ALIGNMENT_FORTRAN_DOUBLE_PRECISION $
>>> {OPAL_ALIGNMENT_FORTRAN_DOUBLE_PRECISION}
>>>
>>> /* Alignment of Fortran 77 INTEGER */
>>> -#define OMPI_ALIGNMENT_FORTRAN_INTEGER $
>>> {OMPI_ALIGNMENT_FORTRAN_INTEGER}
>>> +#define OPAL_ALIGNMENT_FORTRAN_INTEGER $
>>> {OPAL_ALIGNMENT_FORTRAN_INTEGER}
>>>
>>> /* Alignment of Fortran 77 INTEGER*1 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_INTEGER1 $
>>> {OMPI_ALIGNMENT_FORTRAN_INTEGER1}
>>> +#define OPAL_ALIGNMENT_FORTRAN_INTEGER1 $
>>> {OPAL_ALIGNMENT_FORTRAN_INTEGER1}
>>>
>>> /* Alignment of Fortran 77 INTEGER*16 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_INTEGER16 $
>>> {OMPI_ALIGNMENT_FORTRAN_INTEGER16}
>>> +#define OPAL_ALIGNMENT_FORTRAN_INTEGER16 $
>>> {OPAL_ALIGNMENT_FORTRAN_INTEGER16}
>>>
>>> /* Alignment of Fortran 77 INTEGER*2 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_INTEGER2 $
>>> {OMPI_ALIGNMENT_FORTRAN_INTEGER2}
>>> +#define OPAL_ALIGNMENT_FORTRAN_INTEGER2 $
>>> {OPAL_ALIGNMENT_FORTRAN_INTEGER2}
>>>
>>> /* Alignment of Fortran 77 INTEGER*4 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_INTEGER4 $
>>> {OMPI_ALIGNMENT_FORTRAN_INTEGER4}
>>> +#define OPAL_ALIGNMENT_FORTRAN_INTEGER4 $
>>> {OPAL_ALIGNMENT_FORTRAN_INTEGER4}
>>>
>>> /* Alignment of Fortran 77 INTEGER*8 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_INTEGER8 $
>>> {OMPI_ALIGNMENT_FORTRAN_INTEGER8}
>>> +#define OPAL_ALIGNMENT_FORTRAN_INTEGER8 $
>>> {OPAL_ALIGNMENT_FORTRAN_INTEGER8}
>>>
>>> /* Alignment of Fortran 77 LOGICAL */
>>> -#define OMPI_ALIGNMENT_FORTRAN_LOGICAL $
>>> {OMPI_ALIGNMENT_FORTRAN_LOGICAL}
>>> +#define OPAL_ALIGNMENT_FORTRAN_LOGICAL $
>>> {OPAL_ALIGNMENT_FORTRAN_LOGICAL}
>>>
>>> /* Alignment of Fortran 77 LOGICAL*1 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_LOGICAL1 $
>>> {OMPI_ALIGNMENT_FORTRAN_LOGICAL1}
>>> +#define OPAL_ALIGNMENT_FORTRAN_LOGICAL1 $
>>> {OPAL_ALIGNMENT_FORTRAN_LOGICAL1}
>>>
>>> /* Alignment of Fortran 77 LOGICAL*2 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_LOGICAL2 $
>>> {OMPI_ALIGNMENT_FORTRAN_LOGICAL2}
>>> +#define OPAL_ALIGNMENT_FORTRAN_LOGICAL2 $
>>> {OPAL_ALIGNMENT_FORTRAN_LOGICAL2}
>>>
>>> /* Alignment of Fortran 77 LOGICAL*4 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_LOGICAL4 $
>>> {OMPI_ALIGNMENT_FORTRAN_LOGICAL4}
>>> +#define OPAL_ALIGNMENT_FORTRAN_LOGICAL4 $
>>> {OPAL_ALIGNMENT_FORTRAN_LOGICAL4}
>>>
>>> /* Alignment of Fortran 77 LOGICAL*8 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_LOGICAL8 $
>>> {OMPI_ALIGNMENT_FORTRAN_LOGICAL8}
>>> +#define OPAL_ALIGNMENT_FORTRAN_LOGICAL8 $
>>> {OPAL_ALIGNMENT_FORTRAN_LOGICAL8}
>>>
>>> /* Alignment of Fortran 77 REAL */
>>> -#define OMPI_ALIGNMENT_FORTRAN_REAL ${OMPI_ALIGNMENT_FORTRAN_REAL}
>>> +#define OPAL_ALIGNMENT_FORTRAN_REAL ${OPAL_ALIGNMENT_FORTRAN_REAL}
>>>
>>> /* Alignment of Fortran 77 REAL*16 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_REAL16 $
>>> {OMPI_ALIGNMENT_FORTRAN_REAL16}
>>> +#define OPAL_ALIGNMENT_FORTRAN_REAL16 $
>>> {OPAL_ALIGNMENT_FORTRAN_REAL16}
>>>
>>> /* Alignment of Fortran 77 REAL*2 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_REAL2 ${OMPI_ALIGNMENT_FORTRAN_REAL2}
>>> +#define OPAL_ALIGNMENT_FORTRAN_REAL2 ${OPAL_ALIGNMENT_FORTRAN_REAL2}
>>>
>>> /* Alignment of Fortran 77 REAL*4 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_REAL4 ${OMPI_ALIGNMENT_FORTRAN_REAL4}
>>> +#define OPAL_ALIGNMENT_FORTRAN_REAL4 ${OPAL_ALIGNMENT_FORTRAN_REAL4}
>>>
>>> /* Alignment of Fortran 77 REAL*8 */
>>> -#define OMPI_ALIGNMENT_FORTRAN_REAL8 ${OMPI_ALIGNMENT_FORTRAN_REAL8}
>>> +#define OPAL_ALIGNMENT_FORTRAN_REAL8 ${OPAL_ALIGNMENT_FORTRAN_REAL8}
>>>
>>> /* Alignment of type int */
>>> #define OPAL_ALIGNMENT_INT ${INT_ALIGNMENT}
>>> @@ -724,10 +724,10 @@
>>> #define OPAL_ALIGNMENT_SHORT ${SHORT_ALIGNMENT}
>>>
>>> /* Alignment of type void * */
>>> -#define OMPI_ALIGNMENT_VOID_P ${VOID_P_ALIGNMENT}
>>> +#define OPAL_ALIGNMENT_VOID_P ${VOID_P_ALIGNMENT}
>>>
>>> /* Alignment of type wchar_t */
>>> -#define OMPI_ALIGNMENT_WCHAR ${WCHAR_T_ALIGNMENT}
>>> +#define OPAL_ALIGNMENT_WCHAR ${WCHAR_T_ALIGNMENT}
>>>
>>> /* OMPI architecture string */
>>> #define OPAL_ARCH "${CMAKE_SYSTEM_PROCESSOR} ${CMAKE_SYSTEM}"
>>> @@ -852,10 +852,10 @@
>>>
>>> /* Max handle value for fortran MPI handles, effectively
>>> min(INT_MAX, max
>>> fortran INTEGER value) */
>>> -#cmakedefine OMPI_FORTRAN_HANDLE_MAX ${OMPI_FORTRAN_HANDLE_MAX}
>>> +#cmakedefine OPAL_FORTRAN_HANDLE_MAX ${OPAL_FORTRAN_HANDLE_MAX}
>>>
>>> /* Fortran value for LOGICAL .TRUE. value */
>>> -#define OMPI_FORTRAN_VALUE_TRUE ${OMPI_FORTRAN_VALUE_TRUE}
>>> +#define OPAL_FORTRAN_VALUE_TRUE ${OPAL_FORTRAN_VALUE_TRUE}
>>>
>>> /* Greek - alpha, beta, etc - release number of Open MPI */
>>> #cmakedefine OMPI_GREEK_VERSION "${OMPI_GREEK_VERSION_STRING}"
>>> @@ -927,123 +927,123 @@
>>> #define OMPI_HAVE_CXX_EXCEPTION_SUPPORT $
>>> {OMPI_HAVE_CXX_EXCEPTION_SUPPORT}
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_COMPLEX
>>> +#cmakedefine OPAL_HAVE_F90_COMPLEX
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_COMPLEX16
>>> +#cmakedefine OPAL_HAVE_F90_COMPLEX16
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_COMPLEX32
>>> +#cmakedefine OPAL_HAVE_F90_COMPLEX32
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_COMPLEX8
>>> +#cmakedefine OPAL_HAVE_F90_COMPLEX8
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_DOUBLE_COMPLEX
>>> +#cmakedefine OPAL_HAVE_F90_DOUBLE_COMPLEX
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_DOUBLE_PRECISION
>>> +#cmakedefine OPAL_HAVE_F90_DOUBLE_PRECISION
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_INTEGER
>>> +#cmakedefine OPAL_HAVE_F90_INTEGER
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_INTEGER1
>>> +#cmakedefine OPAL_HAVE_F90_INTEGER1
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_INTEGER16
>>> +#cmakedefine OPAL_HAVE_F90_INTEGER16
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_INTEGER2
>>> +#cmakedefine OPAL_HAVE_F90_INTEGER2
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_INTEGER4
>>> +#cmakedefine OPAL_HAVE_F90_INTEGER4
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_INTEGER8
>>> +#cmakedefine OPAL_HAVE_F90_INTEGER8
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_LOGICAL
>>> +#cmakedefine OPAL_HAVE_F90_LOGICAL
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_REAL
>>> +#cmakedefine OPAL_HAVE_F90_REAL
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_REAL16
>>> +#cmakedefine OPAL_HAVE_F90_REAL16
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_REAL2
>>> +#cmakedefine OPAL_HAVE_F90_REAL2
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_REAL4
>>> +#cmakedefine OPAL_HAVE_F90_REAL4
>>>
>>> /* Whether we have Fortran 90 $ofc_fortran_type or not */
>>> -#cmakedefine OMPI_HAVE_F90_REAL8
>>> +#cmakedefine OPAL_HAVE_F90_REAL8
>>>
>>> /* Whether we have Fortran 77 COMPLEX or not */
>>> -#define OMPI_HAVE_FORTRAN_COMPLEX ${OMPI_HAVE_FORTRAN_COMPLEX}
>>> +#define OPAL_HAVE_FORTRAN_COMPLEX ${OPAL_HAVE_FORTRAN_COMPLEX}
>>>
>>> /* Whether we have Fortran 77 COMPLEX*16 or not */
>>> -#define OMPI_HAVE_FORTRAN_COMPLEX16 ${OMPI_HAVE_FORTRAN_COMPLEX16}
>>> +#define OPAL_HAVE_FORTRAN_COMPLEX16 ${OPAL_HAVE_FORTRAN_COMPLEX16}
>>>
>>> /* Whether we have Fortran 77 COMPLEX*32 or not */
>>> -#define OMPI_HAVE_FORTRAN_COMPLEX32 ${OMPI_HAVE_FORTRAN_COMPLEX32}
>>> +#define OPAL_HAVE_FORTRAN_COMPLEX32 ${OPAL_HAVE_FORTRAN_COMPLEX32}
>>>
>>> /* Whether we have Fortran 77 COMPLEX*8 or not */
>>> -#define OMPI_HAVE_FORTRAN_COMPLEX8 ${OMPI_HAVE_FORTRAN_COMPLEX8}
>>> +#define OPAL_HAVE_FORTRAN_COMPLEX8 ${OPAL_HAVE_FORTRAN_COMPLEX8}
>>>
>>> /* Whether we have Fortran 77 DOUBLE PRECISION or not */
>>> -#define OMPI_HAVE_FORTRAN_DOUBLE_PRECISION $
>>> {OMPI_HAVE_FORTRAN_DOUBLE_PRECISION}
>>> +#define OPAL_HAVE_FORTRAN_DOUBLE_PRECISION $
>>> {OPAL_HAVE_FORTRAN_DOUBLE_PRECISION}
>>>
>>> /* Whether we have Fortran 77 INTEGER or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER ${OMPI_HAVE_FORTRAN_INTEGER}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER ${OPAL_HAVE_FORTRAN_INTEGER}
>>>
>>> /* Whether we have Fortran 77 INTEGER*1 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER1 ${OMPI_HAVE_FORTRAN_INTEGER1}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER1 ${OPAL_HAVE_FORTRAN_INTEGER1}
>>>
>>> /* Whether we have Fortran 77 INTEGER*16 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER16 ${OMPI_HAVE_FORTRAN_INTEGER16}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER16 ${OPAL_HAVE_FORTRAN_INTEGER16}
>>>
>>> /* Whether we have Fortran 77 INTEGER*2 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER2 ${OMPI_HAVE_FORTRAN_INTEGER2}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER2 ${OPAL_HAVE_FORTRAN_INTEGER2}
>>>
>>> /* Whether we have Fortran 77 INTEGER*4 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER4 ${OMPI_HAVE_FORTRAN_INTEGER4}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER4 ${OPAL_HAVE_FORTRAN_INTEGER4}
>>>
>>> /* Whether we have Fortran 77 INTEGER*8 or not */
>>> -#define OMPI_HAVE_FORTRAN_INTEGER8 ${OMPI_HAVE_FORTRAN_INTEGER8}
>>> +#define OPAL_HAVE_FORTRAN_INTEGER8 ${OPAL_HAVE_FORTRAN_INTEGER8}
>>>
>>> /* Whether we have Fortran 77 LOGICAL or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL ${OMPI_HAVE_FORTRAN_LOGICAL}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL ${OPAL_HAVE_FORTRAN_LOGICAL}
>>>
>>> /* Whether we have Fortran 77 LOGICAL1 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL1 ${OMPI_HAVE_FORTRAN_LOGICAL1}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL1 ${OPAL_HAVE_FORTRAN_LOGICAL1}
>>>
>>> /* Whether we have Fortran 77 LOGICAL2 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL2 ${OMPI_HAVE_FORTRAN_LOGICAL2}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL2 ${OPAL_HAVE_FORTRAN_LOGICAL2}
>>>
>>> /* Whether we have Fortran 77 LOGICAL4 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL4 ${OMPI_HAVE_FORTRAN_LOGICAL4}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL4 ${OPAL_HAVE_FORTRAN_LOGICAL4}
>>>
>>> /* Whether we have Fortran 77 LOGICAL8 or not */
>>> -#define OMPI_HAVE_FORTRAN_LOGICAL8 ${OMPI_HAVE_FORTRAN_LOGICAL8}
>>> +#define OPAL_HAVE_FORTRAN_LOGICAL8 ${OPAL_HAVE_FORTRAN_LOGICAL8}
>>>
>>> /* Whether we have Fortran 77 REAL or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL ${OMPI_HAVE_FORTRAN_REAL}
>>> +#define OPAL_HAVE_FORTRAN_REAL ${OPAL_HAVE_FORTRAN_REAL}
>>>
>>> /* Whether we have Fortran 77 REAL*16 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL16 ${OMPI_HAVE_FORTRAN_REAL16}
>>> +#define OPAL_HAVE_FORTRAN_REAL16 ${OPAL_HAVE_FORTRAN_REAL16}
>>>
>>> /* Whether we have Fortran 77 REAL*2 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL2 ${OMPI_HAVE_FORTRAN_REAL2}
>>> +#define OPAL_HAVE_FORTRAN_REAL2 ${OPAL_HAVE_FORTRAN_REAL2}
>>>
>>> /* Whether we have Fortran 77 REAL*4 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL4 ${OMPI_HAVE_FORTRAN_REAL4}
>>> +#define OPAL_HAVE_FORTRAN_REAL4 ${OPAL_HAVE_FORTRAN_REAL4}
>>>
>>> /* Whether we have Fortran 77 REAL*8 or not */
>>> -#define OMPI_HAVE_FORTRAN_REAL8 ${OMPI_HAVE_FORTRAN_REAL8}
>>> +#define OPAL_HAVE_FORTRAN_REAL8 ${OPAL_HAVE_FORTRAN_REAL8}
>>>
>>> -#define OMPI_REAL16_MATCHES_C ${OMPI_REAL16_MATCHES_C}
>>> +#define OPAL_REAL16_MATCHES_C ${OPAL_REAL16_MATCHES_C}
>>>
>>> /* Do not use outside of mpi.h. Define to 1 if the system has the
>>> type 'long
>>> long'. */
>>> @@ -1145,67 +1145,67 @@
>>> #cmakedefine OMPI_RML_CNOS_HAVE_BARRIER
>>>
>>> /* Size of Fortran 77 COMPLEX */
>>> -#define OMPI_SIZEOF_FORTRAN_COMPLEX ${OMPI_SIZEOF_FORTRAN_COMPLEX}
>>> +#define OPAL_SIZEOF_FORTRAN_COMPLEX ${OPAL_SIZEOF_FORTRAN_COMPLEX}
>>>
>>> /* Size of Fortran 77 COMPLEX*16 */
>>> -#define OMPI_SIZEOF_FORTRAN_COMPLEX16 $
>>> {OMPI_SIZEOF_FORTRAN_COMPLEX16}
>>> +#define OPAL_SIZEOF_FORTRAN_COMPLEX16 $
>>> {OPAL_SIZEOF_FORTRAN_COMPLEX16}
>>>
>>> /* Size of Fortran 77 COMPLEX*32 */
>>> -#define OMPI_SIZEOF_FORTRAN_COMPLEX32 $
>>> {OMPI_SIZEOF_FORTRAN_COMPLEX32}
>>> +#define OPAL_SIZEOF_FORTRAN_COMPLEX32 $
>>> {OPAL_SIZEOF_FORTRAN_COMPLEX32}
>>>
>>> /* Size of Fortran 77 COMPLEX*8 */
>>> -#define OMPI_SIZEOF_FORTRAN_COMPLEX8 ${OMPI_SIZEOF_FORTRAN_COMPLEX8}
>>> +#define OPAL_SIZEOF_FORTRAN_COMPLEX8 ${OPAL_SIZEOF_FORTRAN_COMPLEX8}
>>>
>>> /* Size of Fortran 77 DOUBLE PRECISION */
>>> -#define OMPI_SIZEOF_FORTRAN_DOUBLE_PRECISION $
>>> {OMPI_SIZEOF_FORTRAN_DOUBLE_PRECISION}
>>> +#define OPAL_SIZEOF_FORTRAN_DOUBLE_PRECISION $
>>> {OPAL_SIZEOF_FORTRAN_DOUBLE_PRECISION}
>>>
>>> /* Size of Fortran 77 INTEGER */
>>> -#define OMPI_SIZEOF_FORTRAN_INTEGER ${OMPI_SIZEOF_FORTRAN_INTEGER}
>>> +#define OPAL_SIZEOF_FORTRAN_INTEGER ${OPAL_SIZEOF_FORTRAN_INTEGER}
>>>
>>> /* Size of Fortran 77 INTEGER*1 */
>>> -#define OMPI_SIZEOF_FORTRAN_INTEGER1 ${OMPI_SIZEOF_FORTRAN_INTEGER1}
>>> +#define OPAL_SIZEOF_FORTRAN_INTEGER1 ${OPAL_SIZEOF_FORTRAN_INTEGER1}
>>>
>>> /* Size of Fortran 77 INTEGER*16 */
>>> -#define OMPI_SIZEOF_FORTRAN_INTEGER16 $
>>> {OMPI_SIZEOF_FORTRAN_INTEGER16}
>>> +#define OPAL_SIZEOF_FORTRAN_INTEGER16 $
>>> {OPAL_SIZEOF_FORTRAN_INTEGER16}
>>>
>>> /* Size of Fortran 77 INTEGER*2 */
>>> -#define OMPI_SIZEOF_FORTRAN_INTEGER2 ${OMPI_SIZEOF_FORTRAN_INTEGER2}
>>> +#define OPAL_SIZEOF_FORTRAN_INTEGER2 ${OPAL_SIZEOF_FORTRAN_INTEGER2}
>>>
>>> /* Size of Fortran 77 INTEGER*4 */
>>> -#define OMPI_SIZEOF_FORTRAN_INTEGER4 ${OMPI_SIZEOF_FORTRAN_INTEGER4}
>>> +#define OPAL_SIZEOF_FORTRAN_INTEGER4 ${OPAL_SIZEOF_FORTRAN_INTEGER4}
>>>
>>> /* Size of Fortran 77 INTEGER*8 */
>>> -#define OMPI_SIZEOF_FORTRAN_INTEGER8 ${OMPI_SIZEOF_FORTRAN_INTEGER8}
>>> +#define OPAL_SIZEOF_FORTRAN_INTEGER8 ${OPAL_SIZEOF_FORTRAN_INTEGER8}
>>>
>>> /* Size of Fortran 77 LOGICAL */
>>> -#define OMPI_SIZEOF_FORTRAN_LOGICAL ${OMPI_SIZEOF_FORTRAN_LOGICAL}
>>> +#define OPAL_SIZEOF_FORTRAN_LOGICAL ${OPAL_SIZEOF_FORTRAN_LOGICAL}
>>>
>>> /* Size of Fortran 77 LOGICAL1 */
>>> -#define OMPI_SIZEOF_FORTRAN_LOGICAL1 ${OMPI_SIZEOF_FORTRAN_LOGICAL1}
>>> +#define OPAL_SIZEOF_FORTRAN_LOGICAL1 ${OPAL_SIZEOF_FORTRAN_LOGICAL1}
>>>
>>> /* Size of Fortran 77 LOGICAL2 */
>>> -#define OMPI_SIZEOF_FORTRAN_LOGICAL2 ${OMPI_SIZEOF_FORTRAN_LOGICAL2}
>>> +#define OPAL_SIZEOF_FORTRAN_LOGICAL2 ${OPAL_SIZEOF_FORTRAN_LOGICAL2}
>>>
>>> /* Size of Fortran 77 LOGICAL4 */
>>> -#define OMPI_SIZEOF_FORTRAN_LOGICAL4 ${OMPI_SIZEOF_FORTRAN_LOGICAL4}
>>> +#define OPAL_SIZEOF_FORTRAN_LOGICAL4 ${OPAL_SIZEOF_FORTRAN_LOGICAL4}
>>>
>>> /* Size of Fortran 77 LOGICAL8 */
>>> -#define OMPI_SIZEOF_FORTRAN_LOGICAL8 ${OMPI_SIZEOF_FORTRAN_LOGICAL8}
>>> +#define OPAL_SIZEOF_FORTRAN_LOGICAL8 ${OPAL_SIZEOF_FORTRAN_LOGICAL8}
>>>
>>> /* Size of Fortran 77 REAL */
>>> -#define OMPI_SIZEOF_FORTRAN_REAL ${OMPI_SIZEOF_FORTRAN_REAL}
>>> +#define OPAL_SIZEOF_FORTRAN_REAL ${OPAL_SIZEOF_FORTRAN_REAL}
>>>
>>> /* Size of Fortran 77 REAL*16 */
>>> -#define OMPI_SIZEOF_FORTRAN_REAL16 ${OMPI_SIZEOF_FORTRAN_REAL16}
>>> +#define OPAL_SIZEOF_FORTRAN_REAL16 ${OPAL_SIZEOF_FORTRAN_REAL16}
>>>
>>> /* Size of Fortran 77 REAL*2 */
>>> -#define OMPI_SIZEOF_FORTRAN_REAL2 ${OMPI_SIZEOF_FORTRAN_REAL2}
>>> +#define OPAL_SIZEOF_FORTRAN_REAL2 ${OPAL_SIZEOF_FORTRAN_REAL2}
>>>
>>> /* Size of Fortran 77 REAL*4 */
>>> -#define OMPI_SIZEOF_FORTRAN_REAL4 ${OMPI_SIZEOF_FORTRAN_REAL4}
>>> +#define OPAL_SIZEOF_FORTRAN_REAL4 ${OPAL_SIZEOF_FORTRAN_REAL4}
>>>
>>> /* Size of Fortran 77 REAL*8 */
>>> -#define OMPI_SIZEOF_FORTRAN_REAL8 ${OMPI_SIZEOF_FORTRAN_REAL8}
>>> +#define OPAL_SIZEOF_FORTRAN_REAL8 ${OPAL_SIZEOF_FORTRAN_REAL8}
>>>
>>> /* Do threads have different pids (pthreads on linux) */
>>> #cmakedefine OPAL_THREADS_HAVE_DIFFERENT_PIDS
>>> @@ -1420,70 +1420,70 @@
>>>
>>> /* A bogus type that allows us to have sentinel type values that
>>> are still
>>> valid */
>>> -#cmakedefine ompi_fortran_bogus_type_t ${ompi_fortran_bogus_type_t}
>>> +#cmakedefine opal_fortran_bogus_type_t ${opal_fortran_bogus_type_t}
>>>
>>> /* C type corresponding to Fortran 77 COMPLEX*16 */
>>> -#cmakedefine ompi_fortran_complex16_t ${ompi_fortran_complex16_t}
>>> +#cmakedefine opal_fortran_complex16_t ${opal_fortran_complex16_t}
>>>
>>> /* C type corresponding to Fortran 77 COMPLEX*32 */
>>> -#cmakedefine ompi_fortran_complex32_t ${ompi_fortran_complex32_t}
>>> +#cmakedefine opal_fortran_complex32_t ${opal_fortran_complex32_t}
>>>
>>> /* C type corresponding to Fortran 77 COMPLEX*8 */
>>> -#cmakedefine ompi_fortran_complex8_t ${ompi_fortran_complex8_t}
>>> +#cmakedefine opal_fortran_complex8_t ${opal_fortran_complex8_t}
>>>
>>> /* C type corresponding to Fortran 77 COMPLEX */
>>> -#cmakedefine ompi_fortran_complex_t ${ompi_fortran_complex_t}
>>> +#cmakedefine opal_fortran_complex_t ${opal_fortran_complex_t}
>>>
>>> /* C type corresponding to Fortran 77 DOUBLE PRECISION */
>>> -#cmakedefine ompi_fortran_double_precision_t $
>>> {ompi_fortran_double_precision_t}
>>> +#cmakedefine opal_fortran_double_precision_t $
>>> {opal_fortran_double_precision_t}
>>>
>>> /* C type corresponding to Fortran 77 INTEGER*16 */
>>> -#cmakedefine ompi_fortran_integer16_t ${ompi_fortran_integer16_t}
>>> +#cmakedefine opal_fortran_integer16_t ${opal_fortran_integer16_t}
>>>
>>> /* C type corresponding to Fortran 77 INTEGER*1 */
>>> -#cmakedefine ompi_fortran_integer1_t ${ompi_fortran_integer1_t}
>>> +#cmakedefine opal_fortran_integer1_t ${opal_fortran_integer1_t}
>>>
>>> /* C type corresponding to Fortran 77 INTEGER*2 */
>>> -#cmakedefine ompi_fortran_integer2_t ${ompi_fortran_integer2_t}
>>> +#cmakedefine opal_fortran_integer2_t ${opal_fortran_integer2_t}
>>>
>>> /* C type corresponding to Fortran 77 INTEGER*4 */
>>> -#cmakedefine ompi_fortran_integer4_t ${ompi_fortran_integer4_t}
>>> +#cmakedefine opal_fortran_integer4_t ${opal_fortran_integer4_t}
>>>
>>> /* C type corresponding to Fortran 77 INTEGER*8 */
>>> -#cmakedefine ompi_fortran_integer8_t ${ompi_fortran_integer8_t}
>>> +#cmakedefine opal_fortran_integer8_t ${opal_fortran_integer8_t}
>>>
>>> /* C type corresponding to Fortran 77 INTEGER */
>>> -#cmakedefine ompi_fortran_integer_t ${ompi_fortran_integer_t}
>>> +#cmakedefine opal_fortran_integer_t ${opal_fortran_integer_t}
>>>
>>> /* C type corresponding to Fortran 77 LOGICAL */
>>> -#cmakedefine ompi_fortran_logical_t ${ompi_fortran_logical_t}
>>> +#cmakedefine opal_fortran_logical_t ${opal_fortran_logical_t}
>>>
>>> /* C type corresponding to Fortran 77 LOGICAL*1 */
>>> -#cmakedefine ompi_fortran_logical1_t ${ompi_fortran_logical1_t}
>>> +#cmakedefine opal_fortran_logical1_t ${opal_fortran_logical1_t}
>>>
>>> /* C type corresponding to Fortran 77 LOGICAL*2 */
>>> -#cmakedefine ompi_fortran_logical2_t ${ompi_fortran_logical2_t}
>>> +#cmakedefine opal_fortran_logical2_t ${opal_fortran_logical2_t}
>>>
>>> /* C type corresponding to Fortran 77 LOGICAL*4 */
>>> -#cmakedefine ompi_fortran_logical4_t ${ompi_fortran_logical4_t}
>>> +#cmakedefine opal_fortran_logical4_t ${opal_fortran_logical4_t}
>>>
>>> /* C type corresponding to Fortran 77 LOGICAL*8 */
>>> -#cmakedefine ompi_fortran_logical8_t ${ompi_fortran_logical8_t}
>>> +#cmakedefine opal_fortran_logical8_t ${opal_fortran_logical8_t}
>>>
>>> /* C type corresponding to Fortran 77 REAL*16 */
>>> -#cmakedefine ompi_fortran_real16_t ${ompi_fortran_real16_t}
>>> +#cmakedefine opal_fortran_real16_t ${opal_fortran_real16_t}
>>>
>>> /* C type corresponding to Fortran 77 REAL*2 */
>>> -#cmakedefine ompi_fortran_real2_t ${ompi_fortran_real2_t}
>>> +#cmakedefine opal_fortran_real2_t ${opal_fortran_real2_t}
>>>
>>> /* C type corresponding to Fortran 77 REAL*4 */
>>> -#cmakedefine ompi_fortran_real4_t ${ompi_fortran_real4_t}
>>> +#cmakedefine opal_fortran_real4_t ${opal_fortran_real4_t}
>>>
>>> /* C type corresponding to Fortran 77 REAL*8 */
>>> -#cmakedefine ompi_fortran_real8_t ${ompi_fortran_real8_t}
>>> +#cmakedefine opal_fortran_real8_t ${opal_fortran_real8_t}
>>>
>>> /* C type corresponding to Fortran 77 REAL */
>>> -#cmakedefine ompi_fortran_real_t ${ompi_fortran_real_t}
>>> +#cmakedefine opal_fortran_real_t ${opal_fortran_real_t}
>>>
>>> /* Define to `int' if <sys/types.h> does not define. */
>>> #define pid_t ${PID_T}
>>>
>>> Modified: trunk/ompi/attribute/attribute.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/attribute/attribute.c (original)
>>> +++ trunk/ompi/attribute/attribute.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -294,7 +294,7 @@
>>> if (0 != (keyval_obj->attr_flag & OMPI_KEYVAL_F77)) { \
>>> MPI_Fint f_key = OMPI_INT_2_FINT(key); \
>>> MPI_Fint f_err; \
>>> - ompi_fortran_logical_t f_flag; \
>>> + opal_fortran_logical_t f_flag; \
>>> /* MPI-1 Fortran-style */ \
>>> if (0 != (keyval_obj->attr_flag & OMPI_KEYVAL_F77_MPI1)) { \
>>> MPI_Fint in, out; \
>>> @@ -486,9 +486,9 @@
>>> }
>>> key_bitmap = OBJ_NEW(opal_bitmap_t);
>>> /*
>>> - * Set the max size to OMPI_FORTRAN_HANDLE_MAX to enforce bound
>>> + * Set the max size to OPAL_FORTRAN_HANDLE_MAX to enforce bound
>>> */
>>> - opal_bitmap_set_max_size (key_bitmap, OMPI_FORTRAN_HANDLE_MAX);
>>> + opal_bitmap_set_max_size (key_bitmap, OPAL_FORTRAN_HANDLE_MAX);
>>> if (0 != opal_bitmap_init(key_bitmap, 32)) {
>>> return MPI_ERR_SYSRESOURCE;
>>> }
>>>
>>> Modified: trunk/ompi/attribute/attribute.h
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/attribute/attribute.h (original)
>>> +++ trunk/ompi/attribute/attribute.h 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -67,7 +67,7 @@
>>> MPI_Fint
>>> *extra_state,
>>> MPI_Fint
>>> *attr_in,
>>> MPI_Fint
>>> *attr_out,
>>> -
>>> ompi_fortran_logical_t *flag,
>>> + MPI_Flogical
>>> *flag,
>>> MPI_Fint *ierr);
>>> typedef void (ompi_mpi1_fortran_delete_attr_function)(MPI_Fint *obj,
>>> MPI_Fint
>>> *keyval,
>>> @@ -84,7 +84,7 @@
>>> void
>>> *extra_state,
>>> void *attr_in,
>>> void *attr_out,
>>> -
>>> ompi_fortran_logical_t *flag,
>>> + MPI_Flogical
>>> *flag,
>>> MPI_Fint *ierr);
>>> typedef void (ompi_mpi2_fortran_delete_attr_function)(MPI_Fint *obj,
>>> MPI_Fint
>>> *keyval,
>>>
>>> Modified: trunk/ompi/communicator/comm_init.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/communicator/comm_init.c (original)
>>> +++ trunk/ompi/communicator/comm_init.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -70,7 +70,7 @@
>>> /* Setup communicator array */
>>> OBJ_CONSTRUCT(&ompi_mpi_communicators, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_mpi_communicators, 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/datatype/copy_functions.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/datatype/copy_functions.c (original)
>>> +++ trunk/ompi/datatype/copy_functions.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -139,19 +139,19 @@
>>> COPY_TYPE( 2complex_float, ompi_complex_float_t, 2 )
>>> COPY_TYPE( 2complex_double, ompi_complex_double_t, 2 )
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_LOGICAL == 1 || SIZEOF_BOOL == 1
>>> +#if OPAL_SIZEOF_FORTRAN_LOGICAL == 1 || SIZEOF_BOOL == 1
>>> #define REQUIRE_COPY_BYTES_1 1
>>> #else
>>> #define REQUIRE_COPY_BYTES_1 0
>>> #endif
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_LOGICAL == 2 || SIZEOF_BOOL == 2
>>> +#if OPAL_SIZEOF_FORTRAN_LOGICAL == 2 || SIZEOF_BOOL == 2
>>> #define REQUIRE_COPY_BYTES_2 1
>>> #else
>>> #define REQUIRE_COPY_BYTES_2 0
>>> #endif
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_LOGICAL == 4 || SIZEOF_BOOL == 4
>>> +#if OPAL_SIZEOF_FORTRAN_LOGICAL == 4 || SIZEOF_BOOL == 4
>>> #define REQUIRE_COPY_BYTES_4 1
>>> #else
>>> #define REQUIRE_COPY_BYTES_4 0
>>> @@ -236,9 +236,9 @@
>>> #else
>>> #error Complete me please
>>> #endif
>>> -#if OMPI_SIZEOF_FORTRAN_LOGICAL == 1
>>> +#if OPAL_SIZEOF_FORTRAN_LOGICAL == 1
>>> (conversion_fct_t)copy_bytes_1, /*
>>> DT_LOGIC */
>>> -#elif OMPI_SIZEOF_FORTRAN_LOGICAL == 4
>>> +#elif OPAL_SIZEOF_FORTRAN_LOGICAL == 4
>>> (conversion_fct_t)copy_bytes_4, /*
>>> DT_LOGIC */
>>> #elif 1 /* always, some compiler complain if there is not value */
>>> NULL, /*
>>> DT_LOGIC */
>>>
>>> Modified: trunk/ompi/datatype/copy_functions_heterogeneous.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/datatype/copy_functions_heterogeneous.c (original)
>>> +++ trunk/ompi/datatype/copy_functions_heterogeneous.c 2009-05-30
>>> 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -269,8 +269,8 @@
>>>
>>> #define
>>> FORTRAN_LOGICAL_COPY_LOOP(TYPE) \
>>> for( i = 0; i < count; i++ )
>>> { \
>>> - ompi_fortran_logical_t *to_real = (ompi_fortran_logical_t*)
>>> to; \
>>> - *to_real = *((TYPE*) from) == 0 ? 0 :
>>> OMPI_FORTRAN_VALUE_TRUE; \
>>> + opal_fortran_logical_t *to_real = (opal_fortran_logical_t*)
>>> to; \
>>> + *to_real = *((TYPE*) from) == 0 ? 0 :
>>> OPAL_FORTRAN_VALUE_TRUE; \
>>> to +=
>>> to_extent; \
>>> from +=
>>> from_extent; \
>>> }
>>> @@ -298,13 +298,13 @@
>>> }
>>> }
>>>
>>> - datatype_check( "logical", sizeof(ompi_fortran_logical_t),
>>> - sizeof(ompi_fortran_logical_t), &count,
>>> + datatype_check( "logical", sizeof(opal_fortran_logical_t),
>>> + sizeof(opal_fortran_logical_t), &count,
>>> from, from_len, from_extent,
>>> to, to_length, to_extent);
>>>
>>> - if ((to_extent != sizeof(ompi_fortran_logical_t) ||
>>> - from_extent != sizeof(ompi_fortran_logical_t)) ||
>>> + if ((to_extent != sizeof(opal_fortran_logical_t) ||
>>> + from_extent != sizeof(opal_fortran_logical_t)) ||
>>> ((pConvertor->remoteArch & OPAL_ARCH_LOGICALISxx) !=
>>> (ompi_mpi_local_arch & OPAL_ARCH_LOGICALISxx))) {
>>> switch (pConvertor->remoteArch & OPAL_ARCH_LOGICALISxx) {
>>> @@ -319,7 +319,7 @@
>>> break;
>>> }
>>> } else {
>>> - MEMCPY( to, from, count * sizeof(ompi_fortran_logical_t) );
>>> + MEMCPY( to, from, count * sizeof(opal_fortran_logical_t) );
>>> }
>>>
>>> *advance = count * from_extent;
>>>
>>> Modified: trunk/ompi/datatype/dt_module.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/datatype/dt_module.c (original)
>>> +++ trunk/ompi/datatype/dt_module.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -118,25 +118,25 @@
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_long_long_int =
>>> { INIT_UNAVAILABLE_DATA( LONG_LONG_INT) };
>>> OMPI_DECLSPEC ompi_predefined_datatype_t
>>> ompi_mpi_unsigned_long_long =
>>> { INIT_UNAVAILABLE_DATA( UNIGNED_LONG_LONG) };
>>> #endif /* HAVE_LONG_LONG */
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_float =
>>> { INIT_BASIC_DATA( float, OMPI_ALIGNMENT_FLOAT, FLOAT,
>>> DT_FLAG_DATA_C | DT_FLAG_DATA_FLOAT) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_double =
>>> { INIT_BASIC_DATA( double, OMPI_ALIGNMENT_DOUBLE, DOUBLE,
>>> DT_FLAG_DATA_C | DT_FLAG_DATA_FLOAT) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_float =
>>> { INIT_BASIC_DATA( float, OPAL_ALIGNMENT_FLOAT, FLOAT,
>>> DT_FLAG_DATA_C | DT_FLAG_DATA_FLOAT) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_double =
>>> { INIT_BASIC_DATA( double, OPAL_ALIGNMENT_DOUBLE, DOUBLE,
>>> DT_FLAG_DATA_C | DT_FLAG_DATA_FLOAT) };
>>> #if HAVE_LONG_DOUBLE
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_long_double =
>>> { INIT_BASIC_DATA( long double, OPAL_ALIGNMENT_LONG_DOUBLE,
>>> LONG_DOUBLE, DT_FLAG_DATA_C | DT_FLAG_DATA_FLOAT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_long_double =
>>> { INIT_UNAVAILABLE_DATA( LONG_DOUBLE) };
>>> #endif /* HAVE_LONG_DOUBLE */
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_packed =
>>> { INIT_BASIC_DATA( char, OPAL_ALIGNMENT_CHAR, PACKED, 0) };
>>> -#if OMPI_ALIGNMENT_WCHAR != 0
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_wchar =
>>> { INIT_BASIC_DATA( wchar_t, OMPI_ALIGNMENT_WCHAR, WCHAR,
>>> DT_FLAG_DATA_C) };
>>> +#if OPAL_ALIGNMENT_WCHAR != 0
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_wchar =
>>> { INIT_BASIC_DATA( wchar_t, OPAL_ALIGNMENT_WCHAR, WCHAR,
>>> DT_FLAG_DATA_C) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_wchar =
>>> { INIT_UNAVAILABLE_DATA( WCHAR) };
>>> -#endif /* OMPI_ALIGNMENT_WCHAR */
>>> +#endif /* OPAL_ALIGNMENT_WCHAR */
>>>
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_bool =
>>> { INIT_BASIC_DATA( bool, OMPI_ALIGNMENT_CXX_BOOL, CXX_BOOL,
>>> DT_FLAG_DATA_CPP) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logic =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGIC,
>>> OMPI_SIZEOF_FORTRAN_LOGICAL, OMPI_ALIGNMENT_FORTRAN_LOGICAL, 0) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_INTEGER, INTEGER,
>>> OMPI_SIZEOF_FORTRAN_INTEGER, OMPI_ALIGNMENT_FORTRAN_INTEGER,
>>> DT_FLAG_DATA_INT) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_REAL, REAL, OMPI_SIZEOF_FORTRAN_REAL,
>>> OMPI_ALIGNMENT_FORTRAN_REAL, DT_FLAG_DATA_FLOAT) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_dblprec =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_DBLPREC, DOUBLE_PRECISION,
>>> OMPI_SIZEOF_FORTRAN_DOUBLE_PRECISION,
>>> OMPI_ALIGNMENT_FORTRAN_DOUBLE_PRECISION, DT_FLAG_DATA_FLOAT) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_bool =
>>> { INIT_BASIC_DATA( bool, OPAL_ALIGNMENT_CXX_BOOL, CXX_BOOL,
>>> DT_FLAG_DATA_CPP) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logic =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGIC,
>>> OPAL_SIZEOF_FORTRAN_LOGICAL, OPAL_ALIGNMENT_FORTRAN_LOGICAL, 0) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_INTEGER, INTEGER,
>>> OPAL_SIZEOF_FORTRAN_INTEGER, OPAL_ALIGNMENT_FORTRAN_INTEGER,
>>> DT_FLAG_DATA_INT) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_REAL, REAL, OPAL_SIZEOF_FORTRAN_REAL,
>>> OPAL_ALIGNMENT_FORTRAN_REAL, DT_FLAG_DATA_FLOAT) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_dblprec =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_DBLPREC, DOUBLE_PRECISION,
>>> OPAL_SIZEOF_FORTRAN_DOUBLE_PRECISION,
>>> OPAL_ALIGNMENT_FORTRAN_DOUBLE_PRECISION, DT_FLAG_DATA_FLOAT) };
>>>
>>> #if HAVE_LONG_DOUBLE
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_ldblcplex =
>>> { INIT_BASIC_DATA( ompi_complex_long_double_t,
>>> OPAL_ALIGNMENT_LONG_DOUBLE, COMPLEX_LONG_DOUBLE,
>>> DT_FLAG_DATA_FORTRAN | DT_FLAG_DATA_COMPLEX) };
>>> @@ -144,8 +144,8 @@
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_ldblcplex =
>>> { INIT_UNAVAILABLE_DATA( COMPLEX_LONG_DOUBLE) };
>>> #endif /* HAVE_LONG_DOUBLE */
>>>
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cplex =
>>> { INIT_BASIC_DATA( ompi_complex_float_t, OMPI_ALIGNMENT_FLOAT,
>>> COMPLEX_FLOAT, DT_FLAG_DATA_FORTRAN | DT_FLAG_DATA_COMPLEX) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_dblcplex =
>>> { INIT_BASIC_DATA( ompi_complex_double_t, OMPI_ALIGNMENT_DOUBLE,
>>> COMPLEX_DOUBLE, DT_FLAG_DATA_FORTRAN | DT_FLAG_DATA_COMPLEX) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cplex =
>>> { INIT_BASIC_DATA( ompi_complex_float_t, OPAL_ALIGNMENT_FLOAT,
>>> COMPLEX_FLOAT, DT_FLAG_DATA_FORTRAN | DT_FLAG_DATA_COMPLEX) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_dblcplex =
>>> { INIT_BASIC_DATA( ompi_complex_double_t, OPAL_ALIGNMENT_DOUBLE,
>>> COMPLEX_DOUBLE, DT_FLAG_DATA_FORTRAN | DT_FLAG_DATA_COMPLEX) };
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_float_int =
>>> { INIT_BASIC_TYPE( DT_FLOAT_INT, FLOAT_INT) };
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_double_int =
>>> { INIT_BASIC_TYPE( DT_DOUBLE_INT, DOUBLE_INT) };
>>> #if HAVE_LONG_DOUBLE
>>> @@ -161,8 +161,8 @@
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_2dblprec =
>>> { INIT_BASIC_TYPE( DT_2DBLPREC, 2DBLPREC) };
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_2integer =
>>> { INIT_BASIC_TYPE( DT_2INTEGER, 2INTEGER) };
>>>
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_cplex =
>>> { INIT_BASIC_DATA( ompi_complex_float_t, OMPI_ALIGNMENT_FLOAT,
>>> COMPLEX_FLOAT, DT_FLAG_DATA_CPP | DT_FLAG_DATA_COMPLEX) };
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_dblcplex =
>>> { INIT_BASIC_DATA( ompi_complex_double_t, OMPI_ALIGNMENT_DOUBLE,
>>> COMPLEX_DOUBLE, DT_FLAG_DATA_CPP | DT_FLAG_DATA_COMPLEX) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_cplex =
>>> { INIT_BASIC_DATA( ompi_complex_float_t, OPAL_ALIGNMENT_FLOAT,
>>> COMPLEX_FLOAT, DT_FLAG_DATA_CPP | DT_FLAG_DATA_COMPLEX) };
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_dblcplex =
>>> { INIT_BASIC_DATA( ompi_complex_double_t, OPAL_ALIGNMENT_DOUBLE,
>>> COMPLEX_DOUBLE, DT_FLAG_DATA_CPP | DT_FLAG_DATA_COMPLEX) };
>>> #if HAVE_LONG_DOUBLE
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_cxx_ldblcplex =
>>> { INIT_BASIC_DATA( ompi_complex_long_double_t,
>>> OPAL_ALIGNMENT_LONG_DOUBLE, COMPLEX_LONG_DOUBLE, DT_FLAG_DATA_CPP |
>>> DT_FLAG_DATA_COMPLEX) };
>>> #else
>>> @@ -173,86 +173,86 @@
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_2dblcplex =
>>> { INIT_BASIC_TYPE( DT_2DOUBLE_COMPLEX, 2DOUBLE_COMPLEX) };
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_unavailable =
>>> { INIT_UNAVAILABLE_DATA( UNAVAILABLE) };
>>>
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL1
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical1 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL1,
>>> OMPI_SIZEOF_FORTRAN_LOGICAL1, OMPI_ALIGNMENT_FORTRAN_LOGICAL1, 0) };
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL1
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical1 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL1,
>>> OPAL_SIZEOF_FORTRAN_LOGICAL1, OPAL_ALIGNMENT_FORTRAN_LOGICAL1, 0) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical1 =
>>> { INIT_UNAVAILABLE_DATA( LOGICAL1) };
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL1 */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL2
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical2 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL2,
>>> OMPI_SIZEOF_FORTRAN_LOGICAL2, OMPI_ALIGNMENT_FORTRAN_LOGICAL2, 0) };
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL1 */
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL2
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical2 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL2,
>>> OPAL_SIZEOF_FORTRAN_LOGICAL2, OPAL_ALIGNMENT_FORTRAN_LOGICAL2, 0) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical2 =
>>> { INIT_UNAVAILABLE_DATA( LOGICAL2) };
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL2 */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL4
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical4 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL4,
>>> OMPI_SIZEOF_FORTRAN_LOGICAL4, OMPI_ALIGNMENT_FORTRAN_LOGICAL4, 0) };
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL2 */
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL4
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical4 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL4,
>>> OPAL_SIZEOF_FORTRAN_LOGICAL4, OPAL_ALIGNMENT_FORTRAN_LOGICAL4, 0) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical4 =
>>> { INIT_UNAVAILABLE_DATA( LOGICAL4) };
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL4 */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL8
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL8,
>>> OMPI_SIZEOF_FORTRAN_LOGICAL8, OMPI_ALIGNMENT_FORTRAN_LOGICAL8, 0) };
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL4 */
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL8
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LOGIC, LOGICAL8,
>>> OPAL_SIZEOF_FORTRAN_LOGICAL8, OPAL_ALIGNMENT_FORTRAN_LOGICAL8, 0) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical8 =
>>> { INIT_UNAVAILABLE_DATA( LOGICAL8) };
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL8 */
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL8 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real2 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_FLOAT, REAL2,
>>> OMPI_SIZEOF_FORTRAN_REAL2, OMPI_ALIGNMENT_FORTRAN_REAL2,
>>> DT_FLAG_DATA_FLOAT) };
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real2 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_FLOAT, REAL2,
>>> OPAL_SIZEOF_FORTRAN_REAL2, OPAL_ALIGNMENT_FORTRAN_REAL2,
>>> DT_FLAG_DATA_FLOAT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real2 =
>>> { INIT_UNAVAILABLE_DATA( REAL2) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real4 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_FLOAT, REAL4,
>>> OMPI_SIZEOF_FORTRAN_REAL4, OMPI_ALIGNMENT_FORTRAN_REAL4,
>>> DT_FLAG_DATA_FLOAT) };
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real4 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_FLOAT, REAL4,
>>> OPAL_SIZEOF_FORTRAN_REAL4, OPAL_ALIGNMENT_FORTRAN_REAL4,
>>> DT_FLAG_DATA_FLOAT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real4 =
>>> { INIT_UNAVAILABLE_DATA( REAL4) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_DOUBLE, REAL8,
>>> OMPI_SIZEOF_FORTRAN_REAL8, OMPI_ALIGNMENT_FORTRAN_REAL8,
>>> DT_FLAG_DATA_FLOAT) };
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_DOUBLE, REAL8,
>>> OPAL_SIZEOF_FORTRAN_REAL8, OPAL_ALIGNMENT_FORTRAN_REAL8,
>>> DT_FLAG_DATA_FLOAT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real8 =
>>> { INIT_UNAVAILABLE_DATA( REAL8) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real16 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LONG_DOUBLE, REAL16,
>>> OMPI_SIZEOF_FORTRAN_REAL16, OMPI_ALIGNMENT_FORTRAN_REAL16,
>>> DT_FLAG_DATA_FLOAT) };
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real16 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LONG_DOUBLE, REAL16,
>>> OPAL_SIZEOF_FORTRAN_REAL16, OPAL_ALIGNMENT_FORTRAN_REAL16,
>>> DT_FLAG_DATA_FLOAT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real16 =
>>> { INIT_UNAVAILABLE_DATA( REAL16) };
>>> #endif
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer1 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_CHAR, INTEGER1,
>>> OMPI_SIZEOF_FORTRAN_INTEGER1, OMPI_ALIGNMENT_FORTRAN_INTEGER1,
>>> DT_FLAG_DATA_INT) };
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer1 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_CHAR, INTEGER1,
>>> OPAL_SIZEOF_FORTRAN_INTEGER1, OPAL_ALIGNMENT_FORTRAN_INTEGER1,
>>> DT_FLAG_DATA_INT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer1 =
>>> { INIT_UNAVAILABLE_DATA( INTEGER1) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer2 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_SHORT, INTEGER2,
>>> OMPI_SIZEOF_FORTRAN_INTEGER2, OMPI_ALIGNMENT_FORTRAN_INTEGER2,
>>> DT_FLAG_DATA_INT) };
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer2 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_SHORT, INTEGER2,
>>> OPAL_SIZEOF_FORTRAN_INTEGER2, OPAL_ALIGNMENT_FORTRAN_INTEGER2,
>>> DT_FLAG_DATA_INT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer2 =
>>> { INIT_UNAVAILABLE_DATA( INTEGER2) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer4 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_INT, INTEGER4,
>>> OMPI_SIZEOF_FORTRAN_INTEGER4, OMPI_ALIGNMENT_FORTRAN_INTEGER4,
>>> DT_FLAG_DATA_INT) };
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer4 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_INT, INTEGER4,
>>> OPAL_SIZEOF_FORTRAN_INTEGER4, OPAL_ALIGNMENT_FORTRAN_INTEGER4,
>>> DT_FLAG_DATA_INT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer4 =
>>> { INIT_UNAVAILABLE_DATA( INTEGER4) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LONG_LONG_INT, INTEGER8,
>>> OMPI_SIZEOF_FORTRAN_INTEGER8, OMPI_ALIGNMENT_FORTRAN_INTEGER8,
>>> DT_FLAG_DATA_INT) };
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LONG_LONG_INT, INTEGER8,
>>> OPAL_SIZEOF_FORTRAN_INTEGER8, OPAL_ALIGNMENT_FORTRAN_INTEGER8,
>>> DT_FLAG_DATA_INT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer8 =
>>> { INIT_UNAVAILABLE_DATA( INTEGER8) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer16 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LONG_LONG_INT, INTEGER16,
>>> OMPI_SIZEOF_FORTRAN_INTEGER16, OMPI_ALIGNMENT_FORTRAN_INTEGER16,
>>> DT_FLAG_DATA_INT) };
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer16 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_LONG_LONG_INT, INTEGER16,
>>> OPAL_SIZEOF_FORTRAN_INTEGER16, OPAL_ALIGNMENT_FORTRAN_INTEGER16,
>>> DT_FLAG_DATA_INT) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer16 =
>>> { INIT_UNAVAILABLE_DATA( INTEGER16) };
>>> #endif
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_COMPLEX_FLOAT, COMPLEX8,
>>> OMPI_SIZEOF_FORTRAN_COMPLEX, OMPI_ALIGNMENT_FORTRAN_REAL,
>>> DT_FLAG_DATA_COMPLEX) };
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex8 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_COMPLEX_FLOAT, COMPLEX8,
>>> OPAL_SIZEOF_FORTRAN_COMPLEX, OPAL_ALIGNMENT_FORTRAN_REAL,
>>> DT_FLAG_DATA_COMPLEX) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex8 =
>>> { INIT_UNAVAILABLE_DATA( COMPLEX8) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex16 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_COMPLEX_DOUBLE, COMPLEX16,
>>> OMPI_SIZEOF_FORTRAN_COMPLEX16, OMPI_ALIGNMENT_FORTRAN_COMPLEX16,
>>> DT_FLAG_DATA_COMPLEX) };
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex16 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_COMPLEX_DOUBLE, COMPLEX16,
>>> OPAL_SIZEOF_FORTRAN_COMPLEX16, OPAL_ALIGNMENT_FORTRAN_COMPLEX16,
>>> DT_FLAG_DATA_COMPLEX) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex16 =
>>> { INIT_UNAVAILABLE_DATA( COMPLEX16) };
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32 &&
>>> OMPI_REAL16_MATCHES_C
>>> -OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex32 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_COMPLEX_LONG_DOUBLE, COMPLEX32,
>>> OMPI_SIZEOF_FORTRAN_COMPLEX32, OMPI_ALIGNMENT_FORTRAN_COMPLEX32,
>>> DT_FLAG_DATA_COMPLEX) };
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32 &&
>>> OPAL_REAL16_MATCHES_C
>>> +OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex32 =
>>> { INIT_BASIC_FORTRAN_TYPE( DT_COMPLEX_LONG_DOUBLE, COMPLEX32,
>>> OPAL_SIZEOF_FORTRAN_COMPLEX32, OPAL_ALIGNMENT_FORTRAN_COMPLEX32,
>>> DT_FLAG_DATA_COMPLEX) };
>>> #else
>>> OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex32 =
>>> { INIT_UNAVAILABLE_DATA( COMPLEX32) };
>>> #endif
>>> @@ -455,7 +455,7 @@
>>> /* Create the f2c translation table */
>>> OBJ_CONSTRUCT(&ompi_datatype_f_to_c_table, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_datatype_f_to_c_table,
>>> - 0,
>>> OMPI_FORTRAN_HANDLE_MAX, 64)) {
>>> + 0,
>>> OPAL_FORTRAN_HANDLE_MAX, 64)) {
>>> return OMPI_ERROR;
>>> }
>>> /* All temporary datatypes created on the following statement
>>> will get registered
>>> @@ -520,197 +520,197 @@
>>> #endif /* HAVE_LONG_DOUBLE */
>>>
>>> /* Optional Fortran LOGICAL types */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL1
>>> -#if (OMPI_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_CHAR)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL1
>>> +#if (OPAL_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_CHAR)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical1.dt, "MPI_LOGICAL1",
>>> &ompi_mpi_char.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_SHORT)
>>> +#elif (OPAL_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_SHORT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical1.dt, "MPI_LOGICAL1",
>>> &ompi_mpi_short.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_INT)
>>> +#elif (OPAL_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_INT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical1.dt, "MPI_LOGICAL1",
>>> &ompi_mpi_int.dt );
>>> #else
>>> # warning "No proper C type found for LOGICAL1"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical1.dt, "MPI_LOGICAL1",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_logical1.dt.flags |= DT_FLAG_DATA_FORTRAN;
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL1 */
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL1 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL2
>>> -#if (OMPI_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_SHORT)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL2
>>> +#if (OPAL_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_SHORT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical2.dt, "MPI_LOGICAL2",
>>> &ompi_mpi_short.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_INT)
>>> +#elif (OPAL_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_INT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical2.dt, "MPI_LOGICAL2",
>>> &ompi_mpi_int.dt );
>>> #else
>>> # warning "No proper C type found for LOGICAL2"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical2.dt, "MPI_LOGICAL2",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_logical2.dt.flags |= DT_FLAG_DATA_FORTRAN;
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL2 */
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL2 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL4
>>> -#if (OMPI_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_INT)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL4
>>> +#if (OPAL_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_INT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical4.dt, "MPI_LOGICAL4",
>>> &ompi_mpi_int.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_LONG)
>>> +#elif (OPAL_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical4.dt, "MPI_LOGICAL4",
>>> &ompi_mpi_long.dt );
>>> #else
>>> # warning "No proper C type found for LOGICAL4"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical4.dt, "MPI_LOGICAL4",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_logical4.dt.flags |= DT_FLAG_DATA_FORTRAN;
>>> -#endif /* OMPI_HAVE_FORTRAN_LOGICAL4 */
>>> +#endif /* OPAL_HAVE_FORTRAN_LOGICAL4 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL8
>>> -#if (OMPI_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL8
>>> +#if (OPAL_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical8.dt, "MPI_LOGICAL8",
>>> &ompi_mpi_long.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG_LONG)
>>> +#elif (OPAL_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical8.dt, "MPI_LOGICAL8",
>>> &ompi_mpi_long_long_int.dt );
>>> #else
>>> # warning "No proper C type found for LOGICAL8"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical8.dt, "MPI_LOGICAL8",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_logical8.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_INT;
>>> -#endif /* OMPI_HAVE_FORTRAN_INTEGER8 */
>>> +#endif /* OPAL_HAVE_FORTRAN_INTEGER8 */
>>>
>>> /* Optional Fortran REAL types */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -#if (OMPI_SIZEOF_FORTRAN_REAL2 == SIZEOF_FLOAT)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +#if (OPAL_SIZEOF_FORTRAN_REAL2 == SIZEOF_FLOAT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real2.dt, "MPI_REAL2",
>>> &ompi_mpi_float.dt );
>>> #else
>>> # warning "No proper C type found for REAL2"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real2.dt, "MPI_REAL2",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_real2.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_FLOAT;
>>> -#endif /* OMPI_HAVE_FORTRAN_REAL2 */
>>> +#endif /* OPAL_HAVE_FORTRAN_REAL2 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -#if (OMPI_SIZEOF_FORTRAN_REAL4 == SIZEOF_FLOAT)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +#if (OPAL_SIZEOF_FORTRAN_REAL4 == SIZEOF_FLOAT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real4.dt, "MPI_REAL4",
>>> &ompi_mpi_float.dt );
>>> #else
>>> # warning "No proper C type found for REAL4"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real4.dt, "MPI_REAL4",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_real4.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_FLOAT;
>>> -#endif /* OMPI_HAVE_FORTRAN_REAL4 */
>>> +#endif /* OPAL_HAVE_FORTRAN_REAL4 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -#if (OMPI_SIZEOF_FORTRAN_REAL8 == SIZEOF_FLOAT)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +#if (OPAL_SIZEOF_FORTRAN_REAL8 == SIZEOF_FLOAT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real8.dt, "MPI_REAL8",
>>> &ompi_mpi_float.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_REAL8 == SIZEOF_DOUBLE)
>>> +#elif (OPAL_SIZEOF_FORTRAN_REAL8 == SIZEOF_DOUBLE)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real8.dt, "MPI_REAL8",
>>> &ompi_mpi_double.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_REAL8 == SIZEOF_LONG_DOUBLE)
>>> +#elif (OPAL_SIZEOF_FORTRAN_REAL8 == SIZEOF_LONG_DOUBLE)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real8.dt, "MPI_REAL8",
>>> &ompi_mpi_long_double.dt );
>>> #else
>>> # warning "No proper C type found for REAL8"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real8.dt, "MPI_REAL8",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_real8.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_FLOAT;
>>> -#endif /* OMPI_HAVE_FORTRAN_REAL8 */
>>> +#endif /* OPAL_HAVE_FORTRAN_REAL8 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -#if (OMPI_SIZEOF_FORTRAN_REAL16 == SIZEOF_LONG_DOUBLE)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +#if (OPAL_SIZEOF_FORTRAN_REAL16 == SIZEOF_LONG_DOUBLE)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real16.dt, "MPI_REAL16",
>>> &ompi_mpi_long_double.dt );
>>> #else
>>> # warning "No proper C type found for REAL16"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real16.dt, "MPI_REAL16",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_real16.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_FLOAT;
>>> -#endif /* OMPI_HAVE_FORTRAN_REAL16 */
>>> +#endif /* OPAL_HAVE_FORTRAN_REAL16 */
>>>
>>> /* Optional Fortran INTEGER types */
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -#if (OMPI_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_CHAR)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +#if (OPAL_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_CHAR)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer1.dt, "MPI_INTEGER1",
>>> &ompi_mpi_char.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_SHORT)
>>> +#elif (OPAL_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_SHORT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer1.dt, "MPI_INTEGER1",
>>> &ompi_mpi_short.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_INT)
>>> +#elif (OPAL_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_INT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer1.dt, "MPI_INTEGER1",
>>> &ompi_mpi_int.dt );
>>> #else
>>> # warning "No proper C type found for INTEGER1"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer1.dt, "MPI_INTEGER1",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_integer1.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_INT;
>>> -#endif /* OMPI_HAVE_FORTRAN_INTEGER1 */
>>> +#endif /* OPAL_HAVE_FORTRAN_INTEGER1 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -#if (OMPI_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_SHORT)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +#if (OPAL_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_SHORT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer2.dt, "MPI_INTEGER2",
>>> &ompi_mpi_short.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_INT)
>>> +#elif (OPAL_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_INT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer2.dt, "MPI_INTEGER2",
>>> &ompi_mpi_int.dt );
>>> #else
>>> # warning "No proper C type found for INTEGER2"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer2.dt, "MPI_INTEGER2",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_integer2.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_INT;
>>> -#endif /* OMPI_HAVE_FORTRAN_INTEGER2 */
>>> +#endif /* OPAL_HAVE_FORTRAN_INTEGER2 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -#if (OMPI_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_INT)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +#if (OPAL_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_INT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer4.dt, "MPI_INTEGER4",
>>> &ompi_mpi_int.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_LONG)
>>> +#elif (OPAL_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer4.dt, "MPI_INTEGER4",
>>> &ompi_mpi_long.dt );
>>> #else
>>> # warning "No proper C type found for INTEGER4"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer4.dt, "MPI_INTEGER4",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_integer4.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_INT;
>>> -#endif /* OMPI_HAVE_FORTRAN_INTEGER4 */
>>> +#endif /* OPAL_HAVE_FORTRAN_INTEGER4 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -#if (OMPI_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +#if (OPAL_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer8.dt, "MPI_INTEGER8",
>>> &ompi_mpi_long.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG_LONG)
>>> +#elif (OPAL_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer8.dt, "MPI_INTEGER8",
>>> &ompi_mpi_long_long_int.dt );
>>> #else
>>> # warning "No proper C type found for INTEGER8"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer8.dt, "MPI_INTEGER8",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_integer8.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_INT;
>>> -#endif /* OMPI_HAVE_FORTRAN_INTEGER8 */
>>> +#endif /* OPAL_HAVE_FORTRAN_INTEGER8 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -#if (OMPI_SIZEOF_FORTRAN_INTEGER16 == SIZEOF_LONG_LONG)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +#if (OPAL_SIZEOF_FORTRAN_INTEGER16 == SIZEOF_LONG_LONG)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer16.dt,
>>> "MPI_INTEGER16", &ompi_mpi_long_long_int.dt );
>>> #else
>>> # warning "No proper C type found for INTEGER16"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer16.dt,
>>> "MPI_INTEGER16", &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_integer16.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_INT;
>>> -#endif /* OMPI_HAVE_FORTRAN_INTEGER16 */
>>> +#endif /* OPAL_HAVE_FORTRAN_INTEGER16 */
>>>
>>> /* Optional Fortran COMPLEX types */
>>>
>>> -#if OMPI_HAVE_FORTRAN_COMPLEX8
>>> -#if (OMPI_SIZEOF_FORTRAN_COMPLEX8 == 2*SIZEOF_FLOAT)
>>> +#if OPAL_HAVE_FORTRAN_COMPLEX8
>>> +#if (OPAL_SIZEOF_FORTRAN_COMPLEX8 == 2*SIZEOF_FLOAT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex8.dt, "MPI_COMPLEX8",
>>> &ompi_mpi_cplex.dt );
>>> #else
>>> # warning "No proper C type found for COMPLEX8"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex8.dt, "MPI_COMPLEX8",
>>> &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_complex8.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_COMPLEX;
>>> -#endif /* OMPI_HAVE_FORTRAN_COMPLEX8 */
>>> +#endif /* OPAL_HAVE_FORTRAN_COMPLEX8 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_COMPLEX16
>>> -#if (OMPI_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_FLOAT)
>>> +#if OPAL_HAVE_FORTRAN_COMPLEX16
>>> +#if (OPAL_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_FLOAT)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex16.dt,
>>> "MPI_COMPLEX16", &ompi_mpi_cplex.dt );
>>> -#elif (OMPI_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_DOUBLE)
>>> +#elif (OPAL_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_DOUBLE)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex16.dt,
>>> "MPI_COMPLEX16", &ompi_mpi_dblcplex.dt );
>>> #else
>>> # warning "No proper C type found for COMPLEX16"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex16.dt,
>>> "MPI_COMPLEX16", &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_complex16.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_COMPLEX;
>>> -#endif /* OMPI_HAVE_FORTRAN_COMPLEX16 */
>>> +#endif /* OPAL_HAVE_FORTRAN_COMPLEX16 */
>>>
>>> -#if OMPI_HAVE_FORTRAN_COMPLEX32
>>> -#if OMPI_REAL16_MATCHES_C && (OMPI_SIZEOF_FORTRAN_COMPLEX32 ==
>>> 2*SIZEOF_LONG_DOUBLE)
>>> +#if OPAL_HAVE_FORTRAN_COMPLEX32
>>> +#if OPAL_REAL16_MATCHES_C && (OPAL_SIZEOF_FORTRAN_COMPLEX32 ==
>>> 2*SIZEOF_LONG_DOUBLE)
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex32.dt,
>>> "MPI_COMPLEX32", &ompi_mpi_ldblcplex.dt );
>>> #else
>>> # warning "No proper C type found for COMPLEX32"
>>> DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex32.dt,
>>> "MPI_COMPLEX32", &ompi_mpi_unavailable.dt );
>>> #endif
>>> ompi_mpi_complex32.dt.flags |= DT_FLAG_DATA_FORTRAN |
>>> DT_FLAG_DATA_COMPLEX;
>>> -#endif /* OMPI_HAVE_FORTRAN_COMPLEX32 */
>>> +#endif /* OPAL_HAVE_FORTRAN_COMPLEX32 */
>>>
>>> /* Start to populate the f2c index translation table */
>>>
>>>
>>> Modified: trunk/ompi/errhandler/errcode-internal.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/errhandler/errcode-internal.c (original)
>>> +++ trunk/ompi/errhandler/errcode-internal.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -61,7 +61,7 @@
>>> the error objects */
>>> OBJ_CONSTRUCT(&ompi_errcodes_intern, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_errcodes_intern,
>>> - 0,
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> + 0,
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/errhandler/errcode.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/errhandler/errcode.c (original)
>>> +++ trunk/ompi/errhandler/errcode.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -111,7 +111,7 @@
>>> the error objects */
>>> OBJ_CONSTRUCT(&ompi_mpi_errcodes, opal_pointer_array_t);
>>> if( OPAL_SUCCESS != opal_pointer_array_init(&ompi_mpi_errcodes,
>>> 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/errhandler/errhandler.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/errhandler/errhandler.c (original)
>>> +++ trunk/ompi/errhandler/errhandler.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -76,7 +76,7 @@
>>>
>>> OBJ_CONSTRUCT( &ompi_errhandler_f_to_c_table,
>>> opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_errhandler_f_to_c_table, 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/file/file.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/file/file.c (original)
>>> +++ trunk/ompi/file/file.c 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -64,7 +64,7 @@
>>>
>>> OBJ_CONSTRUCT(&ompi_file_f_to_c_table, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_file_f_to_c_table, 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/group/group_init.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/group/group_init.c (original)
>>> +++ trunk/ompi/group/group_init.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -308,7 +308,7 @@
>>> /* initialize ompi_group_f_to_c_table */
>>> OBJ_CONSTRUCT( &ompi_group_f_to_c_table, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_group_f_to_c_table, 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/include/mpi.h.in
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/include/mpi.h.in (original)
>>> +++ trunk/ompi/include/mpi.h.in 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -87,43 +87,43 @@
>>> #undef OPAL_MAX_PROCESSOR_NAME
>>>
>>> /* Whether we have FORTRAN LOGICAL*1 or not */
>>> -#undef OMPI_HAVE_FORTRAN_LOGICAL1
>>> +#undef OPAL_HAVE_FORTRAN_LOGICAL1
>>>
>>> /* Whether we have FORTRAN LOGICAL*2 or not */
>>> -#undef OMPI_HAVE_FORTRAN_LOGICAL2
>>> +#undef OPAL_HAVE_FORTRAN_LOGICAL2
>>>
>>> /* Whether we have FORTRAN LOGICAL*4 or not */
>>> -#undef OMPI_HAVE_FORTRAN_LOGICAL4
>>> +#undef OPAL_HAVE_FORTRAN_LOGICAL4
>>>
>>> /* Whether we have FORTRAN LOGICAL*8 or not */
>>> -#undef OMPI_HAVE_FORTRAN_LOGICAL8
>>> +#undef OPAL_HAVE_FORTRAN_LOGICAL8
>>>
>>> /* Whether we have FORTRAN INTEGER*1 or not */
>>> -#undef OMPI_HAVE_FORTRAN_INTEGER1
>>> +#undef OPAL_HAVE_FORTRAN_INTEGER1
>>>
>>> /* Whether we have FORTRAN INTEGER*16 or not */
>>> -#undef OMPI_HAVE_FORTRAN_INTEGER16
>>> +#undef OPAL_HAVE_FORTRAN_INTEGER16
>>>
>>> /* Whether we have FORTRAN INTEGER*2 or not */
>>> -#undef OMPI_HAVE_FORTRAN_INTEGER2
>>> +#undef OPAL_HAVE_FORTRAN_INTEGER2
>>>
>>> /* Whether we have FORTRAN INTEGER*4 or not */
>>> -#undef OMPI_HAVE_FORTRAN_INTEGER4
>>> +#undef OPAL_HAVE_FORTRAN_INTEGER4
>>>
>>> /* Whether we have FORTRAN INTEGER*8 or not */
>>> -#undef OMPI_HAVE_FORTRAN_INTEGER8
>>> +#undef OPAL_HAVE_FORTRAN_INTEGER8
>>>
>>> /* Whether we have FORTRAN REAL*16 or not */
>>> -#undef OMPI_HAVE_FORTRAN_REAL16
>>> +#undef OPAL_HAVE_FORTRAN_REAL16
>>>
>>> /* Whether we have FORTRAN REAL*2 or not */
>>> -#undef OMPI_HAVE_FORTRAN_REAL2
>>> +#undef OPAL_HAVE_FORTRAN_REAL2
>>>
>>> /* Whether we have FORTRAN REAL*4 or not */
>>> -#undef OMPI_HAVE_FORTRAN_REAL4
>>> +#undef OPAL_HAVE_FORTRAN_REAL4
>>>
>>> /* Whether we have FORTRAN REAL*8 or not */
>>> -#undef OMPI_HAVE_FORTRAN_REAL8
>>> +#undef OPAL_HAVE_FORTRAN_REAL8
>>>
>>> /* Type of MPI_Offset -- has to be defined here and typedef'ed
>>> later because mpi.h does not get AC SUBST's */
>>> #undef OMPI_MPI_OFFSET_TYPE
>>> @@ -166,10 +166,10 @@
>>>
>>> /* A type that allows us to have sentinel type values that are still
>>> valid */
>>> -#undef ompi_fortran_bogus_type_t
>>> +#undef opal_fortran_bogus_type_t
>>>
>>> /* C type corresponding to FORTRAN INTEGER */
>>> -#undef ompi_fortran_integer_t
>>> +#undef opal_fortran_integer_t
>>>
>>> /* Whether C compiler supports -fvisibility */
>>> #undef OPAL_C_HAVE_VISIBILITY
>>> @@ -194,8 +194,8 @@
>>> #endif
>>>
>>> #ifndef MPI_Fint
>>> -/* MPI_Fint is the same as ompi_fortran_INTEGER_t */
>>> -#define MPI_Fint ompi_fortran_integer_t
>>> +/* MPI_Fint is the same as opal_fortran_integer_t */
>>> +#define MPI_Fint opal_fortran_integer_t
>>> #endif
>>>
>>> #endif /* #ifndef OMPI_CONFIG_H */
>>> @@ -766,52 +766,52 @@
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_cxx_bool;
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_2cplex, ompi_mpi_2dblcplex;
>>> /* other MPI2 datatypes */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL1
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL1
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical1;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL2
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL2
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical2;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL4
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical4;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL8
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_logical8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer1;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer2;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer4;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_integer16;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real2;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real4;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_real16;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_complex8;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_complex16;
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> OMPI_DECLSPEC extern struct ompi_predefined_datatype_t
>>> ompi_mpi_complex32;
>>> #endif
>>>
>>> @@ -885,53 +885,53 @@
>>> /* Fortran datatype bindings */
>>> #define MPI_CHARACTER OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_character)
>>> #define MPI_LOGICAL OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logic)
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL1
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL1
>>> #define MPI_LOGICAL1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical1)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL2
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL2
>>> #define MPI_LOGICAL2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical2)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL4
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL4
>>> #define MPI_LOGICAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical4)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL8
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL8
>>> #define MPI_LOGICAL8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_logical8)
>>> #endif
>>> #define MPI_INTEGER OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer)
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> #define MPI_INTEGER1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer1)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> #define MPI_INTEGER2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer2)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> #define MPI_INTEGER4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer4)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> #define MPI_INTEGER8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer8)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> #define MPI_INTEGER16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_integer16)
>>> #endif
>>> #define MPI_REAL OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_real)
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define MPI_REAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_real4)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define MPI_REAL8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_real8)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define MPI_REAL16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_real16)
>>> #endif
>>> #define MPI_DOUBLE_PRECISION OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_dblprec)
>>> #define MPI_COMPLEX OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_cplex)
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define MPI_COMPLEX8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_complex8)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define MPI_COMPLEX16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_complex16)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define MPI_COMPLEX32 OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_complex32)
>>> #endif
>>> #define MPI_DOUBLE_COMPLEX OMPI_PREDEFINED_GLOBAL(MPI_Datatype,
>>> ompi_mpi_dblcplex)
>>>
>>> Modified: trunk/ompi/include/ompi_config.h.in
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/include/ompi_config.h.in (original)
>>> +++ trunk/ompi/include/ompi_config.h.in 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -35,50 +35,50 @@
>>> *
>>>
>>> **********************************************************************/
>>>
>>> -/* MPI_Fint is the same as ompi_fortran_INTEGER_t */
>>> -#define MPI_Fint ompi_fortran_integer_t
>>> +/* MPI_Fint is the same as opal_fortran_integer_t */
>>> +#define MPI_Fint opal_fortran_integer_t
>>>
>>> -/* MPI_Flogical is the same as the ompi_fortran_logical_t */
>>> -#define MPI_Flogical ompi_fortran_logical_t
>>> +/* MPI_Flogical is the same as the opal_fortran_logical_t */
>>> +#define MPI_Flogical opal_fortran_logical_t
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
>>> +#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX
>>> /* * C type for Fortran COMPLEX */
>>> typedef struct {
>>> - ompi_fortran_real_t real;
>>> - ompi_fortran_real_t imag;
>>> -} ompi_fortran_complex_t;
>>> + opal_fortran_real_t real;
>>> + opal_fortran_real_t imag;
>>> +} opal_fortran_complex_t;
>>> #endif
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> /* * C type for Fortran COMPLEX*8 */
>>> typedef struct {
>>> - ompi_fortran_real4_t real;
>>> - ompi_fortran_real4_t imag;
>>> -} ompi_fortran_complex8_t;
>>> + opal_fortran_real4_t real;
>>> + opal_fortran_real4_t imag;
>>> +} opal_fortran_complex8_t;
>>> #endif
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> /* * C type for Fortran COMPLEX*16 */
>>> typedef struct {
>>> - ompi_fortran_real8_t real;
>>> - ompi_fortran_real8_t imag;
>>> -} ompi_fortran_complex16_t;
>>> + opal_fortran_real8_t real;
>>> + opal_fortran_real8_t imag;
>>> +} opal_fortran_complex16_t;
>>> #endif
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32
>>> /* * C type for Fortran COMPLEX*32 */
>>> typedef struct {
>>> - ompi_fortran_real16_t real;
>>> - ompi_fortran_real16_t imag;
>>> -} ompi_fortran_complex32_t;
>>> + opal_fortran_real16_t real;
>>> + opal_fortran_real16_t imag;
>>> +} opal_fortran_complex32_t;
>>> #endif
>>>
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> /* * C type for Fortran DOUBLE COMPLEX */
>>> typedef struct {
>>> - ompi_fortran_double_precision_t real;
>>> - ompi_fortran_double_precision_t imag;
>>> -} ompi_fortran_double_complex_t;
>>> + opal_fortran_double_precision_t real;
>>> + opal_fortran_double_precision_t imag;
>>> +} opal_fortran_double_complex_t;
>>> #endif
>>>
>>>
>>>
>>> Modified: trunk/ompi/info/info.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/info/info.c (original)
>>> +++ trunk/ompi/info/info.c 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -85,7 +85,7 @@
>>>
>>> OBJ_CONSTRUCT(&ompi_info_f_to_c_table, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_info_f_to_c_table, 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/ompi/mca/op/base/functions.h
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mca/op/base/functions.h (original)
>>> +++ trunk/ompi/mca/op/base/functions.h 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -56,31 +56,31 @@
>>>
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER_INTRINSIC(name) \
>>> void ompi_op_base_##name##_fortran_integer OMPI_OP_PROTO;
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER1(name) \
>>> void ompi_op_base_##name##_fortran_integer1 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER1(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER2(name) \
>>> void ompi_op_base_##name##_fortran_integer2 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER2(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER4(name) \
>>> void ompi_op_base_##name##_fortran_integer4 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER4(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER8(name) \
>>> void ompi_op_base_##name##_fortran_integer8 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER8(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> #define OMPI_OP_HANDLER_FORTRAN_INTEGER16(name) \
>>> void ompi_op_base_##name##_fortran_integer16 OMPI_OP_PROTO;
>>> #else
>>> @@ -102,25 +102,25 @@
>>> void ompi_op_base_##name##_fortran_real OMPI_OP_PROTO; \
>>> void ompi_op_base_##name##_fortran_double_precision
>>> OMPI_OP_PROTO; \
>>> void ompi_op_base_##name##_long_double OMPI_OP_PROTO;
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL2(name) \
>>> void ompi_op_base_##name##_fortran_real2 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL2(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL4(name) \
>>> void ompi_op_base_##name##_fortran_real4 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL4(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL8(name) \
>>> void ompi_op_base_##name##_fortran_real8 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL8(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define OMPI_OP_HANDLER_FLOATING_POINT_REAL16(name) \
>>> void ompi_op_base_##name##_fortran_real16 OMPI_OP_PROTO;
>>> #else
>>> @@ -140,31 +140,31 @@
>>>
>>> /* Complex */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> #define OMPI_OP_HANDLER_COMPLEX_INTRINSIC(name) \
>>> void ompi_op_base_##name##_fortran_complex OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_COMPLEX_INTRINSIC(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> #define OMPI_OP_HANDLER_DOUBLE_COMPLEX_INTRINSIC(name) \
>>> void ompi_op_base_##name##_fortran_double_complex OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_DOUBLE_COMPLEX_INTRINSIC(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define OMPI_OP_HANDLER_COMPLEX8(name) \
>>> void ompi_op_base_##name##_fortran_complex8 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_COMPLEX8(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define OMPI_OP_HANDLER_COMPLEX16(name) \
>>> void ompi_op_base_##name##_fortran_complex16 OMPI_OP_PROTO;
>>> #else
>>> #define OMPI_OP_HANDLER_COMPLEX16(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define OMPI_OP_HANDLER_COMPLEX32(name) \
>>> void ompi_op_base_##name##_fortran_complex32 OMPI_OP_PROTO;
>>> #else
>>> @@ -311,31 +311,31 @@
>>>
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER_INTRINSIC(name) \
>>> void ompi_op_base_3buff_##name##_fortran_integer
>>> OMPI_OP_PROTO_3BUF;
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER1(name) \
>>> void ompi_op_base_3buff_##name##_fortran_integer1
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER1(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER2(name) \
>>> void ompi_op_base_3buff_##name##_fortran_integer2
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER2(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER4(name) \
>>> void ompi_op_base_3buff_##name##_fortran_integer4
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER4(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER8(name) \
>>> void ompi_op_base_3buff_##name##_fortran_integer8
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER8(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER16(name) \
>>> void ompi_op_base_3buff_##name##_fortran_integer16
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> @@ -357,25 +357,25 @@
>>> void ompi_op_base_3buff_##name##_fortran_real OMPI_OP_PROTO_3BUF; \
>>> void ompi_op_base_3buff_##name##_fortran_double_precision
>>> OMPI_OP_PROTO_3BUF; \
>>> void ompi_op_base_3buff_##name##_long_double OMPI_OP_PROTO_3BUF;
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL2(name) \
>>> void ompi_op_base_3buff_##name##_fortran_real2 OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL2(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL4(name) \
>>> void ompi_op_base_3buff_##name##_fortran_real4 OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL4(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL8(name) \
>>> void ompi_op_base_3buff_##name##_fortran_real8 OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL8(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define OMPI_OP_3BUFF_HANDLER_FLOATING_POINT_REAL16(name) \
>>> void ompi_op_base_3buff_##name##_fortran_real16 OMPI_OP_PROTO_3BUF;
>>> #else
>>> @@ -395,31 +395,31 @@
>>>
>>> /* Complex */
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX_INTRINSIC(name) \
>>> void ompi_op_base_3buff_##name##_fortran_complex
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX_INTRINSIC(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> #define OMPI_OP_3BUFF_HANDLER_DOUBLE_COMPLEX_INTRINSIC(name) \
>>> void ompi_op_base_3buff_##name##_fortran_double_complex
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_DOUBLE_COMPLEX_INTRINSIC(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX8(name) \
>>> void ompi_op_base_3buff_##name##_fortran_complex8
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX8(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX16(name) \
>>> void ompi_op_base_3buff_##name##_fortran_complex16
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX16(name)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> #define OMPI_OP_3BUFF_HANDLER_COMPLEX32(name) \
>>> void ompi_op_base_3buff_##name##_fortran_complex32
>>> OMPI_OP_PROTO_3BUF;
>>> #else
>>>
>>> Modified: trunk/ompi/mca/op/base/op_base_functions.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mca/op/base/op_base_functions.c (original)
>>> +++ trunk/ompi/mca/op/base/op_base_functions.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -151,23 +151,23 @@
>>> FUNC_FUNC(max, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC(max, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC(max, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC(max, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC(max, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC(max, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC(max, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC(max, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC(max, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC(max, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC(max, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC(max, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC(max, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Floating point */
>>> FUNC_FUNC(max, float, float)
>>> @@ -175,23 +175,23 @@
>>> #if HAVE_LONG_DOUBLE
>>> FUNC_FUNC(max, long_double, long double)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -FUNC_FUNC(max, fortran_real, ompi_fortran_real_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +FUNC_FUNC(max, fortran_real, opal_fortran_real_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -FUNC_FUNC(max, fortran_double_precision,
>>> ompi_fortran_double_precision_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +FUNC_FUNC(max, fortran_double_precision,
>>> opal_fortran_double_precision_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -FUNC_FUNC(max, fortran_real2, ompi_fortran_real2_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +FUNC_FUNC(max, fortran_real2, opal_fortran_real2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -FUNC_FUNC(max, fortran_real4, ompi_fortran_real4_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +FUNC_FUNC(max, fortran_real4, opal_fortran_real4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -FUNC_FUNC(max, fortran_real8, ompi_fortran_real8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +FUNC_FUNC(max, fortran_real8, opal_fortran_real8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -FUNC_FUNC(max, fortran_real16, ompi_fortran_real16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +FUNC_FUNC(max, fortran_real16, opal_fortran_real16_t)
>>> #endif
>>>
>>>
>>> @@ -215,23 +215,23 @@
>>> FUNC_FUNC(min, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC(min, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC(min, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC(min, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC(min, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC(min, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC(min, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC(min, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC(min, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC(min, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC(min, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC(min, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC(min, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Floating point */
>>> FUNC_FUNC(min, float, float)
>>> @@ -239,23 +239,23 @@
>>> #if HAVE_LONG_DOUBLE
>>> FUNC_FUNC(min, long_double, long double)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -FUNC_FUNC(min, fortran_real, ompi_fortran_real_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +FUNC_FUNC(min, fortran_real, opal_fortran_real_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -FUNC_FUNC(min, fortran_double_precision,
>>> ompi_fortran_double_precision_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +FUNC_FUNC(min, fortran_double_precision,
>>> opal_fortran_double_precision_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -FUNC_FUNC(min, fortran_real2, ompi_fortran_real2_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +FUNC_FUNC(min, fortran_real2, opal_fortran_real2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -FUNC_FUNC(min, fortran_real4, ompi_fortran_real4_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +FUNC_FUNC(min, fortran_real4, opal_fortran_real4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -FUNC_FUNC(min, fortran_real8, ompi_fortran_real8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +FUNC_FUNC(min, fortran_real8, opal_fortran_real8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -FUNC_FUNC(min, fortran_real16, ompi_fortran_real16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +FUNC_FUNC(min, fortran_real16, opal_fortran_real16_t)
>>> #endif
>>>
>>> /
>>> *************************************************************************
>>> @@ -276,23 +276,23 @@
>>> OP_FUNC(sum, unsigned_long_long, unsigned long long, +=)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -OP_FUNC(sum, fortran_integer, ompi_fortran_integer_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +OP_FUNC(sum, fortran_integer, opal_fortran_integer_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -OP_FUNC(sum, fortran_integer1, ompi_fortran_integer1_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +OP_FUNC(sum, fortran_integer1, opal_fortran_integer1_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -OP_FUNC(sum, fortran_integer2, ompi_fortran_integer2_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +OP_FUNC(sum, fortran_integer2, opal_fortran_integer2_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -OP_FUNC(sum, fortran_integer4, ompi_fortran_integer4_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +OP_FUNC(sum, fortran_integer4, opal_fortran_integer4_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -OP_FUNC(sum, fortran_integer8, ompi_fortran_integer8_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +OP_FUNC(sum, fortran_integer8, opal_fortran_integer8_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -OP_FUNC(sum, fortran_integer16, ompi_fortran_integer16_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +OP_FUNC(sum, fortran_integer16, opal_fortran_integer16_t, +=)
>>> #endif
>>> /* Floating point */
>>> OP_FUNC(sum, float, float, +=)
>>> @@ -300,39 +300,39 @@
>>> #if HAVE_LONG_DOUBLE
>>> OP_FUNC(sum, long_double, long double, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -OP_FUNC(sum, fortran_real, ompi_fortran_real_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +OP_FUNC(sum, fortran_real, opal_fortran_real_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -OP_FUNC(sum, fortran_double_precision,
>>> ompi_fortran_double_precision_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +OP_FUNC(sum, fortran_double_precision,
>>> opal_fortran_double_precision_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -OP_FUNC(sum, fortran_real2, ompi_fortran_real2_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +OP_FUNC(sum, fortran_real2, opal_fortran_real2_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -OP_FUNC(sum, fortran_real4, ompi_fortran_real4_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +OP_FUNC(sum, fortran_real4, opal_fortran_real4_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -OP_FUNC(sum, fortran_real8, ompi_fortran_real8_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +OP_FUNC(sum, fortran_real8, opal_fortran_real8_t, +=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -OP_FUNC(sum, fortran_real16, ompi_fortran_real16_t, +=)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +OP_FUNC(sum, fortran_real16, opal_fortran_real16_t, +=)
>>> #endif
>>> /* Complex */
>>> -#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_SUM(fortran_complex, ompi_fortran_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_SUM(fortran_complex, opal_fortran_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_SUM(fortran_double_complex,
>>> ompi_fortran_double_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_SUM(fortran_double_complex,
>>> opal_fortran_double_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> -COMPLEX_OP_FUNC_SUM(fortran_complex8, ompi_fortran_complex8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> +COMPLEX_OP_FUNC_SUM(fortran_complex8, opal_fortran_complex8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> -COMPLEX_OP_FUNC_SUM(fortran_complex16, ompi_fortran_complex16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> +COMPLEX_OP_FUNC_SUM(fortran_complex16, opal_fortran_complex16_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
>>> -COMPLEX_OP_FUNC_SUM(fortran_complex32, ompi_fortran_complex32_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32
>>> +COMPLEX_OP_FUNC_SUM(fortran_complex32, opal_fortran_complex32_t)
>>> #endif
>>>
>>> /
>>> *************************************************************************
>>> @@ -353,23 +353,23 @@
>>> OP_FUNC(prod, unsigned_long_long, unsigned long long, *=)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -OP_FUNC(prod, fortran_integer, ompi_fortran_integer_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +OP_FUNC(prod, fortran_integer, opal_fortran_integer_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -OP_FUNC(prod, fortran_integer1, ompi_fortran_integer1_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +OP_FUNC(prod, fortran_integer1, opal_fortran_integer1_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -OP_FUNC(prod, fortran_integer2, ompi_fortran_integer2_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +OP_FUNC(prod, fortran_integer2, opal_fortran_integer2_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -OP_FUNC(prod, fortran_integer4, ompi_fortran_integer4_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +OP_FUNC(prod, fortran_integer4, opal_fortran_integer4_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -OP_FUNC(prod, fortran_integer8, ompi_fortran_integer8_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +OP_FUNC(prod, fortran_integer8, opal_fortran_integer8_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -OP_FUNC(prod, fortran_integer16, ompi_fortran_integer16_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +OP_FUNC(prod, fortran_integer16, opal_fortran_integer16_t, *=)
>>> #endif
>>> /* Floating point */
>>> OP_FUNC(prod, float, float, *=)
>>> @@ -377,39 +377,39 @@
>>> #if HAVE_LONG_DOUBLE
>>> OP_FUNC(prod, long_double, long double, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -OP_FUNC(prod, fortran_real, ompi_fortran_real_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +OP_FUNC(prod, fortran_real, opal_fortran_real_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -OP_FUNC(prod, fortran_double_precision,
>>> ompi_fortran_double_precision_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +OP_FUNC(prod, fortran_double_precision,
>>> opal_fortran_double_precision_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -OP_FUNC(prod, fortran_real2, ompi_fortran_real2_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +OP_FUNC(prod, fortran_real2, opal_fortran_real2_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -OP_FUNC(prod, fortran_real4, ompi_fortran_real4_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +OP_FUNC(prod, fortran_real4, opal_fortran_real4_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -OP_FUNC(prod, fortran_real8, ompi_fortran_real8_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +OP_FUNC(prod, fortran_real8, opal_fortran_real8_t, *=)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -OP_FUNC(prod, fortran_real16, ompi_fortran_real16_t, *=)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +OP_FUNC(prod, fortran_real16, opal_fortran_real16_t, *=)
>>> #endif
>>> /* Complex */
>>> -#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_PROD(fortran_complex, ompi_fortran_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_PROD(fortran_complex, opal_fortran_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_PROD(fortran_double_complex,
>>> ompi_fortran_double_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_PROD(fortran_double_complex,
>>> opal_fortran_double_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> -COMPLEX_OP_FUNC_PROD(fortran_complex8, ompi_fortran_complex8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> +COMPLEX_OP_FUNC_PROD(fortran_complex8, opal_fortran_complex8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> -COMPLEX_OP_FUNC_PROD(fortran_complex16, ompi_fortran_complex16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> +COMPLEX_OP_FUNC_PROD(fortran_complex16, opal_fortran_complex16_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
>>> -COMPLEX_OP_FUNC_PROD(fortran_complex32, ompi_fortran_complex32_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32
>>> +COMPLEX_OP_FUNC_PROD(fortran_complex32, opal_fortran_complex32_t)
>>> #endif
>>>
>>> /
>>> *************************************************************************
>>> @@ -432,8 +432,8 @@
>>> FUNC_FUNC(land, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Logical */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> -FUNC_FUNC(land, fortran_logical, ompi_fortran_logical_t)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> +FUNC_FUNC(land, fortran_logical, opal_fortran_logical_t)
>>> #endif
>>> /* C++ bool */
>>> FUNC_FUNC(land, bool, bool)
>>> @@ -458,8 +458,8 @@
>>> FUNC_FUNC(lor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Logical */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> -FUNC_FUNC(lor, fortran_logical, ompi_fortran_logical_t)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> +FUNC_FUNC(lor, fortran_logical, opal_fortran_logical_t)
>>> #endif
>>> /* C++ bool */
>>> FUNC_FUNC(lor, bool, bool)
>>> @@ -484,8 +484,8 @@
>>> FUNC_FUNC(lxor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Logical */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> -FUNC_FUNC(lxor, fortran_logical, ompi_fortran_logical_t)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> +FUNC_FUNC(lxor, fortran_logical, opal_fortran_logical_t)
>>> #endif
>>> /* C++ bool */
>>> FUNC_FUNC(lxor, bool, bool)
>>> @@ -510,23 +510,23 @@
>>> FUNC_FUNC(band, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC(band, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC(band, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC(band, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC(band, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC(band, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC(band, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC(band, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC(band, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC(band, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC(band, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC(band, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC(band, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Byte */
>>> FUNC_FUNC(band, byte, char)
>>> @@ -551,23 +551,23 @@
>>> FUNC_FUNC(bor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC(bor, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC(bor, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC(bor, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC(bor, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC(bor, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC(bor, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC(bor, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC(bor, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC(bor, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC(bor, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC(bor, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC(bor, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Byte */
>>> FUNC_FUNC(bor, byte, char)
>>> @@ -592,23 +592,23 @@
>>> FUNC_FUNC(bxor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC(bxor, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC(bxor, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC(bxor, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC(bxor, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC(bxor, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC(bxor, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC(bxor, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC(bxor, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC(bxor, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC(bxor, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC(bxor, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC(bxor, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Byte */
>>> FUNC_FUNC(bxor, byte, char)
>>> @@ -617,14 +617,14 @@
>>> * Min and max location "pair" datatypes
>>>
>>> *************************************************************************
>>> /
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -LOC_STRUCT(2real, ompi_fortran_real_t, ompi_fortran_real_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +LOC_STRUCT(2real, opal_fortran_real_t, opal_fortran_real_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -LOC_STRUCT(2double_precision, ompi_fortran_double_precision_t,
>>> ompi_fortran_double_precision_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +LOC_STRUCT(2double_precision, opal_fortran_double_precision_t,
>>> opal_fortran_double_precision_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -LOC_STRUCT(2integer, ompi_fortran_integer_t, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +LOC_STRUCT(2integer, opal_fortran_integer_t, opal_fortran_integer_t)
>>> #endif
>>> LOC_STRUCT(float_int, float, int)
>>> LOC_STRUCT(double_int, double, int)
>>> @@ -639,13 +639,13 @@
>>> * Max location
>>>
>>> *************************************************************************
>>> /
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> LOC_FUNC(maxloc, 2real, >)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> LOC_FUNC(maxloc, 2double_precision, >)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> LOC_FUNC(maxloc, 2integer, >)
>>> #endif
>>> LOC_FUNC(maxloc, float_int, >)
>>> @@ -661,13 +661,13 @@
>>> * Min location
>>>
>>> *************************************************************************
>>> /
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> LOC_FUNC(minloc, 2real, <)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> LOC_FUNC(minloc, 2double_precision, <)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> LOC_FUNC(minloc, 2integer, <)
>>> #endif
>>> LOC_FUNC(minloc, float_int, <)
>>> @@ -816,23 +816,23 @@
>>> FUNC_FUNC_3BUF(max, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC_3BUF(max, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC_3BUF(max, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC_3BUF(max, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC_3BUF(max, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC_3BUF(max, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC_3BUF(max, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC_3BUF(max, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC_3BUF(max, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC_3BUF(max, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC_3BUF(max, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC_3BUF(max, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC_3BUF(max, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Floating point */
>>> FUNC_FUNC_3BUF(max, float, float)
>>> @@ -840,23 +840,23 @@
>>> #if HAVE_LONG_DOUBLE
>>> FUNC_FUNC_3BUF(max, long_double, long double)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -FUNC_FUNC_3BUF(max, fortran_real, ompi_fortran_real_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +FUNC_FUNC_3BUF(max, fortran_real, opal_fortran_real_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -FUNC_FUNC_3BUF(max, fortran_double_precision,
>>> ompi_fortran_double_precision_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +FUNC_FUNC_3BUF(max, fortran_double_precision,
>>> opal_fortran_double_precision_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -FUNC_FUNC_3BUF(max, fortran_real2, ompi_fortran_real2_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +FUNC_FUNC_3BUF(max, fortran_real2, opal_fortran_real2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -FUNC_FUNC_3BUF(max, fortran_real4, ompi_fortran_real4_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +FUNC_FUNC_3BUF(max, fortran_real4, opal_fortran_real4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -FUNC_FUNC_3BUF(max, fortran_real8, ompi_fortran_real8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +FUNC_FUNC_3BUF(max, fortran_real8, opal_fortran_real8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -FUNC_FUNC_3BUF(max, fortran_real16, ompi_fortran_real16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +FUNC_FUNC_3BUF(max, fortran_real16, opal_fortran_real16_t)
>>> #endif
>>>
>>>
>>> @@ -880,23 +880,23 @@
>>> FUNC_FUNC_3BUF(min, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC_3BUF(min, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC_3BUF(min, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC_3BUF(min, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC_3BUF(min, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC_3BUF(min, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC_3BUF(min, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC_3BUF(min, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC_3BUF(min, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC_3BUF(min, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC_3BUF(min, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC_3BUF(min, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC_3BUF(min, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Floating point */
>>> FUNC_FUNC_3BUF(min, float, float)
>>> @@ -904,23 +904,23 @@
>>> #if HAVE_LONG_DOUBLE
>>> FUNC_FUNC_3BUF(min, long_double, long double)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -FUNC_FUNC_3BUF(min, fortran_real, ompi_fortran_real_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +FUNC_FUNC_3BUF(min, fortran_real, opal_fortran_real_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -FUNC_FUNC_3BUF(min, fortran_double_precision,
>>> ompi_fortran_double_precision_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +FUNC_FUNC_3BUF(min, fortran_double_precision,
>>> opal_fortran_double_precision_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -FUNC_FUNC_3BUF(min, fortran_real2, ompi_fortran_real2_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +FUNC_FUNC_3BUF(min, fortran_real2, opal_fortran_real2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -FUNC_FUNC_3BUF(min, fortran_real4, ompi_fortran_real4_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +FUNC_FUNC_3BUF(min, fortran_real4, opal_fortran_real4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -FUNC_FUNC_3BUF(min, fortran_real8, ompi_fortran_real8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +FUNC_FUNC_3BUF(min, fortran_real8, opal_fortran_real8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -FUNC_FUNC_3BUF(min, fortran_real16, ompi_fortran_real16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +FUNC_FUNC_3BUF(min, fortran_real16, opal_fortran_real16_t)
>>> #endif
>>>
>>> /
>>> *************************************************************************
>>> @@ -941,23 +941,23 @@
>>> OP_FUNC_3BUF(sum, unsigned_long_long, unsigned long long, +)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -OP_FUNC_3BUF(sum, fortran_integer, ompi_fortran_integer_t, +)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +OP_FUNC_3BUF(sum, fortran_integer, opal_fortran_integer_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -OP_FUNC_3BUF(sum, fortran_integer1, ompi_fortran_integer1_t, +)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +OP_FUNC_3BUF(sum, fortran_integer1, opal_fortran_integer1_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -OP_FUNC_3BUF(sum, fortran_integer2, ompi_fortran_integer2_t, +)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +OP_FUNC_3BUF(sum, fortran_integer2, opal_fortran_integer2_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -OP_FUNC_3BUF(sum, fortran_integer4, ompi_fortran_integer4_t, +)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +OP_FUNC_3BUF(sum, fortran_integer4, opal_fortran_integer4_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -OP_FUNC_3BUF(sum, fortran_integer8, ompi_fortran_integer8_t, +)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +OP_FUNC_3BUF(sum, fortran_integer8, opal_fortran_integer8_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -OP_FUNC_3BUF(sum, fortran_integer16, ompi_fortran_integer16_t, +)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +OP_FUNC_3BUF(sum, fortran_integer16, opal_fortran_integer16_t, +)
>>> #endif
>>> /* Floating point */
>>> OP_FUNC_3BUF(sum, float, float, +)
>>> @@ -965,39 +965,39 @@
>>> #if HAVE_LONG_DOUBLE
>>> OP_FUNC_3BUF(sum, long_double, long double, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -OP_FUNC_3BUF(sum, fortran_real, ompi_fortran_real_t, +)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +OP_FUNC_3BUF(sum, fortran_real, opal_fortran_real_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -OP_FUNC_3BUF(sum, fortran_double_precision,
>>> ompi_fortran_double_precision_t, +)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +OP_FUNC_3BUF(sum, fortran_double_precision,
>>> opal_fortran_double_precision_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -OP_FUNC_3BUF(sum, fortran_real2, ompi_fortran_real2_t, +)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +OP_FUNC_3BUF(sum, fortran_real2, opal_fortran_real2_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -OP_FUNC_3BUF(sum, fortran_real4, ompi_fortran_real4_t, +)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +OP_FUNC_3BUF(sum, fortran_real4, opal_fortran_real4_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -OP_FUNC_3BUF(sum, fortran_real8, ompi_fortran_real8_t, +)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +OP_FUNC_3BUF(sum, fortran_real8, opal_fortran_real8_t, +)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -OP_FUNC_3BUF(sum, fortran_real16, ompi_fortran_real16_t, +)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +OP_FUNC_3BUF(sum, fortran_real16, opal_fortran_real16_t, +)
>>> #endif
>>> /* Complex */
>>> -#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex, ompi_fortran_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex, opal_fortran_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_SUM_3BUF(fortran_double_complex,
>>> ompi_fortran_double_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_SUM_3BUF(fortran_double_complex,
>>> opal_fortran_double_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex8, ompi_fortran_complex8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex8, opal_fortran_complex8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex16, ompi_fortran_complex16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex16, opal_fortran_complex16_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
>>> -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex32, ompi_fortran_complex32_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32
>>> +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex32, opal_fortran_complex32_t)
>>> #endif
>>>
>>> /
>>> *************************************************************************
>>> @@ -1018,23 +1018,23 @@
>>> OP_FUNC_3BUF(prod, unsigned_long_long, unsigned long long, *)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -OP_FUNC_3BUF(prod, fortran_integer, ompi_fortran_integer_t, *)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +OP_FUNC_3BUF(prod, fortran_integer, opal_fortran_integer_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -OP_FUNC_3BUF(prod, fortran_integer1, ompi_fortran_integer1_t, *)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +OP_FUNC_3BUF(prod, fortran_integer1, opal_fortran_integer1_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -OP_FUNC_3BUF(prod, fortran_integer2, ompi_fortran_integer2_t, *)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +OP_FUNC_3BUF(prod, fortran_integer2, opal_fortran_integer2_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -OP_FUNC_3BUF(prod, fortran_integer4, ompi_fortran_integer4_t, *)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +OP_FUNC_3BUF(prod, fortran_integer4, opal_fortran_integer4_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -OP_FUNC_3BUF(prod, fortran_integer8, ompi_fortran_integer8_t, *)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +OP_FUNC_3BUF(prod, fortran_integer8, opal_fortran_integer8_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -OP_FUNC_3BUF(prod, fortran_integer16, ompi_fortran_integer16_t, *)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +OP_FUNC_3BUF(prod, fortran_integer16, opal_fortran_integer16_t, *)
>>> #endif
>>> /* Floating point */
>>> OP_FUNC_3BUF(prod, float, float, *)
>>> @@ -1042,39 +1042,39 @@
>>> #if HAVE_LONG_DOUBLE
>>> OP_FUNC_3BUF(prod, long_double, long double, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -OP_FUNC_3BUF(prod, fortran_real, ompi_fortran_real_t, *)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +OP_FUNC_3BUF(prod, fortran_real, opal_fortran_real_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -OP_FUNC_3BUF(prod, fortran_double_precision,
>>> ompi_fortran_double_precision_t, *)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +OP_FUNC_3BUF(prod, fortran_double_precision,
>>> opal_fortran_double_precision_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> -OP_FUNC_3BUF(prod, fortran_real2, ompi_fortran_real2_t, *)
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> +OP_FUNC_3BUF(prod, fortran_real2, opal_fortran_real2_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> -OP_FUNC_3BUF(prod, fortran_real4, ompi_fortran_real4_t, *)
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> +OP_FUNC_3BUF(prod, fortran_real4, opal_fortran_real4_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> -OP_FUNC_3BUF(prod, fortran_real8, ompi_fortran_real8_t, *)
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> +OP_FUNC_3BUF(prod, fortran_real8, opal_fortran_real8_t, *)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16
>>> -OP_FUNC_3BUF(prod, fortran_real16, ompi_fortran_real16_t, *)
>>> +#if OPAL_HAVE_FORTRAN_REAL16
>>> +OP_FUNC_3BUF(prod, fortran_real16, opal_fortran_real16_t, *)
>>> #endif
>>> /* Complex */
>>> -#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex, ompi_fortran_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex, opal_fortran_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
>>> -COMPLEX_OP_FUNC_PROD_3BUF(fortran_double_complex,
>>> ompi_fortran_double_complex_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX
>>> +COMPLEX_OP_FUNC_PROD_3BUF(fortran_double_complex,
>>> opal_fortran_double_complex_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex8, ompi_fortran_complex8_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex8, opal_fortran_complex8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex16,
>>> ompi_fortran_complex16_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex16,
>>> opal_fortran_complex16_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32
>>> -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex32,
>>> ompi_fortran_complex32_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32
>>> +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex32,
>>> opal_fortran_complex32_t)
>>> #endif
>>>
>>> /
>>> *************************************************************************
>>> @@ -1097,8 +1097,8 @@
>>> FUNC_FUNC_3BUF(land, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Logical */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> -FUNC_FUNC_3BUF(land, fortran_logical, ompi_fortran_logical_t)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> +FUNC_FUNC_3BUF(land, fortran_logical, opal_fortran_logical_t)
>>> #endif
>>> /* C++ bool */
>>> FUNC_FUNC_3BUF(land, bool, bool)
>>> @@ -1123,8 +1123,8 @@
>>> FUNC_FUNC_3BUF(lor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Logical */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> -FUNC_FUNC_3BUF(lor, fortran_logical, ompi_fortran_logical_t)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> +FUNC_FUNC_3BUF(lor, fortran_logical, opal_fortran_logical_t)
>>> #endif
>>> /* C++ bool */
>>> FUNC_FUNC_3BUF(lor, bool, bool)
>>> @@ -1149,8 +1149,8 @@
>>> FUNC_FUNC_3BUF(lxor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Logical */
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> -FUNC_FUNC_3BUF(lxor, fortran_logical, ompi_fortran_logical_t)
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> +FUNC_FUNC_3BUF(lxor, fortran_logical, opal_fortran_logical_t)
>>> #endif
>>> /* C++ bool */
>>> FUNC_FUNC_3BUF(lxor, bool, bool)
>>> @@ -1175,23 +1175,23 @@
>>> FUNC_FUNC_3BUF(band, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC_3BUF(band, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC_3BUF(band, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC_3BUF(band, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC_3BUF(band, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC_3BUF(band, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC_3BUF(band, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC_3BUF(band, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC_3BUF(band, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC_3BUF(band, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC_3BUF(band, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC_3BUF(band, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC_3BUF(band, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Byte */
>>> FUNC_FUNC_3BUF(band, byte, char)
>>> @@ -1216,23 +1216,23 @@
>>> FUNC_FUNC_3BUF(bor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC_3BUF(bor, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC_3BUF(bor, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC_3BUF(bor, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC_3BUF(bor, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC_3BUF(bor, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC_3BUF(bor, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC_3BUF(bor, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC_3BUF(bor, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC_3BUF(bor, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC_3BUF(bor, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC_3BUF(bor, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC_3BUF(bor, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Byte */
>>> FUNC_FUNC_3BUF(bor, byte, char)
>>> @@ -1257,23 +1257,23 @@
>>> FUNC_FUNC_3BUF(bxor, unsigned_long_long, unsigned long long)
>>> #endif
>>> /* Fortran integer */
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -FUNC_FUNC_3BUF(bxor, fortran_integer, ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +FUNC_FUNC_3BUF(bxor, fortran_integer, opal_fortran_integer_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> -FUNC_FUNC_3BUF(bxor, fortran_integer1, ompi_fortran_integer1_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> +FUNC_FUNC_3BUF(bxor, fortran_integer1, opal_fortran_integer1_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> -FUNC_FUNC_3BUF(bxor, fortran_integer2, ompi_fortran_integer2_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> +FUNC_FUNC_3BUF(bxor, fortran_integer2, opal_fortran_integer2_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> -FUNC_FUNC_3BUF(bxor, fortran_integer4, ompi_fortran_integer4_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> +FUNC_FUNC_3BUF(bxor, fortran_integer4, opal_fortran_integer4_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> -FUNC_FUNC_3BUF(bxor, fortran_integer8, ompi_fortran_integer8_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> +FUNC_FUNC_3BUF(bxor, fortran_integer8, opal_fortran_integer8_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> -FUNC_FUNC_3BUF(bxor, fortran_integer16, ompi_fortran_integer16_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> +FUNC_FUNC_3BUF(bxor, fortran_integer16, opal_fortran_integer16_t)
>>> #endif
>>> /* Byte */
>>> FUNC_FUNC_3BUF(bxor, byte, char)
>>> @@ -1283,14 +1283,14 @@
>>>
>>> *************************************************************************
>>> /
>>>
>>> /*
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> -LOC_STRUCT_3BUF(2real, ompi_fortran_real_t, ompi_fortran_real_t)
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> +LOC_STRUCT_3BUF(2real, opal_fortran_real_t, opal_fortran_real_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> -LOC_STRUCT_3BUF(2double_precision, ompi_fortran_double_precision_t,
>>> ompi_fortran_double_precision_t)
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +LOC_STRUCT_3BUF(2double_precision, opal_fortran_double_precision_t,
>>> opal_fortran_double_precision_t)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> -LOC_STRUCT_3BUF(2integer, ompi_fortran_integer_t,
>>> ompi_fortran_integer_t)
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> +LOC_STRUCT_3BUF(2integer, opal_fortran_integer_t,
>>> opal_fortran_integer_t)
>>> #endif
>>> LOC_STRUCT_3BUF(float_int, float, int)
>>> LOC_STRUCT_3BUF(double_int, double, int)
>>> @@ -1306,13 +1306,13 @@
>>> * Max location
>>>
>>> *************************************************************************
>>> /
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> LOC_FUNC_3BUF(maxloc, 2real, >)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> LOC_FUNC_3BUF(maxloc, 2double_precision, >)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> LOC_FUNC_3BUF(maxloc, 2integer, >)
>>> #endif
>>> LOC_FUNC_3BUF(maxloc, float_int, >)
>>> @@ -1328,13 +1328,13 @@
>>> * Min location
>>>
>>> *************************************************************************
>>> /
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> LOC_FUNC_3BUF(minloc, 2real, <)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> LOC_FUNC_3BUF(minloc, 2double_precision, <)
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> LOC_FUNC_3BUF(minloc, 2integer, <)
>>> #endif
>>> LOC_FUNC_3BUF(minloc, float_int, <)
>>> @@ -1422,42 +1422,42 @@
>>>
>>> /** All the Fortran integers
>>> ********************************************/
>>>
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> #define FORTRAN_INTEGER_PLAIN(name)
>>> ompi_op_base_##name##_fortran_integer
>>> #define FORTRAN_INTEGER_PLAIN_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_integer
>>> #else
>>> #define FORTRAN_INTEGER_PLAIN(name) NULL
>>> #define FORTRAN_INTEGER_PLAIN_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER1
>>> +#if OPAL_HAVE_FORTRAN_INTEGER1
>>> #define FORTRAN_INTEGER1(name) ompi_op_base_##name##_fortran_integer1
>>> #define FORTRAN_INTEGER1_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_integer1
>>> #else
>>> #define FORTRAN_INTEGER1(name) NULL
>>> #define FORTRAN_INTEGER1_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER2
>>> +#if OPAL_HAVE_FORTRAN_INTEGER2
>>> #define FORTRAN_INTEGER2(name) ompi_op_base_##name##_fortran_integer2
>>> #define FORTRAN_INTEGER2_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_integer2
>>> #else
>>> #define FORTRAN_INTEGER2(name) NULL
>>> #define FORTRAN_INTEGER2_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER4
>>> +#if OPAL_HAVE_FORTRAN_INTEGER4
>>> #define FORTRAN_INTEGER4(name) ompi_op_base_##name##_fortran_integer4
>>> #define FORTRAN_INTEGER4_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_integer4
>>> #else
>>> #define FORTRAN_INTEGER4(name) NULL
>>> #define FORTRAN_INTEGER4_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER8
>>> +#if OPAL_HAVE_FORTRAN_INTEGER8
>>> #define FORTRAN_INTEGER8(name) ompi_op_base_##name##_fortran_integer8
>>> #define FORTRAN_INTEGER8_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_integer8
>>> #else
>>> #define FORTRAN_INTEGER8(name) NULL
>>> #define FORTRAN_INTEGER8_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER16
>>> +#if OPAL_HAVE_FORTRAN_INTEGER16
>>> #define FORTRAN_INTEGER16(name)
>>> ompi_op_base_##name##_fortran_integer16
>>> #define FORTRAN_INTEGER16_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_integer16
>>> #else
>>> @@ -1498,28 +1498,28 @@
>>>
>>> /** All the Fortran reals
>>> ***********************************************/
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> #define FLOATING_POINT_FORTRAN_REAL_PLAIN(name)
>>> ompi_op_base_##name##_fortran_real
>>> #define FLOATING_POINT_FORTRAN_REAL_PLAIN_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_real
>>> #else
>>> #define FLOATING_POINT_FORTRAN_REAL_PLAIN(name) NULL
>>> #define FLOATING_POINT_FORTRAN_REAL_PLAIN_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL2
>>> +#if OPAL_HAVE_FORTRAN_REAL2
>>> #define FLOATING_POINT_FORTRAN_REAL2(name)
>>> ompi_op_base_##name##_fortran_real2
>>> #define FLOATING_POINT_FORTRAN_REAL2_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_real2
>>> #else
>>> #define FLOATING_POINT_FORTRAN_REAL2(name) NULL
>>> #define FLOATING_POINT_FORTRAN_REAL2_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4
>>> +#if OPAL_HAVE_FORTRAN_REAL4
>>> #define FLOATING_POINT_FORTRAN_REAL4(name)
>>> ompi_op_base_##name##_fortran_real4
>>> #define FLOATING_POINT_FORTRAN_REAL4_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_real4
>>> #else
>>> #define FLOATING_POINT_FORTRAN_REAL4(name) NULL
>>> #define FLOATING_POINT_FORTRAN_REAL4_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8
>>> +#if OPAL_HAVE_FORTRAN_REAL8
>>> #define FLOATING_POINT_FORTRAN_REAL8(name)
>>> ompi_op_base_##name##_fortran_real8
>>> #define FLOATING_POINT_FORTRAN_REAL8_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_real8
>>> #else
>>> @@ -1532,7 +1532,7 @@
>>> corresponding C type
>>> Only then do we put in function pointers for REAL*16 reductions.
>>> Otherwise, just put in NULL. */
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C
>>> #define FLOATING_POINT_FORTRAN_REAL16(name)
>>> ompi_op_base_##name##_fortran_real16
>>> #define FLOATING_POINT_FORTRAN_REAL16_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_real16
>>> #else
>>> @@ -1556,7 +1556,7 @@
>>>
>>> /** Fortran double precision
>>> ********************************************/
>>>
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> #define FLOATING_POINT_FORTRAN_DOUBLE_PRECISION(name) \
>>> ompi_op_base_##name##_fortran_double_precision
>>> #define FLOATING_POINT_FORTRAN_DOUBLE_PRECISION_3BUFF(name) \
>>> @@ -1606,7 +1606,7 @@
>>>
>>> /** Fortran logical
>>> *****************************************************/
>>>
>>> -#if OMPI_HAVE_FORTRAN_LOGICAL
>>> +#if OPAL_HAVE_FORTRAN_LOGICAL
>>> #define FORTRAN_LOGICAL(name) \
>>> ompi_op_base_##name##_fortran_logical /*
>>> OMPI_OP_BASE_TYPE_LOGICAL */
>>> #define FORTRAN_LOGICAL_3BUFF(name) \
>>> @@ -1632,28 +1632,28 @@
>>>
>>> /** Fortran complex
>>> *****************************************************/
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX
>>> +#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX
>>> #define COMPLEX_PLAIN(name) ompi_op_base_##name##_fortran_complex
>>> #define COMPLEX_PLAIN_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_complex
>>> #else
>>> #define COMPLEX_PLAIN(name) NULL
>>> #define COMPLEX_PLAIN_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX
>>> #define COMPLEX_DOUBLE(name)
>>> ompi_op_base_##name##_fortran_double_complex
>>> #define COMPLEX_DOUBLE_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_double_complex
>>> #else
>>> #define COMPLEX_DOUBLE(name) NULL
>>> #define COMPLEX_DOUBLE_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8
>>> +#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8
>>> #define COMPLEX8(name) ompi_op_base_##name##_fortran_complex8
>>> #define COMPLEX8_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_complex8
>>> #else
>>> #define COMPLEX8(name) NULL
>>> #define COMPLEX8_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16
>>> +#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16
>>> #define COMPLEX16(name) ompi_op_base_##name##_fortran_complex16
>>> #define COMPLEX16_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_complex16
>>> #else
>>> @@ -1667,7 +1667,7 @@
>>> - we have fortran COMPILEX*32
>>> Only then do we put in function pointers for COMPLEX*32
>>> reductions.
>>> Otherwise, just put in NULL. */
>>> -#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C &&
>>> OMPI_HAVE_FORTRAN_COMPLEX32
>>> +#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C &&
>>> OPAL_HAVE_FORTRAN_COMPLEX32
>>> #define COMPLEX32(name) ompi_op_base_##name##_fortran_complex32
>>> #define COMPLEX32_3BUFF(name)
>>> ompi_op_base_3buff_##name##_fortran_complex32
>>> #else
>>> @@ -1719,21 +1719,21 @@
>>> /** Fortran complex
>>> *****************************************************/
>>> /** Fortran "2" types
>>> ***************************************************/
>>>
>>> -#if OMPI_HAVE_FORTRAN_REAL
>>> +#if OPAL_HAVE_FORTRAN_REAL
>>> #define TWOLOC_FORTRAN_2REAL(name) ompi_op_base_##name##_2real
>>> #define TWOLOC_FORTRAN_2REAL_3BUFF(name)
>>> ompi_op_base_3buff_##name##_2real
>>> #else
>>> #define TWOLOC_FORTRAN_2REAL(name) NULL
>>> #define TWOLOC_FORTRAN_2REAL_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION
>>> +#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION
>>> #define TWOLOC_FORTRAN_2DOUBLE_PRECISION(name)
>>> ompi_op_base_##name##_2double_precision
>>> #define TWOLOC_FORTRAN_2DOUBLE_PRECISION_3BUFF(name)
>>> ompi_op_base_3buff_##name##_2double_precision
>>> #else
>>> #define TWOLOC_FORTRAN_2DOUBLE_PRECISION(name) NULL
>>> #define TWOLOC_FORTRAN_2DOUBLE_PRECISION_3BUFF(name) NULL
>>> #endif
>>> -#if OMPI_HAVE_FORTRAN_INTEGER
>>> +#if OPAL_HAVE_FORTRAN_INTEGER
>>> #define TWOLOC_FORTRAN_2INTEGER(name) ompi_op_base_##name##_2integer
>>> #define TWOLOC_FORTRAN_2INTEGER_3BUFF(name)
>>> ompi_op_base_3buff_##name##_2integer
>>> #else
>>>
>>> Modified: trunk/ompi/mca/osc/base/osc_base_obj_convert.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mca/osc/base/osc_base_obj_convert.c (original)
>>> +++ trunk/ompi/mca/osc/base/osc_base_obj_convert.c 2009-05-30
>>> 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -149,13 +149,13 @@
>>> #else
>>> (conversion_fct_t)NULL, /*
>>> DT_CXX_BOOL */
>>> #endif
>>> -#if OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_CHAR
>>> +#if OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_CHAR
>>> (conversion_fct_t)copy_char, /*
>>> DT_LOGIC */
>>> -#elif OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_SHORT
>>> +#elif OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_SHORT
>>> (conversion_fct_t)copy_short, /*
>>> DT_LOGIC */
>>> -#elif OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT
>>> +#elif OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT
>>> (conversion_fct_t)copy_int, /*
>>> DT_LOGIC */
>>> -#elif OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_LONG
>>> +#elif OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_LONG
>>> (conversion_fct_t)copy_long, /*
>>> DT_LOGIC */
>>> #else
>>> (conversion_fct_t)NULL, /*
>>> DT_LOGIC */
>>>
>>> Modified: trunk/ompi/mpi/c/type_create_f90_integer.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/c/type_create_f90_integer.c (original)
>>> +++ trunk/ompi/mpi/c/type_create_f90_integer.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -60,11 +60,11 @@
>>> */
>>>
>>> if (r > 38) *newtype = &ompi_mpi_datatype_null.dt;
>>> -#if OMPI_HAVE_F90_INTEGER16
>>> +#if OPAL_HAVE_F90_INTEGER16
>>> else if (r > 18) *newtype = &ompi_mpi_long_long_int.dt;
>>> #else
>>> else if (r > 18) *newtype = &ompi_mpi_datatype_null.dt;
>>> -#endif /* OMPI_HAVE_F90_INTEGER16 */
>>> +#endif /* OPAL_HAVE_F90_INTEGER16 */
>>> #if SIZEOF_LONG > SIZEOF_INT
>>> else if (r > 9) *newtype = &ompi_mpi_long.dt;
>>> #else
>>>
>>> Modified: trunk/ompi/mpi/f77/base/attr_fn_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/base/attr_fn_f.c (original)
>>> +++ trunk/ompi/mpi/f77/base/attr_fn_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -85,14 +85,14 @@
>>> mpi_type_null_copy_fn_,
>>> mpi_type_null_copy_fn__,
>>> mpi_type_null_copy_fn_f,
>>> - (MPI_Fint* type, MPI_Fint* type_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint* ierr),
>>> + (MPI_Fint* type, MPI_Fint* type_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (type, type_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> OMPI_GENERATE_F77_BINDINGS( MPI_TYPE_DUP_FN,
>>> mpi_type_dup_fn,
>>> mpi_type_dup_fn_,
>>> mpi_type_dup_fn__,
>>> mpi_type_dup_fn_f,
>>> - (MPI_Fint* type, MPI_Fint* type_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint* ierr),
>>> + (MPI_Fint* type, MPI_Fint* type_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (type, type_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> OMPI_GENERATE_F77_BINDINGS( MPI_COMM_NULL_DELETE_FN,
>>> mpi_comm_null_delete_fn,
>>> @@ -106,14 +106,14 @@
>>> mpi_comm_null_copy_fn_,
>>> mpi_comm_null_copy_fn__,
>>> mpi_comm_null_copy_fn_f,
>>> - (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint* ierr),
>>> + (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (comm, comm_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> OMPI_GENERATE_F77_BINDINGS( MPI_COMM_DUP_FN,
>>> mpi_comm_dup_fn,
>>> mpi_comm_dup_fn_,
>>> mpi_comm_dup_fn__,
>>> mpi_comm_dup_fn_f,
>>> - (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint* ierr),
>>> + (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Aint* extra_state, MPI_Aint* attribute_val_in, MPI_Aint*
>>> attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (comm, comm_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> OMPI_GENERATE_F77_BINDINGS( MPI_NULL_DELETE_FN,
>>> mpi_null_delete_fn,
>>> @@ -127,14 +127,14 @@
>>> mpi_null_copy_fn_,
>>> mpi_null_copy_fn__,
>>> mpi_null_copy_fn_f,
>>> - (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Fint* extra_state, MPI_Fint* attribute_val_in, MPI_Fint*
>>> attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint* ierr),
>>> + (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Fint* extra_state, MPI_Fint* attribute_val_in, MPI_Fint*
>>> attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (comm, comm_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> OMPI_GENERATE_F77_BINDINGS( MPI_DUP_FN,
>>> mpi_dup_fn,
>>> mpi_dup_fn_,
>>> mpi_dup_fn__,
>>> mpi_dup_fn_f,
>>> - (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Fint* extra_state, MPI_Fint* attribute_val_in, MPI_Fint*
>>> attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint* ierr),
>>> + (MPI_Fint* comm, MPI_Fint* comm_keyval,
>>> MPI_Fint* extra_state, MPI_Fint* attribute_val_in, MPI_Fint*
>>> attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (comm, comm_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>>
>>> OMPI_GENERATE_F77_BINDINGS( MPI_WIN_NULL_DELETE_FN,
>>> @@ -149,14 +149,14 @@
>>> mpi_win_null_copy_fn_,
>>> mpi_win_null_copy_fn__,
>>> mpi_win_null_copy_fn_f,
>>> - (MPI_Fint* window, MPI_Fint*
>>> win_keyval, MPI_Aint* extra_state, MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint*
>>> ierr),
>>> + (MPI_Fint* window, MPI_Fint*
>>> win_keyval, MPI_Aint* extra_state, MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (window, win_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> OMPI_GENERATE_F77_BINDINGS( MPI_WIN_DUP_FN,
>>> mpi_win_dup_fn,
>>> mpi_win_dup_fn_,
>>> mpi_win_dup_fn__,
>>> mpi_win_dup_fn_f,
>>> - (MPI_Fint* window, MPI_Fint*
>>> win_keyval, MPI_Aint* extra_state, MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out, ompi_fortran_logical_t* flag, MPI_Fint*
>>> ierr),
>>> + (MPI_Fint* window, MPI_Fint*
>>> win_keyval, MPI_Aint* extra_state, MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out, MPI_Flogical* flag, MPI_Fint* ierr),
>>> (window, win_keyval, extra_state,
>>> attribute_val_in, attribute_val_out, flag, ierr) )
>>> #endif
>>>
>>> @@ -194,9 +194,9 @@
>>> MPI_Aint* extra_state,
>>> MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag,
>>> MPI_Fint* ierr)
>>> + MPI_Flogical* flag, MPI_Fint* ierr)
>>> {
>>> - *flag = (ompi_fortran_logical_t) 0;
>>> + *flag = (MPI_Flogical) 0;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>>
>>> @@ -204,9 +204,9 @@
>>> MPI_Aint* extra_state,
>>> MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag, MPI_Fint* ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 1;
>>> + *flag = (MPI_Flogical) 1;
>>> *attribute_val_out = *attribute_val_in;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>> @@ -222,9 +222,9 @@
>>> MPI_Aint* extra_state,
>>> MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag,
>>> MPI_Fint* ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 0;
>>> + *flag = (MPI_Flogical) 0;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>>
>>> @@ -232,9 +232,9 @@
>>> MPI_Aint* extra_state,
>>> MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag, MPI_Fint*
>>> ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 1;
>>> + *flag = (MPI_Flogical) 1;
>>> *attribute_val_out = *attribute_val_in;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>> @@ -250,9 +250,9 @@
>>> MPI_Fint* extra_state,
>>> MPI_Fint* attribute_val_in,
>>> MPI_Fint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag, MPI_Fint*
>>> ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 0;
>>> + *flag = (MPI_Flogical) 0;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>>
>>> @@ -261,9 +261,9 @@
>>> MPI_Fint* extra_state,
>>> MPI_Fint* attribute_val_in,
>>> MPI_Fint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag, MPI_Fint* ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 1;
>>> + *flag = (MPI_Flogical) 1;
>>> *attribute_val_out = *attribute_val_in;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>> @@ -279,9 +279,9 @@
>>> MPI_Aint* extra_state,
>>> MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag,
>>> MPI_Fint* ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 0;
>>> + *flag = (MPI_Flogical) 0;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>>
>>> @@ -289,9 +289,9 @@
>>> MPI_Aint* extra_state,
>>> MPI_Aint* attribute_val_in,
>>> MPI_Aint* attribute_val_out,
>>> - ompi_fortran_logical_t* flag, MPI_Fint* ierr )
>>> + MPI_Flogical* flag, MPI_Fint* ierr )
>>> {
>>> - *flag = (ompi_fortran_logical_t) 1;
>>> + *flag = (MPI_Flogical) 1;
>>> *attribute_val_out = *attribute_val_in;
>>> *ierr = OMPI_INT_2_FINT(MPI_SUCCESS);
>>> }
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_all_end_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_all_end_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_all_end_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -62,7 +62,7 @@
>>> MPI_Fint *ierr)
>>> {
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -86,7 +86,7 @@
>>>
>>> *ierr = OMPI_INT_2_FINT(MPI_File_read_all_end(c_fh, buf,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_all_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_all_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_all_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -64,7 +64,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -76,7 +76,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -87,7 +87,7 @@
>>> OMPI_FINT_2_INT(*count),
>>> c_type, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_at_all_end_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_at_all_end_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_at_all_end_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -63,7 +63,7 @@
>>> {
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -86,7 +86,7 @@
>>>
>>> *ierr = OMPI_FINT_2_INT(MPI_File_read_at_all_end(c_fh, buf,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_at_all_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_at_all_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_at_all_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -67,7 +67,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -79,7 +79,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -93,7 +93,7 @@
>>> c_type,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_at_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_at_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_at_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -66,7 +66,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -80,7 +80,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -93,7 +93,7 @@
>>> OMPI_FINT_2_INT(*count),
>>> c_type, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -65,7 +65,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -88,7 +88,7 @@
>>> OMPI_FINT_2_INT(*count),
>>> c_type, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_ordered_end_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_ordered_end_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_ordered_end_f.c 2009-05-30
>>> 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -64,7 +64,7 @@
>>> {
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -78,7 +78,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -87,7 +87,7 @@
>>>
>>> *ierr = OMPI_INT_2_FINT(MPI_File_read_ordered_end(c_fh, buf,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_ordered_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_ordered_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_ordered_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -65,7 +65,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -90,7 +90,7 @@
>>> c_type,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_read_shared_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_read_shared_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_read_shared_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -65,7 +65,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -90,7 +90,7 @@
>>> c_type,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_all_end_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_all_end_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_all_end_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -62,7 +62,7 @@
>>> MPI_Fint *ierr)
>>> {
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -86,7 +86,7 @@
>>>
>>> *ierr = OMPI_INT_2_FINT(MPI_File_write_all_end(c_fh, buf,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_all_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_all_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_all_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -64,7 +64,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -76,7 +76,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -87,7 +87,7 @@
>>> OMPI_FINT_2_INT(*count),
>>> c_type, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_at_all_end_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_at_all_end_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_at_all_end_f.c 2009-05-30
>>> 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -63,7 +63,7 @@
>>> {
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -86,7 +86,7 @@
>>>
>>> *ierr = OMPI_FINT_2_INT(MPI_File_write_at_all_end(c_fh, buf,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_at_all_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_at_all_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_at_all_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -66,7 +66,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -78,7 +78,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -92,7 +92,7 @@
>>> c_type,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_at_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_at_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_at_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -64,7 +64,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -76,7 +76,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -89,7 +89,7 @@
>>> OMPI_FINT_2_INT(*count),
>>> c_type, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -64,7 +64,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -76,7 +76,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -87,7 +87,7 @@
>>> OMPI_FINT_2_INT(*count),
>>> c_type, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_ordered_end_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_ordered_end_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_ordered_end_f.c 2009-05-30
>>> 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -63,7 +63,7 @@
>>> {
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -86,7 +86,7 @@
>>>
>>> *ierr = OMPI_INT_2_FINT(MPI_File_write_ordered_end(c_fh, buf,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_ordered_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_ordered_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_ordered_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -65,7 +65,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -90,7 +90,7 @@
>>> c_type,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/file_write_shared_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/file_write_shared_f.c (original)
>>> +++ trunk/ompi/mpi/f77/file_write_shared_f.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -65,7 +65,7 @@
>>> MPI_File c_fh = MPI_File_f2c(*fh);
>>> MPI_Datatype c_type = MPI_Type_f2c(*datatype);
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -77,7 +77,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -90,7 +90,7 @@
>>> c_type,
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/fint_2_int.h
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/fint_2_int.h (original)
>>> +++ trunk/ompi/mpi/f77/fint_2_int.h 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -27,7 +27,7 @@
>>> * Define MACROS to take account of different size of MPI_Fint from
>>> int
>>> */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> #define OMPI_ARRAY_NAME_DECL(a)
>>> #define OMPI_2_DIM_ARRAY_NAME_DECL(a, dim2)
>>> #define OMPI_SINGLE_NAME_DECL(a)
>>> @@ -43,7 +43,7 @@
>>> #define OMPI_SINGLE_INT_2_FINT(in)
>>> #define OMPI_ARRAY_INT_2_FINT(in, n)
>>>
>>> -#elif OMPI_SIZEOF_FORTRAN_INTEGER > SIZEOF_INT
>>> +#elif OPAL_SIZEOF_FORTRAN_INTEGER > SIZEOF_INT
>>> #define OMPI_ARRAY_NAME_DECL(a) int *c_##a
>>> #define OMPI_2_DIM_ARRAY_NAME_DECL(a, dim2) int (*c_##a)[dim2],
>>> dim2_index
>>> #define OMPI_SINGLE_NAME_DECL(a) int c_##a
>>> @@ -156,7 +156,7 @@
>>> * Define MACROS to take account of different size of logical from
>>> int
>>> */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT
>>> # define OMPI_LOGICAL_NAME_DECL(in) /* Not needed
>>> for int==logical */
>>> # define OMPI_LOGICAL_NAME_CONVERT(in) in /* Not needed
>>> for int==logical */
>>> # define OMPI_LOGICAL_SINGLE_NAME_CONVERT(in) in /* Not needed for
>>> int==logical */
>>> @@ -165,7 +165,7 @@
>>> # define OMPI_ARRAY_LOGICAL_2_INT_ALLOC(in,n) /* Not needed
>>> for int==logical */
>>> # define OMPI_ARRAY_LOGICAL_2_INT_CLEANUP(in) /* Not needed
>>> for int==logical */
>>>
>>> -# if OMPI_FORTRAN_VALUE_TRUE == 1
>>> +# if OPAL_FORTRAN_VALUE_TRUE == 1
>>> # define OMPI_FORTRAN_MUST_CONVERT_LOGICAL_2_INT 0
>>> # define OMPI_LOGICAL_2_INT(a) a
>>> # define OMPI_INT_2_LOGICAL(a) a
>>> @@ -175,7 +175,7 @@
>>> # else
>>> # define OMPI_FORTRAN_MUST_CONVERT_LOGICAL_2_INT 1
>>> # define OMPI_LOGICAL_2_INT(a) ((a)==0? 0 : 1)
>>> -# define OMPI_INT_2_LOGICAL(a) ((a)==0? 0 :
>>> OMPI_FORTRAN_VALUE_TRUE)
>>> +# define OMPI_INT_2_LOGICAL(a) ((a)==0? 0 :
>>> OPAL_FORTRAN_VALUE_TRUE)
>>> # define OMPI_SINGLE_INT_2_LOGICAL(a)
>>> *a=OMPI_INT_2_LOGICAL(OMPI_LOGICAL_NAME_CONVERT(*a))
>>> # define OMPI_ARRAY_LOGICAL_2_INT(in, n) do { \
>>> int converted_n = (int)(n); \
>>> @@ -208,13 +208,13 @@
>>> # define OMPI_ARRAY_LOGICAL_2_INT_CLEANUP(in) \
>>> free(OMPI_LOGICAL_ARRAY_NAME_CONVERT(in))
>>>
>>> -# if OMPI_FORTRAN_VALUE_TRUE == 1
>>> +# if OPAL_FORTRAN_VALUE_TRUE == 1
>>> # define OMPI_LOGICAL_2_INT(a) (int)a
>>> # define OMPI_INT_2_LOGICAL(a) (MPI_Flogical)a
>>> # define OMPI_SINGLE_INT_2_LOGICAL(a)
>>> *a=(OMPI_INT_2_LOGICAL(OMPI_LOGICAL_NAME_CONVERT(a)))
>>> # else
>>> # define OMPI_LOGICAL_2_INT(a) ((a)==0? 0 : 1)
>>> -# define OMPI_INT_2_LOGICAL(a) ((a)==0? 0 :
>>> OMPI_FORTRAN_VALUE_TRUE)
>>> +# define OMPI_INT_2_LOGICAL(a) ((a)==0? 0 :
>>> OPAL_FORTRAN_VALUE_TRUE)
>>> # define OMPI_SINGLE_INT_2_LOGICAL(a)
>>> *a=(OMPI_INT_2_LOGICAL(OMPI_LOGICAL_NAME_CONVERT(a)))
>>> # endif
>>> # define OMPI_ARRAY_LOGICAL_2_INT(in, n) do { \
>>> @@ -231,7 +231,7 @@
>>> } \
>>> } while (0) \
>>> /* free(OMPI_LOGICAL_ARRAY_NAME_CONVERT(in)) * No Need to
>>> free, here */
>>> -#endif /* OMPI_SIZEOF_FORTRAN_LOGICAL */
>>> +#endif /* OPAL_SIZEOF_FORTRAN_LOGICAL */
>>>
>>>
>>> #endif /* OMPI_FINT_2_INT_H */
>>>
>>> Modified: trunk/ompi/mpi/f77/iprobe_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/iprobe_f.c (original)
>>> +++ trunk/ompi/mpi/f77/iprobe_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -64,7 +64,7 @@
>>> {
>>> MPI_Status *c_status;
>>> MPI_Comm c_comm;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>> OMPI_LOGICAL_NAME_DECL(flag);
>>> @@ -80,7 +80,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -93,7 +93,7 @@
>>> c_status));
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr)) {
>>> OMPI_SINGLE_INT_2_LOGICAL(flag);
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>> }
>>>
>>> Modified: trunk/ompi/mpi/f77/probe_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/probe_f.c (original)
>>> +++ trunk/ompi/mpi/f77/probe_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -63,7 +63,7 @@
>>> {
>>> MPI_Status *c_status;
>>> MPI_Comm c_comm;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>>
>>> @@ -78,7 +78,7 @@
>>> translation necessary -- let the underlying functions
>>> write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -89,7 +89,7 @@
>>> OMPI_FINT_2_INT(*tag),
>>> c_comm, c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/recv_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/recv_f.c (original)
>>> +++ trunk/ompi/mpi/f77/recv_f.c 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -64,7 +64,7 @@
>>> MPI_Fint *status, MPI_Fint *ierr)
>>> {
>>> MPI_Status *c_status;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> MPI_Status c_status2;
>>> #endif
>>> MPI_Comm c_comm = MPI_Comm_f2c(*comm);
>>> @@ -78,7 +78,7 @@
>>> translation necessary -- let the underlying functions write
>>> directly into the Fortran status */
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT
>>> c_status = (MPI_Status *) status;
>>> #else
>>> c_status = &c_status2;
>>> @@ -90,7 +90,7 @@
>>> c_type, OMPI_FINT_2_INT(*source),
>>> OMPI_FINT_2_INT(*tag), c_comm,
>>> c_status));
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) &&
>>> MPI_STATUS_IGNORE != c_status) {
>>> MPI_Status_c2f(c_status, status);
>>>
>>> Modified: trunk/ompi/mpi/f77/testsome_f.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f77/testsome_f.c (original)
>>> +++ trunk/ompi/mpi/f77/testsome_f.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -71,7 +71,7 @@
>>> MPI_Request *c_req;
>>> MPI_Status *c_status;
>>> int i;
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> int int_c;
>>> #endif
>>> OMPI_SINGLE_NAME_DECL(outcount);
>>> @@ -97,7 +97,7 @@
>>>
>>> OMPI_ARRAY_NAME_CONVERT(array_of_indices),
>>> c_status));
>>>
>>> -#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> +#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT
>>> OMPI_SINGLE_INT_2_FINT(outcount);
>>> int_c = OMPI_FINT_2_INT(*incount);
>>> OMPI_ARRAY_INT_2_FINT(array_of_indices, int_c);
>>>
>>> Modified: trunk/ompi/mpi/f90/fortran_sizes.h.in
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f90/fortran_sizes.h.in (original)
>>> +++ trunk/ompi/mpi/f90/fortran_sizes.h.in 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -19,36 +19,36 @@
>>>
>>> ! This file is used by scripts/mpi_sizeof.f90.sh (and therefore
>>> mpi_sizeof.f90)
>>>
>>> -integer :: OMPI_SIZEOF_F90_LOGICAL
>>> +integer :: OPAL_SIZEOF_F90_LOGICAL
>>>
>>> -integer :: OMPI_SIZEOF_F90_INT1
>>> -integer :: OMPI_SIZEOF_F90_INT2
>>> -integer :: OMPI_SIZEOF_F90_INT4
>>> -integer :: OMPI_SIZEOF_F90_INT8
>>> -integer :: OMPI_SIZEOF_F90_INT16
>>> -
>>> -integer :: OMPI_SIZEOF_F90_REAL2
>>> -integer :: OMPI_SIZEOF_F90_REAL4
>>> -integer :: OMPI_SIZEOF_F90_REAL8
>>> -integer :: OMPI_SIZEOF_F90_REAL16
>>> -
>>> -integer :: OMPI_SIZEOF_F90_COMPLEX8
>>> -integer :: OMPI_SIZEOF_F90_COMPLEX16
>>> -integer :: OMPI_SIZEOF_F90_COMPLEX32
>>> -
>>> -parameter(OMPI_SIZEOF_F90_LOGICAL = @OMPI_SIZEOF_F90_LOGICAL@)
>>> -
>>> -parameter(OMPI_SIZEOF_F90_INT1 = @OMPI_SIZEOF_F90_INTEGER1@)
>>> -parameter(OMPI_SIZEOF_F90_INT2 = @OMPI_SIZEOF_F90_INTEGER2@)
>>> -parameter(OMPI_SIZEOF_F90_INT4 = @OMPI_SIZEOF_F90_INTEGER4@)
>>> -parameter(OMPI_SIZEOF_F90_INT8 = @OMPI_SIZEOF_F90_INTEGER8@)
>>> -parameter(OMPI_SIZEOF_F90_INT16 = @OMPI_SIZEOF_F90_INTEGER16@)
>>> -
>>> -parameter(OMPI_SIZEOF_F90_REAL2 = @OMPI_SIZEOF_F90_REAL2@)
>>> -parameter(OMPI_SIZEOF_F90_REAL4 = @OMPI_SIZEOF_F90_REAL4@)
>>> -parameter(OMPI_SIZEOF_F90_REAL8 = @OMPI_SIZEOF_F90_REAL8@)
>>> -parameter(OMPI_SIZEOF_F90_REAL16 = @OMPI_SIZEOF_F90_REAL16@)
>>> -
>>> -parameter(OMPI_SIZEOF_F90_COMPLEX8 = @OMPI_SIZEOF_F90_COMPLEX8@)
>>> -parameter(OMPI_SIZEOF_F90_COMPLEX16 = @OMPI_SIZEOF_F90_COMPLEX16@)
>>> -parameter(OMPI_SIZEOF_F90_COMPLEX32 = @OMPI_SIZEOF_F90_COMPLEX32@)
>>> +integer :: OPAL_SIZEOF_F90_INT1
>>> +integer :: OPAL_SIZEOF_F90_INT2
>>> +integer :: OPAL_SIZEOF_F90_INT4
>>> +integer :: OPAL_SIZEOF_F90_INT8
>>> +integer :: OPAL_SIZEOF_F90_INT16
>>> +
>>> +integer :: OPAL_SIZEOF_F90_REAL2
>>> +integer :: OPAL_SIZEOF_F90_REAL4
>>> +integer :: OPAL_SIZEOF_F90_REAL8
>>> +integer :: OPAL_SIZEOF_F90_REAL16
>>> +
>>> +integer :: OPAL_SIZEOF_F90_COMPLEX8
>>> +integer :: OPAL_SIZEOF_F90_COMPLEX16
>>> +integer :: OPAL_SIZEOF_F90_COMPLEX32
>>> +
>>> +parameter(OPAL_SIZEOF_F90_LOGICAL = @OPAL_SIZEOF_F90_LOGICAL@)
>>> +
>>> +parameter(OPAL_SIZEOF_F90_INT1 = @OPAL_SIZEOF_F90_INTEGER1@)
>>> +parameter(OPAL_SIZEOF_F90_INT2 = @OPAL_SIZEOF_F90_INTEGER2@)
>>> +parameter(OPAL_SIZEOF_F90_INT4 = @OPAL_SIZEOF_F90_INTEGER4@)
>>> +parameter(OPAL_SIZEOF_F90_INT8 = @OPAL_SIZEOF_F90_INTEGER8@)
>>> +parameter(OPAL_SIZEOF_F90_INT16 = @OPAL_SIZEOF_F90_INTEGER16@)
>>> +
>>> +parameter(OPAL_SIZEOF_F90_REAL2 = @OPAL_SIZEOF_F90_REAL2@)
>>> +parameter(OPAL_SIZEOF_F90_REAL4 = @OPAL_SIZEOF_F90_REAL4@)
>>> +parameter(OPAL_SIZEOF_F90_REAL8 = @OPAL_SIZEOF_F90_REAL8@)
>>> +parameter(OPAL_SIZEOF_F90_REAL16 = @OPAL_SIZEOF_F90_REAL16@)
>>> +
>>> +parameter(OPAL_SIZEOF_F90_COMPLEX8 = @OPAL_SIZEOF_F90_COMPLEX8@)
>>> +parameter(OPAL_SIZEOF_F90_COMPLEX16 = @OPAL_SIZEOF_F90_COMPLEX16@)
>>> +parameter(OPAL_SIZEOF_F90_COMPLEX32 = @OPAL_SIZEOF_F90_COMPLEX32@)
>>>
>>> Modified: trunk/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh (original)
>>> +++ trunk/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh 2009-05-30
>>> 11:54:29 EDT (Sat, 30 May 2009)
>>> @@ -32,7 +32,7 @@
>>> echo " logical*${kind}, intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_LOGICAL${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_LOGICAL${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -47,7 +47,7 @@
>>> echo " integer*${kind}, intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_INT${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_INT${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -62,7 +62,7 @@
>>> echo " real*${kind}, intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_REAL${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_REAL${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -77,7 +77,7 @@
>>> echo " complex*${kind}, intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_COMPLEX${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_COMPLEX${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -103,7 +103,7 @@
>>> echo " logical*${kind}, dimension(${dim}), intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_LOGICAL${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_LOGICAL${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -118,7 +118,7 @@
>>> echo " integer*${kind}, dimension(${dim}), intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_INT${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_INT${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -133,7 +133,7 @@
>>> echo " real*${kind}, dimension(${dim}), intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_REAL${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_REAL${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>> @@ -148,7 +148,7 @@
>>> echo " complex*${kind}, dimension(${dim}), intent(in) :: x"
>>> echo " integer, intent(out) :: size"
>>> echo " integer, intent(out) :: ierr"
>>> - echo " size = OMPI_SIZEOF_F90_COMPLEX${kind}"
>>> + echo " size = OPAL_SIZEOF_F90_COMPLEX${kind}"
>>> echo " ierr = 0"
>>> echo "end subroutine ${proc}"
>>> echo
>>>
>>> Modified: trunk/ompi/request/request.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/request/request.c (original)
>>> +++ trunk/ompi/request/request.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -103,7 +103,7 @@
>>> OBJ_CONSTRUCT(&ompi_request_null, ompi_request_t);
>>> OBJ_CONSTRUCT(&ompi_request_f_to_c_table, opal_pointer_array_t);
>>> if( OPAL_SUCCESS !=
>>> opal_pointer_array_init(&ompi_request_f_to_c_table,
>>> - 0,
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> + 0,
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>> ompi_request_null.request.req_type = OMPI_REQUEST_NULL;
>>>
>>> Modified: trunk/ompi/tools/ompi_info/param.cc
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/tools/ompi_info/param.cc (original)
>>> +++ trunk/ompi/tools/ompi_info/param.cc 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -584,10 +584,10 @@
>>> out("C double size", "compiler:c:sizeof:double", sizeof(double));
>>> out("C pointer size", "compiler:c:sizeof:pointer", sizeof(void
>>> *));
>>> out("C char align", "compiler:c:align:char",
>>> OPAL_ALIGNMENT_CHAR);
>>> - out("C bool align", "compiler:c:align:bool",
>>> OMPI_ALIGNMENT_CXX_BOOL);
>>> + out("C bool align", "compiler:c:align:bool",
>>> OPAL_ALIGNMENT_CXX_BOOL);
>>> out("C int align", "compiler:c:align:int", OPAL_ALIGNMENT_INT);
>>> - out("C float align", "compiler:c:align:float",
>>> OMPI_ALIGNMENT_FLOAT);
>>> - out("C double align", "compiler:c:align:double",
>>> OMPI_ALIGNMENT_DOUBLE);
>>> + out("C float align", "compiler:c:align:float",
>>> OPAL_ALIGNMENT_FLOAT);
>>> + out("C double align", "compiler:c:align:double",
>>> OPAL_ALIGNMENT_DOUBLE);
>>> }
>>>
>>> out("C++ compiler", "compiler:cxx:command", OMPI_CXX);
>>> @@ -605,115 +605,115 @@
>>> // Will always have the size of Fortran integer
>>>
>>> out("Fort integer size", "compiler:fortran:sizeof:integer",
>>> - OMPI_SIZEOF_FORTRAN_INTEGER);
>>> + OPAL_SIZEOF_FORTRAN_INTEGER);
>>>
>>> out("Fort logical size", "compiler:fortran:sizeof:logical",
>>> - OMPI_SIZEOF_FORTRAN_LOGICAL);
>>> + OPAL_SIZEOF_FORTRAN_LOGICAL);
>>> out("Fort logical value true", "compiler:fortran:value:true",
>>> - OMPI_FORTRAN_VALUE_TRUE);
>>> + OPAL_FORTRAN_VALUE_TRUE);
>>>
>>>
>>> // May or may not have the other Fortran sizes
>>>
>>> if (OMPI_WANT_F77_BINDINGS || OMPI_WANT_F90_BINDINGS) {
>>> out("Fort have integer1", "compiler:fortran:have:integer1",
>>> - OMPI_HAVE_FORTRAN_INTEGER1 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_INTEGER1 ? "yes" : "no");
>>> out("Fort have integer2", "compiler:fortran:have:integer2",
>>> - OMPI_HAVE_FORTRAN_INTEGER2 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_INTEGER2 ? "yes" : "no");
>>> out("Fort have integer4", "compiler:fortran:have:integer4",
>>> - OMPI_HAVE_FORTRAN_INTEGER4 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_INTEGER4 ? "yes" : "no");
>>> out("Fort have integer8", "compiler:fortran:have:integer8",
>>> - OMPI_HAVE_FORTRAN_INTEGER8 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_INTEGER8 ? "yes" : "no");
>>> out("Fort have integer16", "compiler:fortran:have:integer16",
>>> - OMPI_HAVE_FORTRAN_INTEGER16 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_INTEGER16 ? "yes" : "no");
>>>
>>> out("Fort have real4", "compiler:fortran:have:real4",
>>> - OMPI_HAVE_FORTRAN_REAL4 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_REAL4 ? "yes" : "no");
>>> out("Fort have real8", "compiler:fortran:have:real8",
>>> - OMPI_HAVE_FORTRAN_REAL8 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_REAL8 ? "yes" : "no");
>>> out("Fort have real16", "compiler:fortran:have:real16",
>>> - OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C ?
>>> "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C ?
>>> "yes" : "no");
>>>
>>> out("Fort have complex8", "compiler:fortran:have:complex8",
>>> - OMPI_HAVE_FORTRAN_COMPLEX8 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_COMPLEX8 ? "yes" : "no");
>>> out("Fort have complex16", "compiler:fortran:have:complex16",
>>> - OMPI_HAVE_FORTRAN_COMPLEX16 ? "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_COMPLEX16 ? "yes" : "no");
>>> out("Fort have complex32", "compiler:fortran:have:complex32",
>>> - OMPI_HAVE_FORTRAN_COMPLEX32 && OMPI_REAL16_MATCHES_C ?
>>> "yes" : "no");
>>> + OPAL_HAVE_FORTRAN_COMPLEX32 && OPAL_REAL16_MATCHES_C ?
>>> "yes" : "no");
>>>
>>> out("Fort integer1 size", "compiler:fortran:sizeof:integer1",
>>> - OMPI_HAVE_FORTRAN_INTEGER1 ?
>>> OMPI_SIZEOF_FORTRAN_INTEGER1 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER1 ?
>>> OPAL_SIZEOF_FORTRAN_INTEGER1 : -1);
>>> out("Fort integer2 size", "compiler:fortran:sizeof:integer2",
>>> - OMPI_HAVE_FORTRAN_INTEGER2 ?
>>> OMPI_SIZEOF_FORTRAN_INTEGER2 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER2 ?
>>> OPAL_SIZEOF_FORTRAN_INTEGER2 : -1);
>>> out("Fort integer4 size", "compiler:fortran:sizeof:integer4",
>>> - OMPI_HAVE_FORTRAN_INTEGER4 ?
>>> OMPI_SIZEOF_FORTRAN_INTEGER4 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER4 ?
>>> OPAL_SIZEOF_FORTRAN_INTEGER4 : -1);
>>> out("Fort integer8 size", "compiler:fortran:sizeof:integer8",
>>> - OMPI_HAVE_FORTRAN_INTEGER8 ?
>>> OMPI_SIZEOF_FORTRAN_INTEGER8 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER8 ?
>>> OPAL_SIZEOF_FORTRAN_INTEGER8 : -1);
>>> out("Fort integer16 size", "compiler:fortran:sizeof:integer17",
>>> - OMPI_HAVE_FORTRAN_INTEGER16 ?
>>> OMPI_SIZEOF_FORTRAN_INTEGER16 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER16 ?
>>> OPAL_SIZEOF_FORTRAN_INTEGER16 : -1);
>>>
>>> out("Fort real size", "compiler:fortran:sizeof:real",
>>> - OMPI_SIZEOF_FORTRAN_REAL);
>>> + OPAL_SIZEOF_FORTRAN_REAL);
>>> out("Fort real4 size", "compiler:fortran:sizeof:real4",
>>> - OMPI_HAVE_FORTRAN_REAL4 ? OMPI_SIZEOF_FORTRAN_REAL4 : -1);
>>> + OPAL_HAVE_FORTRAN_REAL4 ? OPAL_SIZEOF_FORTRAN_REAL4 : -1);
>>> out("Fort real8 size", "compiler:fortran:sizeof:real8",
>>> - OMPI_HAVE_FORTRAN_REAL8 ? OMPI_SIZEOF_FORTRAN_REAL8 : -1);
>>> + OPAL_HAVE_FORTRAN_REAL8 ? OPAL_SIZEOF_FORTRAN_REAL8 : -1);
>>> out("Fort real16 size", "compiler:fortran:sizeof:real17",
>>> - OMPI_HAVE_FORTRAN_REAL16 ? OMPI_SIZEOF_FORTRAN_REAL16 :
>>> -1);
>>> + OPAL_HAVE_FORTRAN_REAL16 ? OPAL_SIZEOF_FORTRAN_REAL16 :
>>> -1);
>>>
>>> out("Fort dbl prec size",
>>> "compiler:fortran:sizeof:double_precision",
>>> - OMPI_SIZEOF_FORTRAN_REAL);
>>> + OPAL_SIZEOF_FORTRAN_REAL);
>>>
>>> out("Fort cplx size", "compiler:fortran:sizeof:complex",
>>> - OMPI_SIZEOF_FORTRAN_REAL);
>>> + OPAL_SIZEOF_FORTRAN_REAL);
>>> out("Fort dbl cplx size",
>>> "compiler:fortran:sizeof:double_complex",
>>> - OMPI_SIZEOF_FORTRAN_REAL);
>>> + OPAL_SIZEOF_FORTRAN_REAL);
>>> out("Fort cplx8 size", "compiler:fortran:sizeof:complex8",
>>> - OMPI_HAVE_FORTRAN_COMPLEX8 ?
>>> OMPI_SIZEOF_FORTRAN_COMPLEX8 : -1);
>>> + OPAL_HAVE_FORTRAN_COMPLEX8 ?
>>> OPAL_SIZEOF_FORTRAN_COMPLEX8 : -1);
>>> out("Fort cplx16 size", "compiler:fortran:sizeof:complex16",
>>> - OMPI_HAVE_FORTRAN_COMPLEX16 ?
>>> OMPI_SIZEOF_FORTRAN_COMPLEX16 : -1);
>>> + OPAL_HAVE_FORTRAN_COMPLEX16 ?
>>> OPAL_SIZEOF_FORTRAN_COMPLEX16 : -1);
>>> out("Fort cplx32 size", "compiler:fortran:sizeof:complex32",
>>> - OMPI_HAVE_FORTRAN_COMPLEX32 ?
>>> OMPI_SIZEOF_FORTRAN_COMPLEX32 : -1);
>>> + OPAL_HAVE_FORTRAN_COMPLEX32 ?
>>> OPAL_SIZEOF_FORTRAN_COMPLEX32 : -1);
>>>
>>> out("Fort integer align", "compiler:fortran:align:integer",
>>> - OMPI_ALIGNMENT_FORTRAN_INTEGER);
>>> + OPAL_ALIGNMENT_FORTRAN_INTEGER);
>>> out("Fort integer1 align", "compiler:fortran:align:integer1",
>>> - OMPI_HAVE_FORTRAN_INTEGER1 ?
>>> OMPI_ALIGNMENT_FORTRAN_INTEGER1 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER1 ?
>>> OPAL_ALIGNMENT_FORTRAN_INTEGER1 : -1);
>>> out("Fort integer2 align", "compiler:fortran:align:integer2",
>>> - OMPI_HAVE_FORTRAN_INTEGER2 ?
>>> OMPI_ALIGNMENT_FORTRAN_INTEGER2 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER2 ?
>>> OPAL_ALIGNMENT_FORTRAN_INTEGER2 : -1);
>>> out("Fort integer4 align", "compiler:fortran:align:integer4",
>>> - OMPI_HAVE_FORTRAN_INTEGER4 ?
>>> OMPI_ALIGNMENT_FORTRAN_INTEGER4 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER4 ?
>>> OPAL_ALIGNMENT_FORTRAN_INTEGER4 : -1);
>>> out("Fort integer8 align", "compiler:fortran:align:integer8",
>>> - OMPI_HAVE_FORTRAN_INTEGER8 ?
>>> OMPI_ALIGNMENT_FORTRAN_INTEGER8 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER8 ?
>>> OPAL_ALIGNMENT_FORTRAN_INTEGER8 : -1);
>>> out("Fort integer16 align", "compiler:fortran:align:integer16",
>>> - OMPI_HAVE_FORTRAN_INTEGER16 ?
>>> OMPI_ALIGNMENT_FORTRAN_INTEGER16 : -1);
>>> + OPAL_HAVE_FORTRAN_INTEGER16 ?
>>> OPAL_ALIGNMENT_FORTRAN_INTEGER16 : -1);
>>>
>>> out("Fort real align", "compiler:fortran:align:real",
>>> - OMPI_ALIGNMENT_FORTRAN_REAL);
>>> + OPAL_ALIGNMENT_FORTRAN_REAL);
>>> out("Fort real4 align", "compiler:fortran:align:real4",
>>> - OMPI_HAVE_FORTRAN_REAL4 ? OMPI_ALIGNMENT_FORTRAN_REAL4 :
>>> -1);
>>> + OPAL_HAVE_FORTRAN_REAL4 ? OPAL_ALIGNMENT_FORTRAN_REAL4 :
>>> -1);
>>> out("Fort real8 align", "compiler:fortran:align:real8",
>>> - OMPI_HAVE_FORTRAN_REAL8 ? OMPI_ALIGNMENT_FORTRAN_REAL8 :
>>> -1);
>>> + OPAL_HAVE_FORTRAN_REAL8 ? OPAL_ALIGNMENT_FORTRAN_REAL8 :
>>> -1);
>>> out("Fort real16 align", "compiler:fortran:align:real16",
>>> - OMPI_HAVE_FORTRAN_REAL16 ?
>>> OMPI_ALIGNMENT_FORTRAN_REAL16 : -1);
>>> + OPAL_HAVE_FORTRAN_REAL16 ?
>>> OPAL_ALIGNMENT_FORTRAN_REAL16 : -1);
>>>
>>> out("Fort dbl prec align",
>>> "compiler:fortran:align:double_precision",
>>> - OMPI_ALIGNMENT_FORTRAN_REAL);
>>> + OPAL_ALIGNMENT_FORTRAN_REAL);
>>>
>>> out("Fort cplx align", "compiler:fortran:align:complex",
>>> - OMPI_ALIGNMENT_FORTRAN_REAL);
>>> + OPAL_ALIGNMENT_FORTRAN_REAL);
>>> out("Fort dbl cplx align",
>>> "compiler:fortran:align:double_complex",
>>> - OMPI_ALIGNMENT_FORTRAN_REAL);
>>> + OPAL_ALIGNMENT_FORTRAN_REAL);
>>> out("Fort cplx8 align", "compiler:fortran:align:complex8",
>>> - OMPI_HAVE_FORTRAN_COMPLEX8 ?
>>> OMPI_ALIGNMENT_FORTRAN_COMPLEX8 : -1);
>>> + OPAL_HAVE_FORTRAN_COMPLEX8 ?
>>> OPAL_ALIGNMENT_FORTRAN_COMPLEX8 : -1);
>>> out("Fort cplx16 align", "compiler:fortran:align:complex16",
>>> - OMPI_HAVE_FORTRAN_COMPLEX16 ?
>>> OMPI_ALIGNMENT_FORTRAN_COMPLEX16 : -1);
>>> + OPAL_HAVE_FORTRAN_COMPLEX16 ?
>>> OPAL_ALIGNMENT_FORTRAN_COMPLEX16 : -1);
>>> out("Fort cplx32 align", "compiler:fortran:align:complex32",
>>> - OMPI_HAVE_FORTRAN_COMPLEX32 ?
>>> OMPI_ALIGNMENT_FORTRAN_COMPLEX32 : -1);
>>> + OPAL_HAVE_FORTRAN_COMPLEX32 ?
>>> OPAL_ALIGNMENT_FORTRAN_COMPLEX32 : -1);
>>>
>>> } else {
>>> out("Fort real size", "compiler:fortran:sizeof:real",
>>> "skipped");
>>>
>>> Modified: trunk/ompi/win/win.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/ompi/win/win.c (original)
>>> +++ trunk/ompi/win/win.c 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -51,7 +51,7 @@
>>> /* setup window Fortran array */
>>> OBJ_CONSTRUCT(&ompi_mpi_windows, opal_pointer_array_t);
>>> if( OPAL_SUCCESS != opal_pointer_array_init(&ompi_mpi_windows, 0,
>>> -
>>> OMPI_FORTRAN_HANDLE_MAX, 64) ) {
>>> +
>>> OPAL_FORTRAN_HANDLE_MAX, 64) ) {
>>> return OMPI_ERROR;
>>> }
>>>
>>>
>>> Modified: trunk/opal/class/opal_bitmap.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/opal/class/opal_bitmap.c (original)
>>> +++ trunk/opal/class/opal_bitmap.c 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -133,7 +133,7 @@
>>> new_size = (int) new_size_large;
>>>
>>> /*
>>> - * No further tests against max_size (or
>>> OMPI_FORTRAN_HANDLE_MAX) are
>>> + * No further tests against max_size (or
>>> OPAL_FORTRAN_HANDLE_MAX) are
>>> * necessary, since we validated above, that the bit
>>> already is contained!
>>> */
>>>
>>>
>>> Modified: trunk/opal/class/opal_bitmap.h
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/opal/class/opal_bitmap.h (original)
>>> +++ trunk/opal/class/opal_bitmap.h 2009-05-30 11:54:29 EDT
>>> (Sat, 30 May 2009)
>>> @@ -33,7 +33,7 @@
>>> * To allow these bitmaps to track fortran handles (which MPI
>>> defines
>>> * to be Fortran INTEGER), we offer a opal_bitmap_set_max_size, so
>>> that
>>> * the upper layer can ask to never have more than
>>> - * OMPI_FORTRAN_HANDLE_MAX, which is min(INT_MAX, fortran INTEGER
>>> max).
>>> + * OPAL_FORTRAN_HANDLE_MAX, which is min(INT_MAX, fortran INTEGER
>>> max).
>>> * Currently the only user of this is ompi/attribute/attribute.c
>>> *
>>> */
>>>
>>> Modified: trunk/opal/class/opal_pointer_array.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/opal/class/opal_pointer_array.c (original)
>>> +++ trunk/opal/class/opal_pointer_array.c 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -116,7 +116,7 @@
>>> /* need to grow table */
>>> if (!grow_table(table,
>>> (NULL == table->addr ? TABLE_INIT : table-
>>>
>>>> size * TABLE_GROW),
>>>
>>> - OMPI_FORTRAN_HANDLE_MAX)) {
>>> + OPAL_FORTRAN_HANDLE_MAX)) {
>>> OPAL_THREAD_UNLOCK(&(table->lock));
>>> return OPAL_ERR_OUT_OF_RESOURCE;
>>> }
>>> @@ -330,7 +330,7 @@
>>> }
>>>
>>> /* We've already established (above) that the arithmetic
>>> - below will be less than OMPI_FORTRAN_HANDLE_MAX */
>>> + below will be less than OPAL_FORTRAN_HANDLE_MAX */
>>>
>>> new_size_int = (int) new_size;
>>> table->number_free += new_size_int - table->size;
>>>
>>> Modified: trunk/opal/include/opal_config_bottom.h
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/opal/include/opal_config_bottom.h (original)
>>> +++ trunk/opal/include/opal_config_bottom.h 2009-05-30 11:54:29
>>> EDT (Sat, 30 May 2009)
>>> @@ -298,15 +298,15 @@
>>> alignment */
>>> # define false 0
>>> # define true 1
>>> -# if SIZEOF_BOOL == SIZEOF_CHAR &&
>>> OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_CHAR
>>> +# if SIZEOF_BOOL == SIZEOF_CHAR &&
>>> OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_CHAR
>>> typedef unsigned char bool;
>>> -# elif SIZEOF_BOOL == SIZEOF_SHORT &&
>>> OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_SHORT
>>> +# elif SIZEOF_BOOL == SIZEOF_SHORT &&
>>> OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_SHORT
>>> typedef short bool;
>>> -# elif SIZEOF_BOOL == SIZEOF_INT &&
>>> OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_INT
>>> +# elif SIZEOF_BOOL == SIZEOF_INT &&
>>> OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_INT
>>> typedef int bool;
>>> -# elif SIZEOF_BOOL == SIZEOF_LONG &&
>>> OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG
>>> +# elif SIZEOF_BOOL == SIZEOF_LONG &&
>>> OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG
>>> typedef long bool;
>>> -# elif defined(SIZEOF_LONG_LONG) &&
>>> defined(OPAL_ALIGNMENT_LONG) && SIZEOF_BOOL == SIZEOF_LONG &&
>>> OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG
>>> +# elif defined(SIZEOF_LONG_LONG) &&
>>> defined(OPAL_ALIGNMENT_LONG) && SIZEOF_BOOL == SIZEOF_LONG &&
>>> OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG
>>> typedef long long bool;
>>> # else
>>> # error Cannot find a C type that corresponds to the
>>> size and alignment of C++ bool!
>>>
>>> Modified: trunk/opal/util/arch.c
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> =
>>> ======================================================================
>>> --- trunk/opal/util/arch.c (original)
>>> +++ trunk/opal/util/arch.c 2009-05-30 11:54:29 EDT (Sat, 30 May
>>> 2009)
>>> @@ -49,11 +49,11 @@
>>> * placed here to explain the abstraction break and
>>> * indicate that it will eventually be fixed
>>> */
>>> - if (1 == sizeof(ompi_fortran_logical_t) ) {
>>> + if (1 == sizeof(opal_fortran_logical_t) ) {
>>> opal_arch_setmask( me, OPAL_ARCH_LOGICALIS8);
>>> - } else if (2 == sizeof(ompi_fortran_logical_t)) {
>>> + } else if (2 == sizeof(opal_fortran_logical_t)) {
>>> opal_arch_setmask( me, OPAL_ARCH_LOGICALIS16);
>>> - } else if (4 == sizeof(ompi_fortran_logical_t)) {
>>> + } else if (4 == sizeof(opal_fortran_logical_t)) {
>>> opal_arch_setmask( me, OPAL_ARCH_LOGICALIS32);
>>> }
>>>
>>> _______________________________________________
>>> svn-full mailing list
>>> svn-full_at_[hidden]
>>> http://www.open-mpi.org/mailman/listinfo.cgi/svn-full
>
>