Re: [OMPI devel] opal / fortran / Flogical

Mon, 1 Jun 2009 10:42:03 -0400 

I have to agree with Jeff's concerns.

Brian

On Mon, 1 Jun 2009, 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, <rusra...@osl.iu.edu> <rusra...@osl.iu.edu> 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-f...@open-mpi.org
http://www.open-mpi.org/mailman/listinfo.cgi/svn-full

Reply via email to