Open MPI logo

Open MPI Development Mailing List Archives

  |   Home   |   Support   |   FAQ   |   all Development mailing list

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
>
>