diff --git a/config/f77_check.m4 b/config/f77_check.m4 index 22287713d4..569d06e151 100644 --- a/config/f77_check.m4 +++ b/config/f77_check.m4 @@ -36,7 +36,7 @@ AC_DEFUN([OMPI_F77_CHECK], [ ofc_have_type=0 ofc_type_size=$ac_cv_sizeof_int ofc_type_alignment=$ac_cv_sizeof_int - ofc_c_type=opal_fortran_bogus_type_t + ofc_c_type=ompi_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 @@ AC_DEFUN([OMPI_F77_CHECK], [ # 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([OPAL_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), + AC_DEFINE_UNQUOTED([OMPI_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([OPAL_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), + AC_DEFINE_UNQUOTED([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [$ofc_type_size], [Size of Fortran 77 $1]) - AC_DEFINE_UNQUOTED([OPAL_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), + AC_DEFINE_UNQUOTED([OMPI_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([opal_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t], + AC_DEFINE_UNQUOTED([ompi_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 - # 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] + # 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] # Clean up OMPI_VAR_SCOPE_POP diff --git a/config/f77_check_logical_array.m4 b/config/f77_check_logical_array.m4 index dd2fcd620a..7fadff7fc1 100644 --- a/config/f77_check_logical_array.m4 +++ b/config/f77_check_logical_array.m4 @@ -36,7 +36,7 @@ EOF # C module # We really need the confdefs.h Header file for - # the opal_fortran_logical_t definition + # the ompi_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 @@ EOF #ifdef __cplusplus extern "C" { #endif -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) +void $ompi_check_logical_fn(ompi_fortran_logical_t * logical) { int result = 0; FILE *f=fopen("conftestval", "w"); diff --git a/config/f77_check_real16_c_equiv.m4 b/config/f77_check_real16_c_equiv.m4 index b648d6a932..10fb9dabfc 100644 --- a/config/f77_check_real16_c_equiv.m4 +++ b/config/f77_check_real16_c_equiv.m4 @@ -29,13 +29,13 @@ AC_DEFUN([OMPI_F77_CHECK_REAL16_C_EQUIV],[ # 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 "$OPAL_HAVE_FORTRAN_REAL16" = "1"],[ + [AS_IF([test "$OMPI_WANT_F77_BINDINGS" = "1" -a "$OMPI_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 $OPAL_FORTRAN_REAL16_C_TYPE == REAL*16]) - OMPI_F77_CHECK_REAL16_EQUIV_TYPE([$OPAL_FORTRAN_REAL16_C_TYPE], [L]) + AC_MSG_CHECKING([if $OMPI_FORTRAN_REAL16_C_TYPE == REAL*16]) + OMPI_F77_CHECK_REAL16_EQUIV_TYPE([$OMPI_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 @@ AC_DEFUN([OMPI_F77_CHECK_REAL16_C_EQUIV],[ OMPI_UNIQ([CFLAGS]) OMPI_F77_CHECK_REAL16_EQUIV_TYPE([_Quad], [q]) AS_IF([test "$happy" = "yes"], - [OPAL_FORTRAN_REAL16_C_TYPE="_Quad" + [OMPI_FORTRAN_REAL16_C_TYPE="_Quad" AC_MSG_RESULT([works!])], [CFLAGS="$CFLAGS_save" AC_MSG_RESULT([does not work])]) @@ -67,14 +67,14 @@ AC_DEFUN([OMPI_F77_CHECK_REAL16_C_EQUIV],[ ]) ]) - opal_real16_matches_c=AS_VAR_GET([real16_matches_c_var]) + ompi_real16_matches_c=AS_VAR_GET([real16_matches_c_var]) AS_VAR_POPDEF([real16_matches_c_var]) - AS_IF([test "$opal_real16_matches_c" = "yes"], + AS_IF([test "$ompi_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([OPAL_REAL16_MATCHES_C], [$define_value], + AC_DEFINE_UNQUOTED([OMPI_REAL16_MATCHES_C], [$define_value], [Whether Fortran REAL*16 matches the bit format of the equivalent C type]) OMPI_VAR_SCOPE_POP ]) diff --git a/config/f77_get_fortran_handle_max.m4 b/config/f77_get_fortran_handle_max.m4 index 016d1dce1f..6a8b51ed21 100644 --- a/config/f77_get_fortran_handle_max.m4 +++ b/config/f77_get_fortran_handle_max.m4 @@ -33,7 +33,7 @@ AC_DEFUN([OMPI_F77_GET_FORTRAN_HANDLE_MAX],[ # 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 $OPAL_SIZEOF_FORTRAN_INTEGER \* 2 - 1` + ompi_numf=`expr $OMPI_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 @@ fclose(fp);]]), fi rm -f conftest.out > /dev/null 2>&1 ]) - AC_DEFINE_UNQUOTED([OPAL_FORTRAN_HANDLE_MAX], + AC_DEFINE_UNQUOTED([OMPI_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 diff --git a/config/f77_get_value_true.m4 b/config/f77_get_value_true.m4 index 4af422ca11..5582c43989 100644 --- a/config/f77_get_value_true.m4 +++ b/config/f77_get_value_true.m4 @@ -35,7 +35,7 @@ AC_DEFUN([OMPI_F77_GET_VALUE_TRUE],[ # # C module # We really need the confdefs.h Header file for - # the opal_fortran_logical_t definition + # the ompi_fortran_logical_t definition # if test \! -f confdefs.h ; then AC_MSG_WARN([*** Problem running configure test!]) @@ -53,19 +53,19 @@ AC_DEFUN([OMPI_F77_GET_VALUE_TRUE],[ extern "C" { #endif -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) +void $ompi_print_logical_fn(ompi_fortran_logical_t * logical) { FILE *f=fopen("conftestval", "w"); if (!f) exit(1); - if( SIZEOF_INT >= sizeof(opal_fortran_logical_t) ) { + if( SIZEOF_INT >= sizeof(ompi_fortran_logical_t) ) { fprintf(f, "%d\n", (int)*logical); - } else if (SIZEOF_LONG >= sizeof(opal_fortran_logical_t) ) { + } else if (SIZEOF_LONG >= sizeof(ompi_fortran_logical_t) ) { fprintf(f, "%ld\n", (long) *logical); #ifdef HAVE_LONG_LONG - } else if (SIZEOF_LONG_LONG >= sizeof(opal_fortran_logical_t) ) { + } else if (SIZEOF_LONG_LONG >= sizeof(ompi_fortran_logical_t) ) { fprintf(f, "%lld\n", (long long) *logical); #endif } else { @@ -105,7 +105,7 @@ EOF [AC_MSG_ERROR([Could not determine value of Fotran .TRUE.. Aborting.])])]) fi]) - AC_DEFINE_UNQUOTED([OPAL_FORTRAN_VALUE_TRUE], + AC_DEFINE_UNQUOTED([OMPI_FORTRAN_VALUE_TRUE], [$ompi_cv_f77_true_value], [Fortran value for LOGICAL .TRUE. value]) diff --git a/config/f77_purge_unsupported_kind.m4 b/config/f77_purge_unsupported_kind.m4 index 77bf98dc98..816dc8654b 100644 --- a/config/f77_purge_unsupported_kind.m4 +++ b/config/f77_purge_unsupported_kind.m4 @@ -24,10 +24,10 @@ AC_MSG_CHECKING([whether Fortran $1 has expected size]) val=`echo $1 | cut -f2 -d'*'` type=`echo $1 | cut -f1 -d'*'` - 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" + 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" AC_MSG_RESULT([no]) else AC_MSG_RESULT([yes]) diff --git a/config/f90_check.m4 b/config/f90_check.m4 index d0534e2a1d..d377052e99 100644 --- a/config/f90_check.m4 +++ b/config/f90_check.m4 @@ -106,14 +106,14 @@ AC_DEFUN([OMPI_F90_CHECK], [ else # If this type has an F77 counterpart, see if it's # supported. - [ofc_f77_have_type=$OPAL_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]) + [ofc_f77_have_type=$OMPI_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=$OPAL_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]) + [ofc_f77_sizeof=$OMPI_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_DEFUN([OMPI_F90_CHECK], [ # AC_DEFINE_UNQUOTED), autoheader won't put them in the # AC_CONFIG_HEADER (or AM_CONFIG_HEADER, in our case). - AC_DEFINE_UNQUOTED([OPAL_HAVE_F90_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]), + AC_DEFINE_UNQUOTED([OMPI_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. - [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])) + [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])) # Clean up unset ofc_fortran_type ofc_expected_size ofc_want_range ofc_pretty_name diff --git a/configure.ac b/configure.ac index 6f35c4cd02..815f35406b 100644 --- a/configure.ac +++ b/configure.ac @@ -271,18 +271,18 @@ fi OMPI_C_GET_ALIGNMENT(char, OPAL_ALIGNMENT_CHAR) OMPI_C_GET_ALIGNMENT(short, OPAL_ALIGNMENT_SHORT) -OMPI_C_GET_ALIGNMENT(wchar_t, OPAL_ALIGNMENT_WCHAR) +OMPI_C_GET_ALIGNMENT(wchar_t, OMPI_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, OPAL_ALIGNMENT_FLOAT) -OMPI_C_GET_ALIGNMENT(double, OPAL_ALIGNMENT_DOUBLE) +OMPI_C_GET_ALIGNMENT(float, OMPI_ALIGNMENT_FLOAT) +OMPI_C_GET_ALIGNMENT(double, OMPI_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 *, OPAL_ALIGNMENT_VOID_P) +OMPI_C_GET_ALIGNMENT(void *, OMPI_ALIGNMENT_VOID_P) # # Does the C compiler native support "bool"? (i.e., without @@ -403,7 +403,7 @@ AC_CHECK_SIZEOF(bool) # check for type alignments -OMPI_C_GET_ALIGNMENT(bool, OPAL_ALIGNMENT_CXX_BOOL) +OMPI_C_GET_ALIGNMENT(bool, OMPI_ALIGNMENT_CXX_BOOL) AC_LANG_POP(C++) # check if we want C++ support @@ -445,7 +445,7 @@ OMPI_SETUP_F77 # This allows us to mark bogus types, but still have them be a valid # [sentinel] value -AC_DEFINE([opal_fortran_bogus_type_t], [int], +AC_DEFINE([ompi_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 @@ AC_SUBST(OMPI_F90_CKINDS) # 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 "$OPAL_SIZEOF_FORTRAN_INTEGER" = "2"; then +if test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "2"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 4, OMPI_MPI_INTEGER_KIND) -elif test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "4"; then +elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "4"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 9, OMPI_MPI_INTEGER_KIND) -elif test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "8"; then +elif test "$OMPI_SIZEOF_FORTRAN_INTEGER" = "8"; then OMPI_F90_GET_INT_KIND(MPI_INTEGER_KIND, 18, OMPI_MPI_INTEGER_KIND) -elif test "$OPAL_SIZEOF_FORTRAN_INTEGER" = "16"; then +elif test "$OMPI_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 diff --git a/contrib/platform/win32/CMakeModules/f77_check.cmake b/contrib/platform/win32/CMakeModules/f77_check.cmake index 10231c2198..4ee0788689 100644 --- a/contrib/platform/win32/CMakeModules/f77_check.cmake +++ b/contrib/platform/win32/CMakeModules/f77_check.cmake @@ -28,13 +28,13 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE) SET(NEED_RECHECK TRUE) # do we need to check all the features? - IF(DEFINED OPAL_HAVE_FORTRAN_${TYPE_NAME}) + IF(DEFINED OMPI_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 OPAL_HAVE_FORTRAN_${TYPE_NAME}) + ENDIF(DEFINED OMPI_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 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE) SET(ofc_have_type 0) SET(ofc_type_size ${SIZEOF_INT}) SET(ofc_type_alignment ${SIZEOF_INT}) - SET(ofc_c_type ${opal_fortran_bogus_type_t}) + SET(ofc_c_type ${ompi_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 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE) # 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(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}") + 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}") IF(NOT "${TYPE_LIST}" STREQUAL "") STRING(TOLOWER ${TYPE_NAME} TYPE_NAME_L) - SET(opal_fortran_${TYPE_NAME_L}_t ${ofc_c_type} CACHE INTERNAL "opal_fortran_${TYPE_NAME_L}_t") + SET(ompi_fortran_${TYPE_NAME_L}_t ${ofc_c_type} CACHE INTERNAL "ompi_fortran_${TYPE_NAME_L}_t") ENDIF(NOT "${TYPE_LIST}" STREQUAL "") - #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}") + #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}") ENDIF(NEED_RECHECK) -ENDMACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE) +ENDMACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE) \ No newline at end of file diff --git a/contrib/platform/win32/CMakeModules/f77_check_real16_c_equiv.cmake b/contrib/platform/win32/CMakeModules/f77_check_real16_c_equiv.cmake index 4e65cf42f5..2016d2cf1e 100644 --- a/contrib/platform/win32/CMakeModules/f77_check_real16_c_equiv.cmake +++ b/contrib/platform/win32/CMakeModules/f77_check_real16_c_equiv.cmake @@ -12,11 +12,11 @@ # OMPI_F77_CHECK_REAL16_C_EQUIV # ---------------------------------------------------- MACRO(OMPI_F77_CHECK_REAL16_C_EQUIV) - SET(OPAL_REAL16_MATCHES_C 0) - #MESSAGE(STATUS "OPAL_HAVE_FORTRAN_REAL16:${OPAL_HAVE_FORTRAN_REAL16}") + SET(OMPI_REAL16_MATCHES_C 0) + #MESSAGE(STATUS "OMPI_HAVE_FORTRAN_REAL16:${OMPI_HAVE_FORTRAN_REAL16}") IF(OMPI_WANT_F77_BINDINGS) - IF(OPAL_HAVE_FORTRAN_REAL16) + IF(OMPI_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 " @@ -67,15 +67,15 @@ MACRO(OMPI_F77_CHECK_REAL16_C_EQUIV) # 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(OPAL_REAL16_MATCHES_C 1) + SET(OMPI_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(OPAL_HAVE_FORTRAN_REAL16) + ELSE(OMPI_HAVE_FORTRAN_REAL16) MESSAGE(STATUS "Check if REAL*16 bit-matches C...skipped") - ENDIF(OPAL_HAVE_FORTRAN_REAL16) + ENDIF(OMPI_HAVE_FORTRAN_REAL16) ENDIF(OMPI_WANT_F77_BINDINGS) ENDMACRO(OMPI_F77_CHECK_REAL16_C_EQUIV) \ No newline at end of file diff --git a/contrib/platform/win32/CMakeModules/ompi_configure.cmake b/contrib/platform/win32/CMakeModules/ompi_configure.cmake index 4ed833683f..f690c9f45e 100644 --- a/contrib/platform/win32/CMakeModules/ompi_configure.cmake +++ b/contrib/platform/win32/CMakeModules/ompi_configure.cmake @@ -1115,7 +1115,7 @@ INCLUDE(f77_check) # This allows us to mark bogus types, but still have them be a valid # [sentinel] value -SET(opal_fortran_bogus_type_t "int") +SET(ompi_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 @@ ENDIF(WANT_MPI_PROFILINGAND AND OMPI_WANT_F77_BINDINGS) #/* Max handle value for fortran MPI handles, effectively min(INT_MAX, max # fortran INTEGER value) */ -#/* #undef OPAL_FORTRAN_HANDLE_MAX */ +#/* #undef OMPI_FORTRAN_HANDLE_MAX */ # Need to be fixed. IF(WIN32) - SET (OPAL_FORTRAN_HANDLE_MAX "2147483647") + SET (OMPI_FORTRAN_HANDLE_MAX "2147483647") ENDIF(WIN32) # #/* Fortran value for LOGICAL .TRUE. value */ -#/* #undef OPAL_FORTRAN_VALUE_TRUE */ +#/* #undef OMPI_FORTRAN_VALUE_TRUE */ # Need to be fixed. IF(WIN32) - SET (OPAL_FORTRAN_VALUE_TRUE 0) + SET (OMPI_FORTRAN_VALUE_TRUE 0) ENDIF(WIN32) @@ -1227,58 +1227,58 @@ ENDIF(WIN32) #/* #undef OMPI_F90 */ #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_COMPLEX */ +#/* #undef OMPI_HAVE_F90_COMPLEX */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_COMPLEX16 */ +#/* #undef OMPI_HAVE_F90_COMPLEX16 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_COMPLEX32 */ +#/* #undef OMPI_HAVE_F90_COMPLEX32 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_COMPLEX8 */ +#/* #undef OMPI_HAVE_F90_COMPLEX8 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_DOUBLE_COMPLEX */ +#/* #undef OMPI_HAVE_F90_DOUBLE_COMPLEX */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_DOUBLE_PRECISION */ +#/* #undef OMPI_HAVE_F90_DOUBLE_PRECISION */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_INTEGER */ +#/* #undef OMPI_HAVE_F90_INTEGER */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_INTEGER1 */ +#/* #undef OMPI_HAVE_F90_INTEGER1 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_INTEGER16 */ +#/* #undef OMPI_HAVE_F90_INTEGER16 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_INTEGER2 */ +#/* #undef OMPI_HAVE_F90_INTEGER2 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_INTEGER4 */ +#/* #undef OMPI_HAVE_F90_INTEGER4 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_INTEGER8 */ +#/* #undef OMPI_HAVE_F90_INTEGER8 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_LOGICAL */ +#/* #undef OMPI_HAVE_F90_LOGICAL */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_REAL */ +#/* #undef OMPI_HAVE_F90_REAL */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_REAL16 */ +#/* #undef OMPI_HAVE_F90_REAL16 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_REAL2 */ +#/* #undef OMPI_HAVE_F90_REAL2 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_REAL4 */ +#/* #undef OMPI_HAVE_F90_REAL4 */ # #/* Whether we have Fortran 90 $ofc_fortran_type or not */ -#/* #undef OPAL_HAVE_F90_REAL8 */ +#/* #undef OMPI_HAVE_F90_REAL8 */ # ########################################################################################### @@ -1729,127 +1729,127 @@ SET (PACKAGE_VERSION ${VERSION_STRING}) # #/* A bogus type that allows us to have sentinel type values that are still # valid */ -#/* #undef opal_fortran_bogus_type_t */ +#/* #undef ompi_fortran_bogus_type_t */ #IF(WIN32) -# SET(opal_fortran_bogus_type_t 1) -# SET(opal_fortran_bogus_type_t_STRING "int") +# SET(ompi_fortran_bogus_type_t 1) +# SET(ompi_fortran_bogus_type_t_STRING "int") #ENDIF(WIN32) # #/* C type corresponding to Fortran 77 COMPLEX*16 */ -#/* #undef opal_fortran_complex16_t */ +#/* #undef ompi_fortran_complex16_t */ #IF(WIN32) -# SET(opal_fortran_complex16_t 1) -# SET(opal_fortran_complex16_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_complex16_t 1) +# SET(ompi_fortran_complex16_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 COMPLEX*32 */ -##/* #undef opal_fortran_complex32_t */ +##/* #undef ompi_fortran_complex32_t */ #IF(WIN32) -# SET(opal_fortran_complex32_t 1) -# SET(opal_fortran_complex32_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_complex32_t 1) +# SET(ompi_fortran_complex32_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 COMPLEX*8 */ -##/* #undef opal_fortran_complex8_t */ +##/* #undef ompi_fortran_complex8_t */ #IF(WIN32) -# SET(opal_fortran_complex8_t 1) -# SET(opal_fortran_complex8_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_complex8_t 1) +# SET(ompi_fortran_complex8_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 COMPLEX */ -##/* #undef opal_fortran_complex_t */ +##/* #undef ompi_fortran_complex_t */ #IF(WIN32) -# SET(opal_fortran_complex_t 1) -# SET(opal_fortran_complex_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_complex_t 1) +# SET(ompi_fortran_complex_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 DOUBLE PRECISION */ -##/* #undef opal_fortran_double_precision_t */ +##/* #undef ompi_fortran_double_precision_t */ #IF(WIN32) -# SET(opal_fortran_double_precision_t 1) -# SET(opal_fortran_double_precision_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_double_precision_t 1) +# SET(ompi_fortran_double_precision_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 INTEGER*16 */ -##/* #undef opal_fortran_integer16_t */ +##/* #undef ompi_fortran_integer16_t */ #IF(WIN32) -# SET(opal_fortran_integer16_t 1) -# SET(opal_fortran_integer16_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_integer16_t 1) +# SET(ompi_fortran_integer16_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 INTEGER*1 */ -##/* #undef opal_fortran_integer1_t */ +##/* #undef ompi_fortran_integer1_t */ #IF(WIN32) -# SET(opal_fortran_integer1_t 1) -# SET(opal_fortran_integer1_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_integer1_t 1) +# SET(ompi_fortran_integer1_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 INTEGER*2 */ -##/* #undef opal_fortran_integer2_t */ +##/* #undef ompi_fortran_integer2_t */ #IF(WIN32) -# SET(opal_fortran_integer2_t 1) -# SET(opal_fortran_integer2_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_integer2_t 1) +# SET(ompi_fortran_integer2_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 INTEGER*4 */ -##/* #undef opal_fortran_integer4_t */ +##/* #undef ompi_fortran_integer4_t */ #IF(WIN32) -# SET(opal_fortran_integer4_t 1) -# SET(opal_fortran_integer4_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_integer4_t 1) +# SET(ompi_fortran_integer4_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 INTEGER*8 */ -##/* #undef opal_fortran_integer8_t */ +##/* #undef ompi_fortran_integer8_t */ #IF(WIN32) -# SET(opal_fortran_integer8_t 1) -# SET(opal_fortran_integer8_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_integer8_t 1) +# SET(ompi_fortran_integer8_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 INTEGER */ -##/* #undef opal_fortran_integer_t */ +##/* #undef ompi_fortran_integer_t */ #IF(WIN32) -# SET(opal_fortran_integer_t 1) -# SET(opal_fortran_integer_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_integer_t 1) +# SET(ompi_fortran_integer_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 LOGICAL */ -##/* #undef opal_fortran_logical_t */ +##/* #undef ompi_fortran_logical_t */ #IF(WIN32) -# SET(opal_fortran_logical_t 1) -# SET(opal_fortran_logical_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_logical_t 1) +# SET(ompi_fortran_logical_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 REAL*16 */ -##/* #undef opal_fortran_real16_t */ +##/* #undef ompi_fortran_real16_t */ #IF(WIN32) -# SET(opal_fortran_real16_t 1) -# SET(opal_fortran_real16_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_real16_t 1) +# SET(ompi_fortran_real16_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 REAL*2 */ -##/* #undef opal_fortran_real2_t */ +##/* #undef ompi_fortran_real2_t */ #IF(WIN32) -# SET(opal_fortran_real2_t 1) -# SET(opal_fortran_real2_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_real2_t 1) +# SET(ompi_fortran_real2_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 REAL*4 */ -##/* #undef opal_fortran_real4_t */ +##/* #undef ompi_fortran_real4_t */ #IF(WIN32) -# SET(opal_fortran_real4_t 1) -# SET(opal_fortran_real4_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_real4_t 1) +# SET(ompi_fortran_real4_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 REAL*8 */ -##/* #undef opal_fortran_real8_t */ +##/* #undef ompi_fortran_real8_t */ #IF(WIN32) -# SET(opal_fortran_real8_t 1) -# SET(opal_fortran_real8_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_real8_t 1) +# SET(ompi_fortran_real8_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) ## ##/* C type corresponding to Fortran 77 REAL */ -##/* #undef opal_fortran_real_t */ +##/* #undef ompi_fortran_real_t */ #IF(WIN32) -# SET(opal_fortran_real_t 1) -# SET(opal_fortran_real_t_STRING "opal_fortran_bogus_type_t") +# SET(ompi_fortran_real_t 1) +# SET(ompi_fortran_real_t_STRING "ompi_fortran_bogus_type_t") #ENDIF(WIN32) diff --git a/contrib/platform/win32/ConfigFiles/mpi.h.cmake b/contrib/platform/win32/ConfigFiles/mpi.h.cmake index 5245e83248..905065f003 100644 --- a/contrib/platform/win32/ConfigFiles/mpi.h.cmake +++ b/contrib/platform/win32/ConfigFiles/mpi.h.cmake @@ -65,43 +65,43 @@ #cmakedefine OPAL_SIZEOF_INT ${SIZEOF_INT} /* Whether we have FORTRAN LOGICAL*1 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL1 ${OPAL_HAVE_FORTRAN_LOGICAL1} +#define OMPI_HAVE_FORTRAN_LOGICAL1 ${OMPI_HAVE_FORTRAN_LOGICAL1} /* Whether we have FORTRAN LOGICAL*2 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL2 ${OPAL_HAVE_FORTRAN_LOGICAL2} +#define OMPI_HAVE_FORTRAN_LOGICAL2 ${OMPI_HAVE_FORTRAN_LOGICAL2} /* Whether we have FORTRAN LOGICAL*4 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL4 ${OPAL_HAVE_FORTRAN_LOGICAL4} +#define OMPI_HAVE_FORTRAN_LOGICAL4 ${OMPI_HAVE_FORTRAN_LOGICAL4} /* Whether we have FORTRAN LOGICAL*8 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL8 ${OPAL_HAVE_FORTRAN_LOGICAL8} +#define OMPI_HAVE_FORTRAN_LOGICAL8 ${OMPI_HAVE_FORTRAN_LOGICAL8} /* Whether we have FORTRAN INTEGER*1 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER1 ${OPAL_HAVE_FORTRAN_INTEGER1} +#define OMPI_HAVE_FORTRAN_INTEGER1 ${OMPI_HAVE_FORTRAN_INTEGER1} /* Whether we have FORTRAN INTEGER*16 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER16 ${OPAL_HAVE_FORTRAN_INTEGER16} +#define OMPI_HAVE_FORTRAN_INTEGER16 ${OMPI_HAVE_FORTRAN_INTEGER16} /* Whether we have FORTRAN INTEGER*2 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER2 ${OPAL_HAVE_FORTRAN_INTEGER2} +#define OMPI_HAVE_FORTRAN_INTEGER2 ${OMPI_HAVE_FORTRAN_INTEGER2} /* Whether we have FORTRAN INTEGER*4 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER4 ${OPAL_HAVE_FORTRAN_INTEGER4} +#define OMPI_HAVE_FORTRAN_INTEGER4 ${OMPI_HAVE_FORTRAN_INTEGER4} /* Whether we have FORTRAN INTEGER*8 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER8 ${OPAL_HAVE_FORTRAN_INTEGER8} +#define OMPI_HAVE_FORTRAN_INTEGER8 ${OMPI_HAVE_FORTRAN_INTEGER8} /* Whether we have FORTRAN REAL*16 or not */ -#define OPAL_HAVE_FORTRAN_REAL16 ${OPAL_HAVE_FORTRAN_REAL16} +#define OMPI_HAVE_FORTRAN_REAL16 ${OMPI_HAVE_FORTRAN_REAL16} /* Whether we have FORTRAN REAL*2 or not */ -#define OPAL_HAVE_FORTRAN_REAL2 ${OPAL_HAVE_FORTRAN_REAL2} +#define OMPI_HAVE_FORTRAN_REAL2 ${OMPI_HAVE_FORTRAN_REAL2} /* Whether we have FORTRAN REAL*4 or not */ -#define OPAL_HAVE_FORTRAN_REAL4 ${OPAL_HAVE_FORTRAN_REAL4} +#define OMPI_HAVE_FORTRAN_REAL4 ${OMPI_HAVE_FORTRAN_REAL4} /* Whether we have FORTRAN REAL*8 or not */ -#define OPAL_HAVE_FORTRAN_REAL8 ${OPAL_HAVE_FORTRAN_REAL8} +#define OMPI_HAVE_FORTRAN_REAL8 ${OMPI_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 opal_fortran_bogus_type_t ${opal_fortran_bogus_type_t} +#cmakedefine ompi_fortran_bogus_type_t ${ompi_fortran_bogus_type_t} /* C type corresponding to FORTRAN INTEGER */ -#cmakedefine opal_fortran_integer_t ${opal_fortran_integer_t} +#cmakedefine ompi_fortran_integer_t ${ompi_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 opal_fortran_integer_t */ -#define MPI_Fint opal_fortran_integer_t +/* MPI_Fint is the same as ompi_fortran_INTEGER_t */ +#define MPI_Fint ompi_fortran_integer_t #endif #endif /* #ifndef OMPI_CONFIG_H */ @@ -747,52 +747,52 @@ OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_cxx_ldblcplex; 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 OPAL_HAVE_FORTRAN_LOGICAL1 +#if OMPI_HAVE_FORTRAN_LOGICAL1 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical1; #endif -#if OPAL_HAVE_FORTRAN_LOGICAL2 +#if OMPI_HAVE_FORTRAN_LOGICAL2 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical2; #endif -#if OPAL_HAVE_FORTRAN_LOGICAL4 +#if OMPI_HAVE_FORTRAN_LOGICAL4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical4; #endif -#if OPAL_HAVE_FORTRAN_LOGICAL8 +#if OMPI_HAVE_FORTRAN_LOGICAL8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical8; #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_HAVE_FORTRAN_INTEGER1 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer1; #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_HAVE_FORTRAN_INTEGER2 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer2; #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_HAVE_FORTRAN_INTEGER4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer4; #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_HAVE_FORTRAN_INTEGER8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer8; #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_HAVE_FORTRAN_INTEGER16 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer16; #endif -#if OPAL_HAVE_FORTRAN_REAL2 +#if OMPI_HAVE_FORTRAN_REAL2 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real2; #endif -#if OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real4; #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real8; #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_HAVE_FORTRAN_REAL16 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real16; #endif -#if OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_complex8; #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_complex16; #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_HAVE_FORTRAN_REAL16 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_complex32; #endif @@ -866,53 +866,53 @@ OMPI_DECLSPEC extern MPI_Fint *MPI_F_STATUSES_IGNORE; /* 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 OPAL_HAVE_FORTRAN_LOGICAL1 +#if OMPI_HAVE_FORTRAN_LOGICAL1 #define MPI_LOGICAL1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_logical1) #endif -#if OPAL_HAVE_FORTRAN_LOGICAL2 +#if OMPI_HAVE_FORTRAN_LOGICAL2 #define MPI_LOGICAL2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_logical2) #endif -#if OPAL_HAVE_FORTRAN_LOGICAL4 +#if OMPI_HAVE_FORTRAN_LOGICAL4 #define MPI_LOGICAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_logical4) #endif -#if OPAL_HAVE_FORTRAN_LOGICAL8 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_HAVE_FORTRAN_INTEGER1 #define MPI_INTEGER1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer1) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_HAVE_FORTRAN_INTEGER2 #define MPI_INTEGER2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer2) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_HAVE_FORTRAN_INTEGER4 #define MPI_INTEGER4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer4) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_HAVE_FORTRAN_INTEGER8 #define MPI_INTEGER8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer8) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 #define MPI_REAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_real4) #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 #define MPI_REAL8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_real8) #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 #define MPI_COMPLEX8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_complex8) #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 #define MPI_COMPLEX16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_complex16) #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_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) diff --git a/contrib/platform/win32/ConfigFiles/opal_config.h.cmake b/contrib/platform/win32/ConfigFiles/opal_config.h.cmake index 71c69a1b44..57b865ab9b 100644 --- a/contrib/platform/win32/ConfigFiles/opal_config.h.cmake +++ b/contrib/platform/win32/ConfigFiles/opal_config.h.cmake @@ -637,76 +637,76 @@ #define OPAL_ALIGNMENT_CHAR ${CHAR_ALIGNMENT} /* Alignment of type bool */ -#define OPAL_ALIGNMENT_CXX_BOOL ${BOOL_ALIGNMENT} +#define OMPI_ALIGNMENT_CXX_BOOL ${BOOL_ALIGNMENT} /* Alignment of type double */ -#define OPAL_ALIGNMENT_DOUBLE ${DOUBLE_ALIGNMENT} +#define OMPI_ALIGNMENT_DOUBLE ${DOUBLE_ALIGNMENT} /* Alignment of type float */ -#define OPAL_ALIGNMENT_FLOAT ${FLOAT_ALIGNMENT} +#define OMPI_ALIGNMENT_FLOAT ${FLOAT_ALIGNMENT} /* Alignment of Fortran 77 COMPLEX */ -#define OPAL_ALIGNMENT_FORTRAN_COMPLEX ${OPAL_ALIGNMENT_FORTRAN_COMPLEX} +#define OMPI_ALIGNMENT_FORTRAN_COMPLEX ${OMPI_ALIGNMENT_FORTRAN_COMPLEX} /* Alignment of Fortran 77 COMPLEX*16 */ -#define OPAL_ALIGNMENT_FORTRAN_COMPLEX16 ${OPAL_ALIGNMENT_FORTRAN_COMPLEX16} +#define OMPI_ALIGNMENT_FORTRAN_COMPLEX16 ${OMPI_ALIGNMENT_FORTRAN_COMPLEX16} /* Alignment of Fortran 77 COMPLEX*32 */ -#define OPAL_ALIGNMENT_FORTRAN_COMPLEX32 ${OPAL_ALIGNMENT_FORTRAN_COMPLEX32} +#define OMPI_ALIGNMENT_FORTRAN_COMPLEX32 ${OMPI_ALIGNMENT_FORTRAN_COMPLEX32} /* Alignment of Fortran 77 COMPLEX*8 */ -#define OPAL_ALIGNMENT_FORTRAN_COMPLEX8 ${OPAL_ALIGNMENT_FORTRAN_COMPLEX8} +#define OMPI_ALIGNMENT_FORTRAN_COMPLEX8 ${OMPI_ALIGNMENT_FORTRAN_COMPLEX8} /* Alignment of Fortran 77 DOUBLE PRECISION */ -#define OPAL_ALIGNMENT_FORTRAN_DOUBLE_PRECISION ${OPAL_ALIGNMENT_FORTRAN_DOUBLE_PRECISION} +#define OMPI_ALIGNMENT_FORTRAN_DOUBLE_PRECISION ${OMPI_ALIGNMENT_FORTRAN_DOUBLE_PRECISION} /* Alignment of Fortran 77 INTEGER */ -#define OPAL_ALIGNMENT_FORTRAN_INTEGER ${OPAL_ALIGNMENT_FORTRAN_INTEGER} +#define OMPI_ALIGNMENT_FORTRAN_INTEGER ${OMPI_ALIGNMENT_FORTRAN_INTEGER} /* Alignment of Fortran 77 INTEGER*1 */ -#define OPAL_ALIGNMENT_FORTRAN_INTEGER1 ${OPAL_ALIGNMENT_FORTRAN_INTEGER1} +#define OMPI_ALIGNMENT_FORTRAN_INTEGER1 ${OMPI_ALIGNMENT_FORTRAN_INTEGER1} /* Alignment of Fortran 77 INTEGER*16 */ -#define OPAL_ALIGNMENT_FORTRAN_INTEGER16 ${OPAL_ALIGNMENT_FORTRAN_INTEGER16} +#define OMPI_ALIGNMENT_FORTRAN_INTEGER16 ${OMPI_ALIGNMENT_FORTRAN_INTEGER16} /* Alignment of Fortran 77 INTEGER*2 */ -#define OPAL_ALIGNMENT_FORTRAN_INTEGER2 ${OPAL_ALIGNMENT_FORTRAN_INTEGER2} +#define OMPI_ALIGNMENT_FORTRAN_INTEGER2 ${OMPI_ALIGNMENT_FORTRAN_INTEGER2} /* Alignment of Fortran 77 INTEGER*4 */ -#define OPAL_ALIGNMENT_FORTRAN_INTEGER4 ${OPAL_ALIGNMENT_FORTRAN_INTEGER4} +#define OMPI_ALIGNMENT_FORTRAN_INTEGER4 ${OMPI_ALIGNMENT_FORTRAN_INTEGER4} /* Alignment of Fortran 77 INTEGER*8 */ -#define OPAL_ALIGNMENT_FORTRAN_INTEGER8 ${OPAL_ALIGNMENT_FORTRAN_INTEGER8} +#define OMPI_ALIGNMENT_FORTRAN_INTEGER8 ${OMPI_ALIGNMENT_FORTRAN_INTEGER8} /* Alignment of Fortran 77 LOGICAL */ -#define OPAL_ALIGNMENT_FORTRAN_LOGICAL ${OPAL_ALIGNMENT_FORTRAN_LOGICAL} +#define OMPI_ALIGNMENT_FORTRAN_LOGICAL ${OMPI_ALIGNMENT_FORTRAN_LOGICAL} /* Alignment of Fortran 77 LOGICAL*1 */ -#define OPAL_ALIGNMENT_FORTRAN_LOGICAL1 ${OPAL_ALIGNMENT_FORTRAN_LOGICAL1} +#define OMPI_ALIGNMENT_FORTRAN_LOGICAL1 ${OMPI_ALIGNMENT_FORTRAN_LOGICAL1} /* Alignment of Fortran 77 LOGICAL*2 */ -#define OPAL_ALIGNMENT_FORTRAN_LOGICAL2 ${OPAL_ALIGNMENT_FORTRAN_LOGICAL2} +#define OMPI_ALIGNMENT_FORTRAN_LOGICAL2 ${OMPI_ALIGNMENT_FORTRAN_LOGICAL2} /* Alignment of Fortran 77 LOGICAL*4 */ -#define OPAL_ALIGNMENT_FORTRAN_LOGICAL4 ${OPAL_ALIGNMENT_FORTRAN_LOGICAL4} +#define OMPI_ALIGNMENT_FORTRAN_LOGICAL4 ${OMPI_ALIGNMENT_FORTRAN_LOGICAL4} /* Alignment of Fortran 77 LOGICAL*8 */ -#define OPAL_ALIGNMENT_FORTRAN_LOGICAL8 ${OPAL_ALIGNMENT_FORTRAN_LOGICAL8} +#define OMPI_ALIGNMENT_FORTRAN_LOGICAL8 ${OMPI_ALIGNMENT_FORTRAN_LOGICAL8} /* Alignment of Fortran 77 REAL */ -#define OPAL_ALIGNMENT_FORTRAN_REAL ${OPAL_ALIGNMENT_FORTRAN_REAL} +#define OMPI_ALIGNMENT_FORTRAN_REAL ${OMPI_ALIGNMENT_FORTRAN_REAL} /* Alignment of Fortran 77 REAL*16 */ -#define OPAL_ALIGNMENT_FORTRAN_REAL16 ${OPAL_ALIGNMENT_FORTRAN_REAL16} +#define OMPI_ALIGNMENT_FORTRAN_REAL16 ${OMPI_ALIGNMENT_FORTRAN_REAL16} /* Alignment of Fortran 77 REAL*2 */ -#define OPAL_ALIGNMENT_FORTRAN_REAL2 ${OPAL_ALIGNMENT_FORTRAN_REAL2} +#define OMPI_ALIGNMENT_FORTRAN_REAL2 ${OMPI_ALIGNMENT_FORTRAN_REAL2} /* Alignment of Fortran 77 REAL*4 */ -#define OPAL_ALIGNMENT_FORTRAN_REAL4 ${OPAL_ALIGNMENT_FORTRAN_REAL4} +#define OMPI_ALIGNMENT_FORTRAN_REAL4 ${OMPI_ALIGNMENT_FORTRAN_REAL4} /* Alignment of Fortran 77 REAL*8 */ -#define OPAL_ALIGNMENT_FORTRAN_REAL8 ${OPAL_ALIGNMENT_FORTRAN_REAL8} +#define OMPI_ALIGNMENT_FORTRAN_REAL8 ${OMPI_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 OPAL_ALIGNMENT_VOID_P ${VOID_P_ALIGNMENT} +#define OMPI_ALIGNMENT_VOID_P ${VOID_P_ALIGNMENT} /* Alignment of type wchar_t */ -#define OPAL_ALIGNMENT_WCHAR ${WCHAR_T_ALIGNMENT} +#define OMPI_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 OPAL_FORTRAN_HANDLE_MAX ${OPAL_FORTRAN_HANDLE_MAX} +#cmakedefine OMPI_FORTRAN_HANDLE_MAX ${OMPI_FORTRAN_HANDLE_MAX} /* Fortran value for LOGICAL .TRUE. value */ -#define OPAL_FORTRAN_VALUE_TRUE ${OPAL_FORTRAN_VALUE_TRUE} +#define OMPI_FORTRAN_VALUE_TRUE ${OMPI_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 OPAL_HAVE_F90_COMPLEX +#cmakedefine OMPI_HAVE_F90_COMPLEX /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_COMPLEX16 +#cmakedefine OMPI_HAVE_F90_COMPLEX16 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_COMPLEX32 +#cmakedefine OMPI_HAVE_F90_COMPLEX32 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_COMPLEX8 +#cmakedefine OMPI_HAVE_F90_COMPLEX8 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_DOUBLE_COMPLEX +#cmakedefine OMPI_HAVE_F90_DOUBLE_COMPLEX /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_DOUBLE_PRECISION +#cmakedefine OMPI_HAVE_F90_DOUBLE_PRECISION /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_INTEGER +#cmakedefine OMPI_HAVE_F90_INTEGER /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_INTEGER1 +#cmakedefine OMPI_HAVE_F90_INTEGER1 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_INTEGER16 +#cmakedefine OMPI_HAVE_F90_INTEGER16 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_INTEGER2 +#cmakedefine OMPI_HAVE_F90_INTEGER2 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_INTEGER4 +#cmakedefine OMPI_HAVE_F90_INTEGER4 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_INTEGER8 +#cmakedefine OMPI_HAVE_F90_INTEGER8 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_LOGICAL +#cmakedefine OMPI_HAVE_F90_LOGICAL /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_REAL +#cmakedefine OMPI_HAVE_F90_REAL /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_REAL16 +#cmakedefine OMPI_HAVE_F90_REAL16 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_REAL2 +#cmakedefine OMPI_HAVE_F90_REAL2 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_REAL4 +#cmakedefine OMPI_HAVE_F90_REAL4 /* Whether we have Fortran 90 $ofc_fortran_type or not */ -#cmakedefine OPAL_HAVE_F90_REAL8 +#cmakedefine OMPI_HAVE_F90_REAL8 /* Whether we have Fortran 77 COMPLEX or not */ -#define OPAL_HAVE_FORTRAN_COMPLEX ${OPAL_HAVE_FORTRAN_COMPLEX} +#define OMPI_HAVE_FORTRAN_COMPLEX ${OMPI_HAVE_FORTRAN_COMPLEX} /* Whether we have Fortran 77 COMPLEX*16 or not */ -#define OPAL_HAVE_FORTRAN_COMPLEX16 ${OPAL_HAVE_FORTRAN_COMPLEX16} +#define OMPI_HAVE_FORTRAN_COMPLEX16 ${OMPI_HAVE_FORTRAN_COMPLEX16} /* Whether we have Fortran 77 COMPLEX*32 or not */ -#define OPAL_HAVE_FORTRAN_COMPLEX32 ${OPAL_HAVE_FORTRAN_COMPLEX32} +#define OMPI_HAVE_FORTRAN_COMPLEX32 ${OMPI_HAVE_FORTRAN_COMPLEX32} /* Whether we have Fortran 77 COMPLEX*8 or not */ -#define OPAL_HAVE_FORTRAN_COMPLEX8 ${OPAL_HAVE_FORTRAN_COMPLEX8} +#define OMPI_HAVE_FORTRAN_COMPLEX8 ${OMPI_HAVE_FORTRAN_COMPLEX8} /* Whether we have Fortran 77 DOUBLE PRECISION or not */ -#define OPAL_HAVE_FORTRAN_DOUBLE_PRECISION ${OPAL_HAVE_FORTRAN_DOUBLE_PRECISION} +#define OMPI_HAVE_FORTRAN_DOUBLE_PRECISION ${OMPI_HAVE_FORTRAN_DOUBLE_PRECISION} /* Whether we have Fortran 77 INTEGER or not */ -#define OPAL_HAVE_FORTRAN_INTEGER ${OPAL_HAVE_FORTRAN_INTEGER} +#define OMPI_HAVE_FORTRAN_INTEGER ${OMPI_HAVE_FORTRAN_INTEGER} /* Whether we have Fortran 77 INTEGER*1 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER1 ${OPAL_HAVE_FORTRAN_INTEGER1} +#define OMPI_HAVE_FORTRAN_INTEGER1 ${OMPI_HAVE_FORTRAN_INTEGER1} /* Whether we have Fortran 77 INTEGER*16 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER16 ${OPAL_HAVE_FORTRAN_INTEGER16} +#define OMPI_HAVE_FORTRAN_INTEGER16 ${OMPI_HAVE_FORTRAN_INTEGER16} /* Whether we have Fortran 77 INTEGER*2 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER2 ${OPAL_HAVE_FORTRAN_INTEGER2} +#define OMPI_HAVE_FORTRAN_INTEGER2 ${OMPI_HAVE_FORTRAN_INTEGER2} /* Whether we have Fortran 77 INTEGER*4 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER4 ${OPAL_HAVE_FORTRAN_INTEGER4} +#define OMPI_HAVE_FORTRAN_INTEGER4 ${OMPI_HAVE_FORTRAN_INTEGER4} /* Whether we have Fortran 77 INTEGER*8 or not */ -#define OPAL_HAVE_FORTRAN_INTEGER8 ${OPAL_HAVE_FORTRAN_INTEGER8} +#define OMPI_HAVE_FORTRAN_INTEGER8 ${OMPI_HAVE_FORTRAN_INTEGER8} /* Whether we have Fortran 77 LOGICAL or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL ${OPAL_HAVE_FORTRAN_LOGICAL} +#define OMPI_HAVE_FORTRAN_LOGICAL ${OMPI_HAVE_FORTRAN_LOGICAL} /* Whether we have Fortran 77 LOGICAL1 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL1 ${OPAL_HAVE_FORTRAN_LOGICAL1} +#define OMPI_HAVE_FORTRAN_LOGICAL1 ${OMPI_HAVE_FORTRAN_LOGICAL1} /* Whether we have Fortran 77 LOGICAL2 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL2 ${OPAL_HAVE_FORTRAN_LOGICAL2} +#define OMPI_HAVE_FORTRAN_LOGICAL2 ${OMPI_HAVE_FORTRAN_LOGICAL2} /* Whether we have Fortran 77 LOGICAL4 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL4 ${OPAL_HAVE_FORTRAN_LOGICAL4} +#define OMPI_HAVE_FORTRAN_LOGICAL4 ${OMPI_HAVE_FORTRAN_LOGICAL4} /* Whether we have Fortran 77 LOGICAL8 or not */ -#define OPAL_HAVE_FORTRAN_LOGICAL8 ${OPAL_HAVE_FORTRAN_LOGICAL8} +#define OMPI_HAVE_FORTRAN_LOGICAL8 ${OMPI_HAVE_FORTRAN_LOGICAL8} /* Whether we have Fortran 77 REAL or not */ -#define OPAL_HAVE_FORTRAN_REAL ${OPAL_HAVE_FORTRAN_REAL} +#define OMPI_HAVE_FORTRAN_REAL ${OMPI_HAVE_FORTRAN_REAL} /* Whether we have Fortran 77 REAL*16 or not */ -#define OPAL_HAVE_FORTRAN_REAL16 ${OPAL_HAVE_FORTRAN_REAL16} +#define OMPI_HAVE_FORTRAN_REAL16 ${OMPI_HAVE_FORTRAN_REAL16} /* Whether we have Fortran 77 REAL*2 or not */ -#define OPAL_HAVE_FORTRAN_REAL2 ${OPAL_HAVE_FORTRAN_REAL2} +#define OMPI_HAVE_FORTRAN_REAL2 ${OMPI_HAVE_FORTRAN_REAL2} /* Whether we have Fortran 77 REAL*4 or not */ -#define OPAL_HAVE_FORTRAN_REAL4 ${OPAL_HAVE_FORTRAN_REAL4} +#define OMPI_HAVE_FORTRAN_REAL4 ${OMPI_HAVE_FORTRAN_REAL4} /* Whether we have Fortran 77 REAL*8 or not */ -#define OPAL_HAVE_FORTRAN_REAL8 ${OPAL_HAVE_FORTRAN_REAL8} +#define OMPI_HAVE_FORTRAN_REAL8 ${OMPI_HAVE_FORTRAN_REAL8} -#define OPAL_REAL16_MATCHES_C ${OPAL_REAL16_MATCHES_C} +#define OMPI_REAL16_MATCHES_C ${OMPI_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 OPAL_SIZEOF_FORTRAN_COMPLEX ${OPAL_SIZEOF_FORTRAN_COMPLEX} +#define OMPI_SIZEOF_FORTRAN_COMPLEX ${OMPI_SIZEOF_FORTRAN_COMPLEX} /* Size of Fortran 77 COMPLEX*16 */ -#define OPAL_SIZEOF_FORTRAN_COMPLEX16 ${OPAL_SIZEOF_FORTRAN_COMPLEX16} +#define OMPI_SIZEOF_FORTRAN_COMPLEX16 ${OMPI_SIZEOF_FORTRAN_COMPLEX16} /* Size of Fortran 77 COMPLEX*32 */ -#define OPAL_SIZEOF_FORTRAN_COMPLEX32 ${OPAL_SIZEOF_FORTRAN_COMPLEX32} +#define OMPI_SIZEOF_FORTRAN_COMPLEX32 ${OMPI_SIZEOF_FORTRAN_COMPLEX32} /* Size of Fortran 77 COMPLEX*8 */ -#define OPAL_SIZEOF_FORTRAN_COMPLEX8 ${OPAL_SIZEOF_FORTRAN_COMPLEX8} +#define OMPI_SIZEOF_FORTRAN_COMPLEX8 ${OMPI_SIZEOF_FORTRAN_COMPLEX8} /* Size of Fortran 77 DOUBLE PRECISION */ -#define OPAL_SIZEOF_FORTRAN_DOUBLE_PRECISION ${OPAL_SIZEOF_FORTRAN_DOUBLE_PRECISION} +#define OMPI_SIZEOF_FORTRAN_DOUBLE_PRECISION ${OMPI_SIZEOF_FORTRAN_DOUBLE_PRECISION} /* Size of Fortran 77 INTEGER */ -#define OPAL_SIZEOF_FORTRAN_INTEGER ${OPAL_SIZEOF_FORTRAN_INTEGER} +#define OMPI_SIZEOF_FORTRAN_INTEGER ${OMPI_SIZEOF_FORTRAN_INTEGER} /* Size of Fortran 77 INTEGER*1 */ -#define OPAL_SIZEOF_FORTRAN_INTEGER1 ${OPAL_SIZEOF_FORTRAN_INTEGER1} +#define OMPI_SIZEOF_FORTRAN_INTEGER1 ${OMPI_SIZEOF_FORTRAN_INTEGER1} /* Size of Fortran 77 INTEGER*16 */ -#define OPAL_SIZEOF_FORTRAN_INTEGER16 ${OPAL_SIZEOF_FORTRAN_INTEGER16} +#define OMPI_SIZEOF_FORTRAN_INTEGER16 ${OMPI_SIZEOF_FORTRAN_INTEGER16} /* Size of Fortran 77 INTEGER*2 */ -#define OPAL_SIZEOF_FORTRAN_INTEGER2 ${OPAL_SIZEOF_FORTRAN_INTEGER2} +#define OMPI_SIZEOF_FORTRAN_INTEGER2 ${OMPI_SIZEOF_FORTRAN_INTEGER2} /* Size of Fortran 77 INTEGER*4 */ -#define OPAL_SIZEOF_FORTRAN_INTEGER4 ${OPAL_SIZEOF_FORTRAN_INTEGER4} +#define OMPI_SIZEOF_FORTRAN_INTEGER4 ${OMPI_SIZEOF_FORTRAN_INTEGER4} /* Size of Fortran 77 INTEGER*8 */ -#define OPAL_SIZEOF_FORTRAN_INTEGER8 ${OPAL_SIZEOF_FORTRAN_INTEGER8} +#define OMPI_SIZEOF_FORTRAN_INTEGER8 ${OMPI_SIZEOF_FORTRAN_INTEGER8} /* Size of Fortran 77 LOGICAL */ -#define OPAL_SIZEOF_FORTRAN_LOGICAL ${OPAL_SIZEOF_FORTRAN_LOGICAL} +#define OMPI_SIZEOF_FORTRAN_LOGICAL ${OMPI_SIZEOF_FORTRAN_LOGICAL} /* Size of Fortran 77 LOGICAL1 */ -#define OPAL_SIZEOF_FORTRAN_LOGICAL1 ${OPAL_SIZEOF_FORTRAN_LOGICAL1} +#define OMPI_SIZEOF_FORTRAN_LOGICAL1 ${OMPI_SIZEOF_FORTRAN_LOGICAL1} /* Size of Fortran 77 LOGICAL2 */ -#define OPAL_SIZEOF_FORTRAN_LOGICAL2 ${OPAL_SIZEOF_FORTRAN_LOGICAL2} +#define OMPI_SIZEOF_FORTRAN_LOGICAL2 ${OMPI_SIZEOF_FORTRAN_LOGICAL2} /* Size of Fortran 77 LOGICAL4 */ -#define OPAL_SIZEOF_FORTRAN_LOGICAL4 ${OPAL_SIZEOF_FORTRAN_LOGICAL4} +#define OMPI_SIZEOF_FORTRAN_LOGICAL4 ${OMPI_SIZEOF_FORTRAN_LOGICAL4} /* Size of Fortran 77 LOGICAL8 */ -#define OPAL_SIZEOF_FORTRAN_LOGICAL8 ${OPAL_SIZEOF_FORTRAN_LOGICAL8} +#define OMPI_SIZEOF_FORTRAN_LOGICAL8 ${OMPI_SIZEOF_FORTRAN_LOGICAL8} /* Size of Fortran 77 REAL */ -#define OPAL_SIZEOF_FORTRAN_REAL ${OPAL_SIZEOF_FORTRAN_REAL} +#define OMPI_SIZEOF_FORTRAN_REAL ${OMPI_SIZEOF_FORTRAN_REAL} /* Size of Fortran 77 REAL*16 */ -#define OPAL_SIZEOF_FORTRAN_REAL16 ${OPAL_SIZEOF_FORTRAN_REAL16} +#define OMPI_SIZEOF_FORTRAN_REAL16 ${OMPI_SIZEOF_FORTRAN_REAL16} /* Size of Fortran 77 REAL*2 */ -#define OPAL_SIZEOF_FORTRAN_REAL2 ${OPAL_SIZEOF_FORTRAN_REAL2} +#define OMPI_SIZEOF_FORTRAN_REAL2 ${OMPI_SIZEOF_FORTRAN_REAL2} /* Size of Fortran 77 REAL*4 */ -#define OPAL_SIZEOF_FORTRAN_REAL4 ${OPAL_SIZEOF_FORTRAN_REAL4} +#define OMPI_SIZEOF_FORTRAN_REAL4 ${OMPI_SIZEOF_FORTRAN_REAL4} /* Size of Fortran 77 REAL*8 */ -#define OPAL_SIZEOF_FORTRAN_REAL8 ${OPAL_SIZEOF_FORTRAN_REAL8} +#define OMPI_SIZEOF_FORTRAN_REAL8 ${OMPI_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 opal_fortran_bogus_type_t ${opal_fortran_bogus_type_t} +#cmakedefine ompi_fortran_bogus_type_t ${ompi_fortran_bogus_type_t} /* C type corresponding to Fortran 77 COMPLEX*16 */ -#cmakedefine opal_fortran_complex16_t ${opal_fortran_complex16_t} +#cmakedefine ompi_fortran_complex16_t ${ompi_fortran_complex16_t} /* C type corresponding to Fortran 77 COMPLEX*32 */ -#cmakedefine opal_fortran_complex32_t ${opal_fortran_complex32_t} +#cmakedefine ompi_fortran_complex32_t ${ompi_fortran_complex32_t} /* C type corresponding to Fortran 77 COMPLEX*8 */ -#cmakedefine opal_fortran_complex8_t ${opal_fortran_complex8_t} +#cmakedefine ompi_fortran_complex8_t ${ompi_fortran_complex8_t} /* C type corresponding to Fortran 77 COMPLEX */ -#cmakedefine opal_fortran_complex_t ${opal_fortran_complex_t} +#cmakedefine ompi_fortran_complex_t ${ompi_fortran_complex_t} /* C type corresponding to Fortran 77 DOUBLE PRECISION */ -#cmakedefine opal_fortran_double_precision_t ${opal_fortran_double_precision_t} +#cmakedefine ompi_fortran_double_precision_t ${ompi_fortran_double_precision_t} /* C type corresponding to Fortran 77 INTEGER*16 */ -#cmakedefine opal_fortran_integer16_t ${opal_fortran_integer16_t} +#cmakedefine ompi_fortran_integer16_t ${ompi_fortran_integer16_t} /* C type corresponding to Fortran 77 INTEGER*1 */ -#cmakedefine opal_fortran_integer1_t ${opal_fortran_integer1_t} +#cmakedefine ompi_fortran_integer1_t ${ompi_fortran_integer1_t} /* C type corresponding to Fortran 77 INTEGER*2 */ -#cmakedefine opal_fortran_integer2_t ${opal_fortran_integer2_t} +#cmakedefine ompi_fortran_integer2_t ${ompi_fortran_integer2_t} /* C type corresponding to Fortran 77 INTEGER*4 */ -#cmakedefine opal_fortran_integer4_t ${opal_fortran_integer4_t} +#cmakedefine ompi_fortran_integer4_t ${ompi_fortran_integer4_t} /* C type corresponding to Fortran 77 INTEGER*8 */ -#cmakedefine opal_fortran_integer8_t ${opal_fortran_integer8_t} +#cmakedefine ompi_fortran_integer8_t ${ompi_fortran_integer8_t} /* C type corresponding to Fortran 77 INTEGER */ -#cmakedefine opal_fortran_integer_t ${opal_fortran_integer_t} +#cmakedefine ompi_fortran_integer_t ${ompi_fortran_integer_t} /* C type corresponding to Fortran 77 LOGICAL */ -#cmakedefine opal_fortran_logical_t ${opal_fortran_logical_t} +#cmakedefine ompi_fortran_logical_t ${ompi_fortran_logical_t} /* C type corresponding to Fortran 77 LOGICAL*1 */ -#cmakedefine opal_fortran_logical1_t ${opal_fortran_logical1_t} +#cmakedefine ompi_fortran_logical1_t ${ompi_fortran_logical1_t} /* C type corresponding to Fortran 77 LOGICAL*2 */ -#cmakedefine opal_fortran_logical2_t ${opal_fortran_logical2_t} +#cmakedefine ompi_fortran_logical2_t ${ompi_fortran_logical2_t} /* C type corresponding to Fortran 77 LOGICAL*4 */ -#cmakedefine opal_fortran_logical4_t ${opal_fortran_logical4_t} +#cmakedefine ompi_fortran_logical4_t ${ompi_fortran_logical4_t} /* C type corresponding to Fortran 77 LOGICAL*8 */ -#cmakedefine opal_fortran_logical8_t ${opal_fortran_logical8_t} +#cmakedefine ompi_fortran_logical8_t ${ompi_fortran_logical8_t} /* C type corresponding to Fortran 77 REAL*16 */ -#cmakedefine opal_fortran_real16_t ${opal_fortran_real16_t} +#cmakedefine ompi_fortran_real16_t ${ompi_fortran_real16_t} /* C type corresponding to Fortran 77 REAL*2 */ -#cmakedefine opal_fortran_real2_t ${opal_fortran_real2_t} +#cmakedefine ompi_fortran_real2_t ${ompi_fortran_real2_t} /* C type corresponding to Fortran 77 REAL*4 */ -#cmakedefine opal_fortran_real4_t ${opal_fortran_real4_t} +#cmakedefine ompi_fortran_real4_t ${ompi_fortran_real4_t} /* C type corresponding to Fortran 77 REAL*8 */ -#cmakedefine opal_fortran_real8_t ${opal_fortran_real8_t} +#cmakedefine ompi_fortran_real8_t ${ompi_fortran_real8_t} /* C type corresponding to Fortran 77 REAL */ -#cmakedefine opal_fortran_real_t ${opal_fortran_real_t} +#cmakedefine ompi_fortran_real_t ${ompi_fortran_real_t} /* Define to `int' if does not define. */ #define pid_t ${PID_T} diff --git a/ompi/attribute/attribute.c b/ompi/attribute/attribute.c index c556122305..7463f0dc42 100644 --- a/ompi/attribute/attribute.c +++ b/ompi/attribute/attribute.c @@ -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; \ - opal_fortran_logical_t f_flag; \ + ompi_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 @@ int ompi_attr_init(void) } key_bitmap = OBJ_NEW(opal_bitmap_t); /* - * Set the max size to OPAL_FORTRAN_HANDLE_MAX to enforce bound + * Set the max size to OMPI_FORTRAN_HANDLE_MAX to enforce bound */ - opal_bitmap_set_max_size (key_bitmap, OPAL_FORTRAN_HANDLE_MAX); + opal_bitmap_set_max_size (key_bitmap, OMPI_FORTRAN_HANDLE_MAX); if (0 != opal_bitmap_init(key_bitmap, 32)) { return MPI_ERR_SYSRESOURCE; } diff --git a/ompi/attribute/attribute.h b/ompi/attribute/attribute.h index ef2081d1ae..3ded2fa307 100644 --- a/ompi/attribute/attribute.h +++ b/ompi/attribute/attribute.h @@ -67,7 +67,7 @@ typedef void (ompi_mpi1_fortran_copy_attr_function)(MPI_Fint *oldobj, MPI_Fint *extra_state, MPI_Fint *attr_in, MPI_Fint *attr_out, - MPI_Flogical *flag, + ompi_fortran_logical_t *flag, MPI_Fint *ierr); typedef void (ompi_mpi1_fortran_delete_attr_function)(MPI_Fint *obj, MPI_Fint *keyval, @@ -84,7 +84,7 @@ typedef void (ompi_mpi2_fortran_copy_attr_function)(MPI_Fint *oldobj, void *extra_state, void *attr_in, void *attr_out, - MPI_Flogical *flag, + ompi_fortran_logical_t *flag, MPI_Fint *ierr); typedef void (ompi_mpi2_fortran_delete_attr_function)(MPI_Fint *obj, MPI_Fint *keyval, diff --git a/ompi/communicator/comm_init.c b/ompi/communicator/comm_init.c index 53a590f8f5..db47cf4c63 100644 --- a/ompi/communicator/comm_init.c +++ b/ompi/communicator/comm_init.c @@ -70,7 +70,7 @@ int ompi_comm_init(void) /* Setup communicator array */ OBJ_CONSTRUCT(&ompi_mpi_communicators, opal_pointer_array_t); if( OPAL_SUCCESS != opal_pointer_array_init(&ompi_mpi_communicators, 0, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/datatype/copy_functions.c b/ompi/datatype/copy_functions.c index 28f43e51ea..67e9ced2c0 100644 --- a/ompi/datatype/copy_functions.c +++ b/ompi/datatype/copy_functions.c @@ -139,19 +139,19 @@ COPY_TYPE( 2double, double, 2 ) COPY_TYPE( 2complex_float, ompi_complex_float_t, 2 ) COPY_TYPE( 2complex_double, ompi_complex_double_t, 2 ) -#if OPAL_SIZEOF_FORTRAN_LOGICAL == 1 || SIZEOF_BOOL == 1 +#if OMPI_SIZEOF_FORTRAN_LOGICAL == 1 || SIZEOF_BOOL == 1 #define REQUIRE_COPY_BYTES_1 1 #else #define REQUIRE_COPY_BYTES_1 0 #endif -#if OPAL_SIZEOF_FORTRAN_LOGICAL == 2 || SIZEOF_BOOL == 2 +#if OMPI_SIZEOF_FORTRAN_LOGICAL == 2 || SIZEOF_BOOL == 2 #define REQUIRE_COPY_BYTES_2 1 #else #define REQUIRE_COPY_BYTES_2 0 #endif -#if OPAL_SIZEOF_FORTRAN_LOGICAL == 4 || SIZEOF_BOOL == 4 +#if OMPI_SIZEOF_FORTRAN_LOGICAL == 4 || SIZEOF_BOOL == 4 #define REQUIRE_COPY_BYTES_4 1 #else #define REQUIRE_COPY_BYTES_4 0 @@ -236,9 +236,9 @@ conversion_fct_t ompi_ddt_copy_functions[DT_MAX_PREDEFINED] = { #else #error Complete me please #endif -#if OPAL_SIZEOF_FORTRAN_LOGICAL == 1 +#if OMPI_SIZEOF_FORTRAN_LOGICAL == 1 (conversion_fct_t)copy_bytes_1, /* DT_LOGIC */ -#elif OPAL_SIZEOF_FORTRAN_LOGICAL == 4 +#elif OMPI_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 */ diff --git a/ompi/datatype/copy_functions_heterogeneous.c b/ompi/datatype/copy_functions_heterogeneous.c index f3bf8bb715..b1885ee514 100644 --- a/ompi/datatype/copy_functions_heterogeneous.c +++ b/ompi/datatype/copy_functions_heterogeneous.c @@ -269,8 +269,8 @@ copy_cxx_bool_heterogeneous(ompi_convertor_t *pConvertor, uint32_t count, #define FORTRAN_LOGICAL_COPY_LOOP(TYPE) \ for( i = 0; i < count; i++ ) { \ - opal_fortran_logical_t *to_real = (opal_fortran_logical_t*) to; \ - *to_real = *((TYPE*) from) == 0 ? 0 : OPAL_FORTRAN_VALUE_TRUE; \ + ompi_fortran_logical_t *to_real = (ompi_fortran_logical_t*) to; \ + *to_real = *((TYPE*) from) == 0 ? 0 : OMPI_FORTRAN_VALUE_TRUE; \ to += to_extent; \ from += from_extent; \ } @@ -298,13 +298,13 @@ copy_fortran_logical_heterogeneous(ompi_convertor_t *pConvertor, uint32_t count, } } - datatype_check( "logical", sizeof(opal_fortran_logical_t), - sizeof(opal_fortran_logical_t), &count, + datatype_check( "logical", sizeof(ompi_fortran_logical_t), + sizeof(ompi_fortran_logical_t), &count, from, from_len, from_extent, to, to_length, to_extent); - if ((to_extent != sizeof(opal_fortran_logical_t) || - from_extent != sizeof(opal_fortran_logical_t)) || + if ((to_extent != sizeof(ompi_fortran_logical_t) || + from_extent != sizeof(ompi_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 @@ copy_fortran_logical_heterogeneous(ompi_convertor_t *pConvertor, uint32_t count, break; } } else { - MEMCPY( to, from, count * sizeof(opal_fortran_logical_t) ); + MEMCPY( to, from, count * sizeof(ompi_fortran_logical_t) ); } *advance = count * from_extent; diff --git a/ompi/datatype/dt_module.c b/ompi/datatype/dt_module.c index 7062a0cf51..0b5a92450b 100644 --- a/ompi/datatype/dt_module.c +++ b/ompi/datatype/dt_module.c @@ -118,25 +118,25 @@ OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_unsigned_long_long = { INIT_BA 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, 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) }; +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) }; #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 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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_wchar = { INIT_UNAVAILABLE_DATA( WCHAR) }; -#endif /* OPAL_ALIGNMENT_WCHAR */ +#endif /* OMPI_ALIGNMENT_WCHAR */ -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) }; +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) }; #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_BASIC_DATA( 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, 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_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_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_2real = { INIT_BASIC_TYPE( DT_ 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, 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) }; +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) }; #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_2cplex = { INIT_BASIC_TYPE( DT 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 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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical1 = { INIT_UNAVAILABLE_DATA( LOGICAL1) }; -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical2 = { INIT_UNAVAILABLE_DATA( LOGICAL2) }; -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical4 = { INIT_UNAVAILABLE_DATA( LOGICAL4) }; -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_logical8 = { INIT_UNAVAILABLE_DATA( LOGICAL8) }; -#endif /* OPAL_HAVE_FORTRAN_LOGICAL8 */ +#endif /* OMPI_HAVE_FORTRAN_LOGICAL8 */ -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real2 = { INIT_UNAVAILABLE_DATA( REAL2) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real4 = { INIT_UNAVAILABLE_DATA( REAL4) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real8 = { INIT_UNAVAILABLE_DATA( REAL8) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_real16 = { INIT_UNAVAILABLE_DATA( REAL16) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer1 = { INIT_UNAVAILABLE_DATA( INTEGER1) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer2 = { INIT_UNAVAILABLE_DATA( INTEGER2) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer4 = { INIT_UNAVAILABLE_DATA( INTEGER4) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer8 = { INIT_UNAVAILABLE_DATA( INTEGER8) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_integer16 = { INIT_UNAVAILABLE_DATA( INTEGER16) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex8 = { INIT_UNAVAILABLE_DATA( COMPLEX8) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex16 = { INIT_UNAVAILABLE_DATA( COMPLEX16) }; #endif -#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) }; +#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) }; #else OMPI_DECLSPEC ompi_predefined_datatype_t ompi_mpi_complex32 = { INIT_UNAVAILABLE_DATA( COMPLEX32) }; #endif @@ -455,7 +455,7 @@ int32_t ompi_ddt_init( void ) /* 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, OPAL_FORTRAN_HANDLE_MAX, 64)) { + 0, OMPI_FORTRAN_HANDLE_MAX, 64)) { return OMPI_ERROR; } /* All temporary datatypes created on the following statement will get registered @@ -520,197 +520,197 @@ int32_t ompi_ddt_init( void ) #endif /* HAVE_LONG_DOUBLE */ /* Optional Fortran LOGICAL types */ -#if OPAL_HAVE_FORTRAN_LOGICAL1 -#if (OPAL_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_CHAR) +#if OMPI_HAVE_FORTRAN_LOGICAL1 +#if (OMPI_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_CHAR) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical1.dt, "MPI_LOGICAL1", &ompi_mpi_char.dt ); -#elif (OPAL_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_SHORT) +#elif (OMPI_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_SHORT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical1.dt, "MPI_LOGICAL1", &ompi_mpi_short.dt ); -#elif (OPAL_SIZEOF_FORTRAN_LOGICAL1 == SIZEOF_INT) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_LOGICAL1 */ +#endif /* OMPI_HAVE_FORTRAN_LOGICAL1 */ -#if OPAL_HAVE_FORTRAN_LOGICAL2 -#if (OPAL_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_SHORT) +#if OMPI_HAVE_FORTRAN_LOGICAL2 +#if (OMPI_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_SHORT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical2.dt, "MPI_LOGICAL2", &ompi_mpi_short.dt ); -#elif (OPAL_SIZEOF_FORTRAN_LOGICAL2 == SIZEOF_INT) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_LOGICAL2 */ +#endif /* OMPI_HAVE_FORTRAN_LOGICAL2 */ -#if OPAL_HAVE_FORTRAN_LOGICAL4 -#if (OPAL_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_INT) +#if OMPI_HAVE_FORTRAN_LOGICAL4 +#if (OMPI_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_INT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical4.dt, "MPI_LOGICAL4", &ompi_mpi_int.dt ); -#elif (OPAL_SIZEOF_FORTRAN_LOGICAL4 == SIZEOF_LONG) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_LOGICAL4 */ +#endif /* OMPI_HAVE_FORTRAN_LOGICAL4 */ -#if OPAL_HAVE_FORTRAN_LOGICAL8 -#if (OPAL_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG) +#if OMPI_HAVE_FORTRAN_LOGICAL8 +#if (OMPI_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_logical8.dt, "MPI_LOGICAL8", &ompi_mpi_long.dt ); -#elif (OPAL_SIZEOF_FORTRAN_LOGICAL8 == SIZEOF_LONG_LONG) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_INTEGER8 */ +#endif /* OMPI_HAVE_FORTRAN_INTEGER8 */ /* Optional Fortran REAL types */ -#if OPAL_HAVE_FORTRAN_REAL2 -#if (OPAL_SIZEOF_FORTRAN_REAL2 == SIZEOF_FLOAT) +#if OMPI_HAVE_FORTRAN_REAL2 +#if (OMPI_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 /* OPAL_HAVE_FORTRAN_REAL2 */ +#endif /* OMPI_HAVE_FORTRAN_REAL2 */ -#if OPAL_HAVE_FORTRAN_REAL4 -#if (OPAL_SIZEOF_FORTRAN_REAL4 == SIZEOF_FLOAT) +#if OMPI_HAVE_FORTRAN_REAL4 +#if (OMPI_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 /* OPAL_HAVE_FORTRAN_REAL4 */ +#endif /* OMPI_HAVE_FORTRAN_REAL4 */ -#if OPAL_HAVE_FORTRAN_REAL8 -#if (OPAL_SIZEOF_FORTRAN_REAL8 == SIZEOF_FLOAT) +#if OMPI_HAVE_FORTRAN_REAL8 +#if (OMPI_SIZEOF_FORTRAN_REAL8 == SIZEOF_FLOAT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real8.dt, "MPI_REAL8", &ompi_mpi_float.dt ); -#elif (OPAL_SIZEOF_FORTRAN_REAL8 == SIZEOF_DOUBLE) +#elif (OMPI_SIZEOF_FORTRAN_REAL8 == SIZEOF_DOUBLE) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_real8.dt, "MPI_REAL8", &ompi_mpi_double.dt ); -#elif (OPAL_SIZEOF_FORTRAN_REAL8 == SIZEOF_LONG_DOUBLE) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_REAL8 */ +#endif /* OMPI_HAVE_FORTRAN_REAL8 */ -#if OPAL_HAVE_FORTRAN_REAL16 -#if (OPAL_SIZEOF_FORTRAN_REAL16 == SIZEOF_LONG_DOUBLE) +#if OMPI_HAVE_FORTRAN_REAL16 +#if (OMPI_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 /* OPAL_HAVE_FORTRAN_REAL16 */ +#endif /* OMPI_HAVE_FORTRAN_REAL16 */ /* Optional Fortran INTEGER types */ -#if OPAL_HAVE_FORTRAN_INTEGER1 -#if (OPAL_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_CHAR) +#if OMPI_HAVE_FORTRAN_INTEGER1 +#if (OMPI_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_CHAR) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer1.dt, "MPI_INTEGER1", &ompi_mpi_char.dt ); -#elif (OPAL_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_SHORT) +#elif (OMPI_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_SHORT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer1.dt, "MPI_INTEGER1", &ompi_mpi_short.dt ); -#elif (OPAL_SIZEOF_FORTRAN_INTEGER1 == SIZEOF_INT) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_INTEGER1 */ +#endif /* OMPI_HAVE_FORTRAN_INTEGER1 */ -#if OPAL_HAVE_FORTRAN_INTEGER2 -#if (OPAL_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_SHORT) +#if OMPI_HAVE_FORTRAN_INTEGER2 +#if (OMPI_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_SHORT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer2.dt, "MPI_INTEGER2", &ompi_mpi_short.dt ); -#elif (OPAL_SIZEOF_FORTRAN_INTEGER2 == SIZEOF_INT) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_INTEGER2 */ +#endif /* OMPI_HAVE_FORTRAN_INTEGER2 */ -#if OPAL_HAVE_FORTRAN_INTEGER4 -#if (OPAL_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_INT) +#if OMPI_HAVE_FORTRAN_INTEGER4 +#if (OMPI_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_INT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer4.dt, "MPI_INTEGER4", &ompi_mpi_int.dt ); -#elif (OPAL_SIZEOF_FORTRAN_INTEGER4 == SIZEOF_LONG) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_INTEGER4 */ +#endif /* OMPI_HAVE_FORTRAN_INTEGER4 */ -#if OPAL_HAVE_FORTRAN_INTEGER8 -#if (OPAL_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG) +#if OMPI_HAVE_FORTRAN_INTEGER8 +#if (OMPI_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_integer8.dt, "MPI_INTEGER8", &ompi_mpi_long.dt ); -#elif (OPAL_SIZEOF_FORTRAN_INTEGER8 == SIZEOF_LONG_LONG) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_INTEGER8 */ +#endif /* OMPI_HAVE_FORTRAN_INTEGER8 */ -#if OPAL_HAVE_FORTRAN_INTEGER16 -#if (OPAL_SIZEOF_FORTRAN_INTEGER16 == SIZEOF_LONG_LONG) +#if OMPI_HAVE_FORTRAN_INTEGER16 +#if (OMPI_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 /* OPAL_HAVE_FORTRAN_INTEGER16 */ +#endif /* OMPI_HAVE_FORTRAN_INTEGER16 */ /* Optional Fortran COMPLEX types */ -#if OPAL_HAVE_FORTRAN_COMPLEX8 -#if (OPAL_SIZEOF_FORTRAN_COMPLEX8 == 2*SIZEOF_FLOAT) +#if OMPI_HAVE_FORTRAN_COMPLEX8 +#if (OMPI_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 /* OPAL_HAVE_FORTRAN_COMPLEX8 */ +#endif /* OMPI_HAVE_FORTRAN_COMPLEX8 */ -#if OPAL_HAVE_FORTRAN_COMPLEX16 -#if (OPAL_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_FLOAT) +#if OMPI_HAVE_FORTRAN_COMPLEX16 +#if (OMPI_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_FLOAT) DECLARE_MPI_SYNONYM_DDT( &ompi_mpi_complex16.dt, "MPI_COMPLEX16", &ompi_mpi_cplex.dt ); -#elif (OPAL_SIZEOF_FORTRAN_COMPLEX16 == 2*SIZEOF_DOUBLE) +#elif (OMPI_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 /* OPAL_HAVE_FORTRAN_COMPLEX16 */ +#endif /* OMPI_HAVE_FORTRAN_COMPLEX16 */ -#if OPAL_HAVE_FORTRAN_COMPLEX32 -#if OPAL_REAL16_MATCHES_C && (OPAL_SIZEOF_FORTRAN_COMPLEX32 == 2*SIZEOF_LONG_DOUBLE) +#if OMPI_HAVE_FORTRAN_COMPLEX32 +#if OMPI_REAL16_MATCHES_C && (OMPI_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 /* OPAL_HAVE_FORTRAN_COMPLEX32 */ +#endif /* OMPI_HAVE_FORTRAN_COMPLEX32 */ /* Start to populate the f2c index translation table */ diff --git a/ompi/errhandler/errcode-internal.c b/ompi/errhandler/errcode-internal.c index 440caff0d1..c2c98c1b7e 100644 --- a/ompi/errhandler/errcode-internal.c +++ b/ompi/errhandler/errcode-internal.c @@ -61,7 +61,7 @@ int ompi_errcode_intern_init (void) the error objects */ OBJ_CONSTRUCT(&ompi_errcodes_intern, opal_pointer_array_t); if( OPAL_SUCCESS != opal_pointer_array_init(&ompi_errcodes_intern, - 0, OPAL_FORTRAN_HANDLE_MAX, 64) ) { + 0, OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/errhandler/errcode.c b/ompi/errhandler/errcode.c index a8c4b6f15b..ee11203c36 100644 --- a/ompi/errhandler/errcode.c +++ b/ompi/errhandler/errcode.c @@ -111,7 +111,7 @@ int ompi_mpi_errcode_init (void) the error objects */ OBJ_CONSTRUCT(&ompi_mpi_errcodes, opal_pointer_array_t); if( OPAL_SUCCESS != opal_pointer_array_init(&ompi_mpi_errcodes, 0, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/errhandler/errhandler.c b/ompi/errhandler/errhandler.c index f15b5f25fe..a10e5dc3c0 100644 --- a/ompi/errhandler/errhandler.c +++ b/ompi/errhandler/errhandler.c @@ -76,7 +76,7 @@ int ompi_errhandler_init(void) 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, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/file/file.c b/ompi/file/file.c index 99734a58f7..41f2bba4ca 100644 --- a/ompi/file/file.c +++ b/ompi/file/file.c @@ -64,7 +64,7 @@ int ompi_file_init(void) 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, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/group/group_init.c b/ompi/group/group_init.c index 2deb94a162..c157c6e191 100644 --- a/ompi/group/group_init.c +++ b/ompi/group/group_init.c @@ -308,7 +308,7 @@ int ompi_group_init(void) /* 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, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/include/mpi.h.in b/ompi/include/mpi.h.in index b5cfd216f3..c0dcc5c947 100644 --- a/ompi/include/mpi.h.in +++ b/ompi/include/mpi.h.in @@ -87,43 +87,43 @@ #undef OPAL_MAX_PROCESSOR_NAME /* Whether we have FORTRAN LOGICAL*1 or not */ -#undef OPAL_HAVE_FORTRAN_LOGICAL1 +#undef OMPI_HAVE_FORTRAN_LOGICAL1 /* Whether we have FORTRAN LOGICAL*2 or not */ -#undef OPAL_HAVE_FORTRAN_LOGICAL2 +#undef OMPI_HAVE_FORTRAN_LOGICAL2 /* Whether we have FORTRAN LOGICAL*4 or not */ -#undef OPAL_HAVE_FORTRAN_LOGICAL4 +#undef OMPI_HAVE_FORTRAN_LOGICAL4 /* Whether we have FORTRAN LOGICAL*8 or not */ -#undef OPAL_HAVE_FORTRAN_LOGICAL8 +#undef OMPI_HAVE_FORTRAN_LOGICAL8 /* Whether we have FORTRAN INTEGER*1 or not */ -#undef OPAL_HAVE_FORTRAN_INTEGER1 +#undef OMPI_HAVE_FORTRAN_INTEGER1 /* Whether we have FORTRAN INTEGER*16 or not */ -#undef OPAL_HAVE_FORTRAN_INTEGER16 +#undef OMPI_HAVE_FORTRAN_INTEGER16 /* Whether we have FORTRAN INTEGER*2 or not */ -#undef OPAL_HAVE_FORTRAN_INTEGER2 +#undef OMPI_HAVE_FORTRAN_INTEGER2 /* Whether we have FORTRAN INTEGER*4 or not */ -#undef OPAL_HAVE_FORTRAN_INTEGER4 +#undef OMPI_HAVE_FORTRAN_INTEGER4 /* Whether we have FORTRAN INTEGER*8 or not */ -#undef OPAL_HAVE_FORTRAN_INTEGER8 +#undef OMPI_HAVE_FORTRAN_INTEGER8 /* Whether we have FORTRAN REAL*16 or not */ -#undef OPAL_HAVE_FORTRAN_REAL16 +#undef OMPI_HAVE_FORTRAN_REAL16 /* Whether we have FORTRAN REAL*2 or not */ -#undef OPAL_HAVE_FORTRAN_REAL2 +#undef OMPI_HAVE_FORTRAN_REAL2 /* Whether we have FORTRAN REAL*4 or not */ -#undef OPAL_HAVE_FORTRAN_REAL4 +#undef OMPI_HAVE_FORTRAN_REAL4 /* Whether we have FORTRAN REAL*8 or not */ -#undef OPAL_HAVE_FORTRAN_REAL8 +#undef OMPI_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 opal_fortran_bogus_type_t +#undef ompi_fortran_bogus_type_t /* C type corresponding to FORTRAN INTEGER */ -#undef opal_fortran_integer_t +#undef ompi_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 opal_fortran_integer_t */ -#define MPI_Fint opal_fortran_integer_t +/* MPI_Fint is the same as ompi_fortran_INTEGER_t */ +#define MPI_Fint ompi_fortran_integer_t #endif #endif /* #ifndef OMPI_CONFIG_H */ @@ -768,52 +768,52 @@ OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_cxx_ldblcplex; 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 OPAL_HAVE_FORTRAN_LOGICAL1 +#if OMPI_HAVE_FORTRAN_LOGICAL1 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical1; #endif -#if OPAL_HAVE_FORTRAN_LOGICAL2 +#if OMPI_HAVE_FORTRAN_LOGICAL2 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical2; #endif -#if OPAL_HAVE_FORTRAN_LOGICAL4 +#if OMPI_HAVE_FORTRAN_LOGICAL4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical4; #endif -#if OPAL_HAVE_FORTRAN_LOGICAL8 +#if OMPI_HAVE_FORTRAN_LOGICAL8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_logical8; #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_HAVE_FORTRAN_INTEGER1 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer1; #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_HAVE_FORTRAN_INTEGER2 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer2; #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_HAVE_FORTRAN_INTEGER4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer4; #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_HAVE_FORTRAN_INTEGER8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer8; #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_HAVE_FORTRAN_INTEGER16 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_integer16; #endif -#if OPAL_HAVE_FORTRAN_REAL2 +#if OMPI_HAVE_FORTRAN_REAL2 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real2; #endif -#if OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real4; #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real8; #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_HAVE_FORTRAN_REAL16 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_real16; #endif -#if OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_complex8; #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_complex16; #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_HAVE_FORTRAN_REAL16 OMPI_DECLSPEC extern struct ompi_predefined_datatype_t ompi_mpi_complex32; #endif @@ -887,53 +887,53 @@ OMPI_DECLSPEC extern MPI_Fint *MPI_F_STATUSES_IGNORE; /* 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 OPAL_HAVE_FORTRAN_LOGICAL1 +#if OMPI_HAVE_FORTRAN_LOGICAL1 #define MPI_LOGICAL1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_logical1) #endif -#if OPAL_HAVE_FORTRAN_LOGICAL2 +#if OMPI_HAVE_FORTRAN_LOGICAL2 #define MPI_LOGICAL2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_logical2) #endif -#if OPAL_HAVE_FORTRAN_LOGICAL4 +#if OMPI_HAVE_FORTRAN_LOGICAL4 #define MPI_LOGICAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_logical4) #endif -#if OPAL_HAVE_FORTRAN_LOGICAL8 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_HAVE_FORTRAN_INTEGER1 #define MPI_INTEGER1 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer1) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_HAVE_FORTRAN_INTEGER2 #define MPI_INTEGER2 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer2) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_HAVE_FORTRAN_INTEGER4 #define MPI_INTEGER4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer4) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_HAVE_FORTRAN_INTEGER8 #define MPI_INTEGER8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_integer8) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 #define MPI_REAL4 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_real4) #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 #define MPI_REAL8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_real8) #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_HAVE_FORTRAN_REAL4 #define MPI_COMPLEX8 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_complex8) #endif -#if OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_HAVE_FORTRAN_REAL8 #define MPI_COMPLEX16 OMPI_PREDEFINED_GLOBAL(MPI_Datatype, ompi_mpi_complex16) #endif -#if OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_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) diff --git a/ompi/include/ompi_config.h.in b/ompi/include/ompi_config.h.in index 4e7145df55..a42177e108 100644 --- a/ompi/include/ompi_config.h.in +++ b/ompi/include/ompi_config.h.in @@ -35,50 +35,50 @@ * **********************************************************************/ -/* MPI_Fint is the same as opal_fortran_integer_t */ -#define MPI_Fint opal_fortran_integer_t +/* MPI_Fint is the same as ompi_fortran_INTEGER_t */ +#define MPI_Fint ompi_fortran_integer_t -/* MPI_Flogical is the same as the opal_fortran_logical_t */ -#define MPI_Flogical opal_fortran_logical_t +/* MPI_Flogical is the same as the ompi_fortran_logical_t */ +#define MPI_Flogical ompi_fortran_logical_t -#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX +#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX /* * C type for Fortran COMPLEX */ typedef struct { - opal_fortran_real_t real; - opal_fortran_real_t imag; -} opal_fortran_complex_t; + ompi_fortran_real_t real; + ompi_fortran_real_t imag; +} ompi_fortran_complex_t; #endif -#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8 +#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8 /* * C type for Fortran COMPLEX*8 */ typedef struct { - opal_fortran_real4_t real; - opal_fortran_real4_t imag; -} opal_fortran_complex8_t; + ompi_fortran_real4_t real; + ompi_fortran_real4_t imag; +} ompi_fortran_complex8_t; #endif -#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16 +#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16 /* * C type for Fortran COMPLEX*16 */ typedef struct { - opal_fortran_real8_t real; - opal_fortran_real8_t imag; -} opal_fortran_complex16_t; + ompi_fortran_real8_t real; + ompi_fortran_real8_t imag; +} ompi_fortran_complex16_t; #endif -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32 +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32 /* * C type for Fortran COMPLEX*32 */ typedef struct { - opal_fortran_real16_t real; - opal_fortran_real16_t imag; -} opal_fortran_complex32_t; + ompi_fortran_real16_t real; + ompi_fortran_real16_t imag; +} ompi_fortran_complex32_t; #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION /* * C type for Fortran DOUBLE COMPLEX */ typedef struct { - opal_fortran_double_precision_t real; - opal_fortran_double_precision_t imag; -} opal_fortran_double_complex_t; + ompi_fortran_double_precision_t real; + ompi_fortran_double_precision_t imag; +} ompi_fortran_double_complex_t; #endif diff --git a/ompi/info/info.c b/ompi/info/info.c index e7a4a361ff..59f194b9e9 100644 --- a/ompi/info/info.c +++ b/ompi/info/info.c @@ -85,7 +85,7 @@ int ompi_info_init(void) 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, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/ompi/mca/op/base/functions.h b/ompi/mca/op/base/functions.h index 3af2d7f370..72019b393d 100644 --- a/ompi/mca/op/base/functions.h +++ b/ompi/mca/op/base/functions.h @@ -56,31 +56,31 @@ #define OMPI_OP_HANDLER_FORTRAN_INTEGER_INTRINSIC(name) \ void ompi_op_base_##name##_fortran_integer OMPI_OP_PROTO; -#if OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL2 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL +#if OMPI_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 OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_HAVE_FORTRAN_REAL16 #define OMPI_OP_HANDLER_COMPLEX32(name) \ void ompi_op_base_##name##_fortran_complex32 OMPI_OP_PROTO; #else @@ -311,31 +311,31 @@ BEGIN_C_DECLS #define OMPI_OP_3BUFF_HANDLER_FORTRAN_INTEGER_INTRINSIC(name) \ void ompi_op_base_3buff_##name##_fortran_integer OMPI_OP_PROTO_3BUF; -#if OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_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 @@ BEGIN_C_DECLS 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 OPAL_HAVE_FORTRAN_REAL2 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_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 @@ BEGIN_C_DECLS /* Complex */ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_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 OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL16 +#if OMPI_HAVE_FORTRAN_REAL16 #define OMPI_OP_3BUFF_HANDLER_COMPLEX32(name) \ void ompi_op_base_3buff_##name##_fortran_complex32 OMPI_OP_PROTO_3BUF; #else diff --git a/ompi/mca/op/base/op_base_functions.c b/ompi/mca/op/base/op_base_functions.c index 7c3460ae6c..65448cbeb4 100644 --- a/ompi/mca/op/base/op_base_functions.c +++ b/ompi/mca/op/base/op_base_functions.c @@ -151,23 +151,23 @@ FUNC_FUNC(max, long_long_int, long long int) FUNC_FUNC(max, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC(max, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC(max, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC(max, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC(max, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC(max, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC(max, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC(max, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC(max, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC(max, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC(max, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC(max, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC(max, fortran_integer16, ompi_fortran_integer16_t) #endif /* Floating point */ FUNC_FUNC(max, float, float) @@ -175,23 +175,23 @@ FUNC_FUNC(max, double, double) #if HAVE_LONG_DOUBLE FUNC_FUNC(max, long_double, long double) #endif -#if OPAL_HAVE_FORTRAN_REAL -FUNC_FUNC(max, fortran_real, opal_fortran_real_t) +#if OMPI_HAVE_FORTRAN_REAL +FUNC_FUNC(max, fortran_real, ompi_fortran_real_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -FUNC_FUNC(max, fortran_double_precision, opal_fortran_double_precision_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +FUNC_FUNC(max, fortran_double_precision, ompi_fortran_double_precision_t) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -FUNC_FUNC(max, fortran_real2, opal_fortran_real2_t) +#if OMPI_HAVE_FORTRAN_REAL2 +FUNC_FUNC(max, fortran_real2, ompi_fortran_real2_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -FUNC_FUNC(max, fortran_real4, opal_fortran_real4_t) +#if OMPI_HAVE_FORTRAN_REAL4 +FUNC_FUNC(max, fortran_real4, ompi_fortran_real4_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -FUNC_FUNC(max, fortran_real8, opal_fortran_real8_t) +#if OMPI_HAVE_FORTRAN_REAL8 +FUNC_FUNC(max, fortran_real8, ompi_fortran_real8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -FUNC_FUNC(max, fortran_real16, opal_fortran_real16_t) +#if OMPI_HAVE_FORTRAN_REAL16 +FUNC_FUNC(max, fortran_real16, ompi_fortran_real16_t) #endif @@ -215,23 +215,23 @@ FUNC_FUNC(min, long_long_int, long long int) FUNC_FUNC(min, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC(min, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC(min, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC(min, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC(min, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC(min, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC(min, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC(min, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC(min, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC(min, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC(min, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC(min, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC(min, fortran_integer16, ompi_fortran_integer16_t) #endif /* Floating point */ FUNC_FUNC(min, float, float) @@ -239,23 +239,23 @@ FUNC_FUNC(min, double, double) #if HAVE_LONG_DOUBLE FUNC_FUNC(min, long_double, long double) #endif -#if OPAL_HAVE_FORTRAN_REAL -FUNC_FUNC(min, fortran_real, opal_fortran_real_t) +#if OMPI_HAVE_FORTRAN_REAL +FUNC_FUNC(min, fortran_real, ompi_fortran_real_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -FUNC_FUNC(min, fortran_double_precision, opal_fortran_double_precision_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +FUNC_FUNC(min, fortran_double_precision, ompi_fortran_double_precision_t) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -FUNC_FUNC(min, fortran_real2, opal_fortran_real2_t) +#if OMPI_HAVE_FORTRAN_REAL2 +FUNC_FUNC(min, fortran_real2, ompi_fortran_real2_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -FUNC_FUNC(min, fortran_real4, opal_fortran_real4_t) +#if OMPI_HAVE_FORTRAN_REAL4 +FUNC_FUNC(min, fortran_real4, ompi_fortran_real4_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -FUNC_FUNC(min, fortran_real8, opal_fortran_real8_t) +#if OMPI_HAVE_FORTRAN_REAL8 +FUNC_FUNC(min, fortran_real8, ompi_fortran_real8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -FUNC_FUNC(min, fortran_real16, opal_fortran_real16_t) +#if OMPI_HAVE_FORTRAN_REAL16 +FUNC_FUNC(min, fortran_real16, ompi_fortran_real16_t) #endif /************************************************************************* @@ -276,23 +276,23 @@ OP_FUNC(sum, long_long_int, long long int, +=) OP_FUNC(sum, unsigned_long_long, unsigned long long, +=) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -OP_FUNC(sum, fortran_integer, opal_fortran_integer_t, +=) +#if OMPI_HAVE_FORTRAN_INTEGER +OP_FUNC(sum, fortran_integer, ompi_fortran_integer_t, +=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -OP_FUNC(sum, fortran_integer1, opal_fortran_integer1_t, +=) +#if OMPI_HAVE_FORTRAN_INTEGER1 +OP_FUNC(sum, fortran_integer1, ompi_fortran_integer1_t, +=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -OP_FUNC(sum, fortran_integer2, opal_fortran_integer2_t, +=) +#if OMPI_HAVE_FORTRAN_INTEGER2 +OP_FUNC(sum, fortran_integer2, ompi_fortran_integer2_t, +=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -OP_FUNC(sum, fortran_integer4, opal_fortran_integer4_t, +=) +#if OMPI_HAVE_FORTRAN_INTEGER4 +OP_FUNC(sum, fortran_integer4, ompi_fortran_integer4_t, +=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -OP_FUNC(sum, fortran_integer8, opal_fortran_integer8_t, +=) +#if OMPI_HAVE_FORTRAN_INTEGER8 +OP_FUNC(sum, fortran_integer8, ompi_fortran_integer8_t, +=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -OP_FUNC(sum, fortran_integer16, opal_fortran_integer16_t, +=) +#if OMPI_HAVE_FORTRAN_INTEGER16 +OP_FUNC(sum, fortran_integer16, ompi_fortran_integer16_t, +=) #endif /* Floating point */ OP_FUNC(sum, float, float, +=) @@ -300,39 +300,39 @@ OP_FUNC(sum, double, double, +=) #if HAVE_LONG_DOUBLE OP_FUNC(sum, long_double, long double, +=) #endif -#if OPAL_HAVE_FORTRAN_REAL -OP_FUNC(sum, fortran_real, opal_fortran_real_t, +=) +#if OMPI_HAVE_FORTRAN_REAL +OP_FUNC(sum, fortran_real, ompi_fortran_real_t, +=) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -OP_FUNC(sum, fortran_double_precision, opal_fortran_double_precision_t, +=) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +OP_FUNC(sum, fortran_double_precision, ompi_fortran_double_precision_t, +=) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -OP_FUNC(sum, fortran_real2, opal_fortran_real2_t, +=) +#if OMPI_HAVE_FORTRAN_REAL2 +OP_FUNC(sum, fortran_real2, ompi_fortran_real2_t, +=) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -OP_FUNC(sum, fortran_real4, opal_fortran_real4_t, +=) +#if OMPI_HAVE_FORTRAN_REAL4 +OP_FUNC(sum, fortran_real4, ompi_fortran_real4_t, +=) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -OP_FUNC(sum, fortran_real8, opal_fortran_real8_t, +=) +#if OMPI_HAVE_FORTRAN_REAL8 +OP_FUNC(sum, fortran_real8, ompi_fortran_real8_t, +=) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -OP_FUNC(sum, fortran_real16, opal_fortran_real16_t, +=) +#if OMPI_HAVE_FORTRAN_REAL16 +OP_FUNC(sum, fortran_real16, ompi_fortran_real16_t, +=) #endif /* Complex */ -#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_SUM(fortran_complex, opal_fortran_complex_t) +#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_SUM(fortran_complex, ompi_fortran_complex_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_SUM(fortran_double_complex, opal_fortran_double_complex_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_SUM(fortran_double_complex, ompi_fortran_double_complex_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8 -COMPLEX_OP_FUNC_SUM(fortran_complex8, opal_fortran_complex8_t) +#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8 +COMPLEX_OP_FUNC_SUM(fortran_complex8, ompi_fortran_complex8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16 -COMPLEX_OP_FUNC_SUM(fortran_complex16, opal_fortran_complex16_t) +#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16 +COMPLEX_OP_FUNC_SUM(fortran_complex16, ompi_fortran_complex16_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32 -COMPLEX_OP_FUNC_SUM(fortran_complex32, opal_fortran_complex32_t) +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32 +COMPLEX_OP_FUNC_SUM(fortran_complex32, ompi_fortran_complex32_t) #endif /************************************************************************* @@ -353,23 +353,23 @@ OP_FUNC(prod, long_long_int, long long int, *=) OP_FUNC(prod, unsigned_long_long, unsigned long long, *=) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -OP_FUNC(prod, fortran_integer, opal_fortran_integer_t, *=) +#if OMPI_HAVE_FORTRAN_INTEGER +OP_FUNC(prod, fortran_integer, ompi_fortran_integer_t, *=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -OP_FUNC(prod, fortran_integer1, opal_fortran_integer1_t, *=) +#if OMPI_HAVE_FORTRAN_INTEGER1 +OP_FUNC(prod, fortran_integer1, ompi_fortran_integer1_t, *=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -OP_FUNC(prod, fortran_integer2, opal_fortran_integer2_t, *=) +#if OMPI_HAVE_FORTRAN_INTEGER2 +OP_FUNC(prod, fortran_integer2, ompi_fortran_integer2_t, *=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -OP_FUNC(prod, fortran_integer4, opal_fortran_integer4_t, *=) +#if OMPI_HAVE_FORTRAN_INTEGER4 +OP_FUNC(prod, fortran_integer4, ompi_fortran_integer4_t, *=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -OP_FUNC(prod, fortran_integer8, opal_fortran_integer8_t, *=) +#if OMPI_HAVE_FORTRAN_INTEGER8 +OP_FUNC(prod, fortran_integer8, ompi_fortran_integer8_t, *=) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -OP_FUNC(prod, fortran_integer16, opal_fortran_integer16_t, *=) +#if OMPI_HAVE_FORTRAN_INTEGER16 +OP_FUNC(prod, fortran_integer16, ompi_fortran_integer16_t, *=) #endif /* Floating point */ OP_FUNC(prod, float, float, *=) @@ -377,39 +377,39 @@ OP_FUNC(prod, double, double, *=) #if HAVE_LONG_DOUBLE OP_FUNC(prod, long_double, long double, *=) #endif -#if OPAL_HAVE_FORTRAN_REAL -OP_FUNC(prod, fortran_real, opal_fortran_real_t, *=) +#if OMPI_HAVE_FORTRAN_REAL +OP_FUNC(prod, fortran_real, ompi_fortran_real_t, *=) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -OP_FUNC(prod, fortran_double_precision, opal_fortran_double_precision_t, *=) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +OP_FUNC(prod, fortran_double_precision, ompi_fortran_double_precision_t, *=) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -OP_FUNC(prod, fortran_real2, opal_fortran_real2_t, *=) +#if OMPI_HAVE_FORTRAN_REAL2 +OP_FUNC(prod, fortran_real2, ompi_fortran_real2_t, *=) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -OP_FUNC(prod, fortran_real4, opal_fortran_real4_t, *=) +#if OMPI_HAVE_FORTRAN_REAL4 +OP_FUNC(prod, fortran_real4, ompi_fortran_real4_t, *=) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -OP_FUNC(prod, fortran_real8, opal_fortran_real8_t, *=) +#if OMPI_HAVE_FORTRAN_REAL8 +OP_FUNC(prod, fortran_real8, ompi_fortran_real8_t, *=) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -OP_FUNC(prod, fortran_real16, opal_fortran_real16_t, *=) +#if OMPI_HAVE_FORTRAN_REAL16 +OP_FUNC(prod, fortran_real16, ompi_fortran_real16_t, *=) #endif /* Complex */ -#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_PROD(fortran_complex, opal_fortran_complex_t) +#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_PROD(fortran_complex, ompi_fortran_complex_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_PROD(fortran_double_complex, opal_fortran_double_complex_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_PROD(fortran_double_complex, ompi_fortran_double_complex_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8 -COMPLEX_OP_FUNC_PROD(fortran_complex8, opal_fortran_complex8_t) +#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8 +COMPLEX_OP_FUNC_PROD(fortran_complex8, ompi_fortran_complex8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16 -COMPLEX_OP_FUNC_PROD(fortran_complex16, opal_fortran_complex16_t) +#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16 +COMPLEX_OP_FUNC_PROD(fortran_complex16, ompi_fortran_complex16_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32 -COMPLEX_OP_FUNC_PROD(fortran_complex32, opal_fortran_complex32_t) +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32 +COMPLEX_OP_FUNC_PROD(fortran_complex32, ompi_fortran_complex32_t) #endif /************************************************************************* @@ -432,8 +432,8 @@ FUNC_FUNC(land, long_long_int, long long int) FUNC_FUNC(land, unsigned_long_long, unsigned long long) #endif /* Logical */ -#if OPAL_HAVE_FORTRAN_LOGICAL -FUNC_FUNC(land, fortran_logical, opal_fortran_logical_t) +#if OMPI_HAVE_FORTRAN_LOGICAL +FUNC_FUNC(land, fortran_logical, ompi_fortran_logical_t) #endif /* C++ bool */ FUNC_FUNC(land, bool, bool) @@ -458,8 +458,8 @@ FUNC_FUNC(lor, long_long_int, long long int) FUNC_FUNC(lor, unsigned_long_long, unsigned long long) #endif /* Logical */ -#if OPAL_HAVE_FORTRAN_LOGICAL -FUNC_FUNC(lor, fortran_logical, opal_fortran_logical_t) +#if OMPI_HAVE_FORTRAN_LOGICAL +FUNC_FUNC(lor, fortran_logical, ompi_fortran_logical_t) #endif /* C++ bool */ FUNC_FUNC(lor, bool, bool) @@ -484,8 +484,8 @@ FUNC_FUNC(lxor, long_long_int, long long int) FUNC_FUNC(lxor, unsigned_long_long, unsigned long long) #endif /* Logical */ -#if OPAL_HAVE_FORTRAN_LOGICAL -FUNC_FUNC(lxor, fortran_logical, opal_fortran_logical_t) +#if OMPI_HAVE_FORTRAN_LOGICAL +FUNC_FUNC(lxor, fortran_logical, ompi_fortran_logical_t) #endif /* C++ bool */ FUNC_FUNC(lxor, bool, bool) @@ -510,23 +510,23 @@ FUNC_FUNC(band, long_long_int, long long int) FUNC_FUNC(band, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC(band, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC(band, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC(band, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC(band, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC(band, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC(band, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC(band, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC(band, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC(band, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC(band, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC(band, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC(band, fortran_integer16, ompi_fortran_integer16_t) #endif /* Byte */ FUNC_FUNC(band, byte, char) @@ -551,23 +551,23 @@ FUNC_FUNC(bor, long_long_int, long long int) FUNC_FUNC(bor, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC(bor, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC(bor, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC(bor, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC(bor, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC(bor, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC(bor, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC(bor, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC(bor, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC(bor, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC(bor, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC(bor, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC(bor, fortran_integer16, ompi_fortran_integer16_t) #endif /* Byte */ FUNC_FUNC(bor, byte, char) @@ -592,23 +592,23 @@ FUNC_FUNC(bxor, long_long_int, long long int) FUNC_FUNC(bxor, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC(bxor, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC(bxor, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC(bxor, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC(bxor, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC(bxor, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC(bxor, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC(bxor, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC(bxor, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC(bxor, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC(bxor, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC(bxor, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC(bxor, fortran_integer16, ompi_fortran_integer16_t) #endif /* Byte */ FUNC_FUNC(bxor, byte, char) @@ -617,14 +617,14 @@ FUNC_FUNC(bxor, byte, char) * Min and max location "pair" datatypes *************************************************************************/ -#if OPAL_HAVE_FORTRAN_REAL -LOC_STRUCT(2real, opal_fortran_real_t, opal_fortran_real_t) +#if OMPI_HAVE_FORTRAN_REAL +LOC_STRUCT(2real, ompi_fortran_real_t, ompi_fortran_real_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -LOC_STRUCT(2double_precision, opal_fortran_double_precision_t, opal_fortran_double_precision_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +LOC_STRUCT(2double_precision, ompi_fortran_double_precision_t, ompi_fortran_double_precision_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER -LOC_STRUCT(2integer, opal_fortran_integer_t, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +LOC_STRUCT(2integer, ompi_fortran_integer_t, ompi_fortran_integer_t) #endif LOC_STRUCT(float_int, float, int) LOC_STRUCT(double_int, double, int) @@ -639,13 +639,13 @@ LOC_STRUCT(long_double_int, long double, int) * Max location *************************************************************************/ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_HAVE_FORTRAN_REAL LOC_FUNC(maxloc, 2real, >) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION LOC_FUNC(maxloc, 2double_precision, >) #endif -#if OPAL_HAVE_FORTRAN_INTEGER +#if OMPI_HAVE_FORTRAN_INTEGER LOC_FUNC(maxloc, 2integer, >) #endif LOC_FUNC(maxloc, float_int, >) @@ -661,13 +661,13 @@ LOC_FUNC(maxloc, long_double_int, >) * Min location *************************************************************************/ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_HAVE_FORTRAN_REAL LOC_FUNC(minloc, 2real, <) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION LOC_FUNC(minloc, 2double_precision, <) #endif -#if OPAL_HAVE_FORTRAN_INTEGER +#if OMPI_HAVE_FORTRAN_INTEGER LOC_FUNC(minloc, 2integer, <) #endif LOC_FUNC(minloc, float_int, <) @@ -816,23 +816,23 @@ FUNC_FUNC_3BUF(max, long_long_int, long long int) FUNC_FUNC_3BUF(max, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC_3BUF(max, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC_3BUF(max, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC_3BUF(max, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC_3BUF(max, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC_3BUF(max, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC_3BUF(max, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC_3BUF(max, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC_3BUF(max, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC_3BUF(max, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC_3BUF(max, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC_3BUF(max, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC_3BUF(max, fortran_integer16, ompi_fortran_integer16_t) #endif /* Floating point */ FUNC_FUNC_3BUF(max, float, float) @@ -840,23 +840,23 @@ FUNC_FUNC_3BUF(max, double, double) #if HAVE_LONG_DOUBLE FUNC_FUNC_3BUF(max, long_double, long double) #endif -#if OPAL_HAVE_FORTRAN_REAL -FUNC_FUNC_3BUF(max, fortran_real, opal_fortran_real_t) +#if OMPI_HAVE_FORTRAN_REAL +FUNC_FUNC_3BUF(max, fortran_real, ompi_fortran_real_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -FUNC_FUNC_3BUF(max, fortran_double_precision, opal_fortran_double_precision_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +FUNC_FUNC_3BUF(max, fortran_double_precision, ompi_fortran_double_precision_t) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -FUNC_FUNC_3BUF(max, fortran_real2, opal_fortran_real2_t) +#if OMPI_HAVE_FORTRAN_REAL2 +FUNC_FUNC_3BUF(max, fortran_real2, ompi_fortran_real2_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -FUNC_FUNC_3BUF(max, fortran_real4, opal_fortran_real4_t) +#if OMPI_HAVE_FORTRAN_REAL4 +FUNC_FUNC_3BUF(max, fortran_real4, ompi_fortran_real4_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -FUNC_FUNC_3BUF(max, fortran_real8, opal_fortran_real8_t) +#if OMPI_HAVE_FORTRAN_REAL8 +FUNC_FUNC_3BUF(max, fortran_real8, ompi_fortran_real8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -FUNC_FUNC_3BUF(max, fortran_real16, opal_fortran_real16_t) +#if OMPI_HAVE_FORTRAN_REAL16 +FUNC_FUNC_3BUF(max, fortran_real16, ompi_fortran_real16_t) #endif @@ -880,23 +880,23 @@ FUNC_FUNC_3BUF(min, long_long_int, long long int) FUNC_FUNC_3BUF(min, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC_3BUF(min, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC_3BUF(min, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC_3BUF(min, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC_3BUF(min, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC_3BUF(min, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC_3BUF(min, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC_3BUF(min, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC_3BUF(min, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC_3BUF(min, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC_3BUF(min, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC_3BUF(min, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC_3BUF(min, fortran_integer16, ompi_fortran_integer16_t) #endif /* Floating point */ FUNC_FUNC_3BUF(min, float, float) @@ -904,23 +904,23 @@ FUNC_FUNC_3BUF(min, double, double) #if HAVE_LONG_DOUBLE FUNC_FUNC_3BUF(min, long_double, long double) #endif -#if OPAL_HAVE_FORTRAN_REAL -FUNC_FUNC_3BUF(min, fortran_real, opal_fortran_real_t) +#if OMPI_HAVE_FORTRAN_REAL +FUNC_FUNC_3BUF(min, fortran_real, ompi_fortran_real_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -FUNC_FUNC_3BUF(min, fortran_double_precision, opal_fortran_double_precision_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +FUNC_FUNC_3BUF(min, fortran_double_precision, ompi_fortran_double_precision_t) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -FUNC_FUNC_3BUF(min, fortran_real2, opal_fortran_real2_t) +#if OMPI_HAVE_FORTRAN_REAL2 +FUNC_FUNC_3BUF(min, fortran_real2, ompi_fortran_real2_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -FUNC_FUNC_3BUF(min, fortran_real4, opal_fortran_real4_t) +#if OMPI_HAVE_FORTRAN_REAL4 +FUNC_FUNC_3BUF(min, fortran_real4, ompi_fortran_real4_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -FUNC_FUNC_3BUF(min, fortran_real8, opal_fortran_real8_t) +#if OMPI_HAVE_FORTRAN_REAL8 +FUNC_FUNC_3BUF(min, fortran_real8, ompi_fortran_real8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -FUNC_FUNC_3BUF(min, fortran_real16, opal_fortran_real16_t) +#if OMPI_HAVE_FORTRAN_REAL16 +FUNC_FUNC_3BUF(min, fortran_real16, ompi_fortran_real16_t) #endif /************************************************************************* @@ -941,23 +941,23 @@ OP_FUNC_3BUF(sum, long_long_int, long long int, +) OP_FUNC_3BUF(sum, unsigned_long_long, unsigned long long, +) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -OP_FUNC_3BUF(sum, fortran_integer, opal_fortran_integer_t, +) +#if OMPI_HAVE_FORTRAN_INTEGER +OP_FUNC_3BUF(sum, fortran_integer, ompi_fortran_integer_t, +) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -OP_FUNC_3BUF(sum, fortran_integer1, opal_fortran_integer1_t, +) +#if OMPI_HAVE_FORTRAN_INTEGER1 +OP_FUNC_3BUF(sum, fortran_integer1, ompi_fortran_integer1_t, +) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -OP_FUNC_3BUF(sum, fortran_integer2, opal_fortran_integer2_t, +) +#if OMPI_HAVE_FORTRAN_INTEGER2 +OP_FUNC_3BUF(sum, fortran_integer2, ompi_fortran_integer2_t, +) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -OP_FUNC_3BUF(sum, fortran_integer4, opal_fortran_integer4_t, +) +#if OMPI_HAVE_FORTRAN_INTEGER4 +OP_FUNC_3BUF(sum, fortran_integer4, ompi_fortran_integer4_t, +) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -OP_FUNC_3BUF(sum, fortran_integer8, opal_fortran_integer8_t, +) +#if OMPI_HAVE_FORTRAN_INTEGER8 +OP_FUNC_3BUF(sum, fortran_integer8, ompi_fortran_integer8_t, +) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -OP_FUNC_3BUF(sum, fortran_integer16, opal_fortran_integer16_t, +) +#if OMPI_HAVE_FORTRAN_INTEGER16 +OP_FUNC_3BUF(sum, fortran_integer16, ompi_fortran_integer16_t, +) #endif /* Floating point */ OP_FUNC_3BUF(sum, float, float, +) @@ -965,39 +965,39 @@ OP_FUNC_3BUF(sum, double, double, +) #if HAVE_LONG_DOUBLE OP_FUNC_3BUF(sum, long_double, long double, +) #endif -#if OPAL_HAVE_FORTRAN_REAL -OP_FUNC_3BUF(sum, fortran_real, opal_fortran_real_t, +) +#if OMPI_HAVE_FORTRAN_REAL +OP_FUNC_3BUF(sum, fortran_real, ompi_fortran_real_t, +) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -OP_FUNC_3BUF(sum, fortran_double_precision, opal_fortran_double_precision_t, +) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +OP_FUNC_3BUF(sum, fortran_double_precision, ompi_fortran_double_precision_t, +) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -OP_FUNC_3BUF(sum, fortran_real2, opal_fortran_real2_t, +) +#if OMPI_HAVE_FORTRAN_REAL2 +OP_FUNC_3BUF(sum, fortran_real2, ompi_fortran_real2_t, +) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -OP_FUNC_3BUF(sum, fortran_real4, opal_fortran_real4_t, +) +#if OMPI_HAVE_FORTRAN_REAL4 +OP_FUNC_3BUF(sum, fortran_real4, ompi_fortran_real4_t, +) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -OP_FUNC_3BUF(sum, fortran_real8, opal_fortran_real8_t, +) +#if OMPI_HAVE_FORTRAN_REAL8 +OP_FUNC_3BUF(sum, fortran_real8, ompi_fortran_real8_t, +) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -OP_FUNC_3BUF(sum, fortran_real16, opal_fortran_real16_t, +) +#if OMPI_HAVE_FORTRAN_REAL16 +OP_FUNC_3BUF(sum, fortran_real16, ompi_fortran_real16_t, +) #endif /* Complex */ -#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex, opal_fortran_complex_t) +#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex, ompi_fortran_complex_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_SUM_3BUF(fortran_double_complex, opal_fortran_double_complex_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_SUM_3BUF(fortran_double_complex, ompi_fortran_double_complex_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8 -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex8, opal_fortran_complex8_t) +#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8 +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex8, ompi_fortran_complex8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16 -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex16, opal_fortran_complex16_t) +#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16 +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex16, ompi_fortran_complex16_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32 -COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex32, opal_fortran_complex32_t) +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32 +COMPLEX_OP_FUNC_SUM_3BUF(fortran_complex32, ompi_fortran_complex32_t) #endif /************************************************************************* @@ -1018,23 +1018,23 @@ OP_FUNC_3BUF(prod, long_long_int, long long int, *) OP_FUNC_3BUF(prod, unsigned_long_long, unsigned long long, *) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -OP_FUNC_3BUF(prod, fortran_integer, opal_fortran_integer_t, *) +#if OMPI_HAVE_FORTRAN_INTEGER +OP_FUNC_3BUF(prod, fortran_integer, ompi_fortran_integer_t, *) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -OP_FUNC_3BUF(prod, fortran_integer1, opal_fortran_integer1_t, *) +#if OMPI_HAVE_FORTRAN_INTEGER1 +OP_FUNC_3BUF(prod, fortran_integer1, ompi_fortran_integer1_t, *) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -OP_FUNC_3BUF(prod, fortran_integer2, opal_fortran_integer2_t, *) +#if OMPI_HAVE_FORTRAN_INTEGER2 +OP_FUNC_3BUF(prod, fortran_integer2, ompi_fortran_integer2_t, *) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -OP_FUNC_3BUF(prod, fortran_integer4, opal_fortran_integer4_t, *) +#if OMPI_HAVE_FORTRAN_INTEGER4 +OP_FUNC_3BUF(prod, fortran_integer4, ompi_fortran_integer4_t, *) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -OP_FUNC_3BUF(prod, fortran_integer8, opal_fortran_integer8_t, *) +#if OMPI_HAVE_FORTRAN_INTEGER8 +OP_FUNC_3BUF(prod, fortran_integer8, ompi_fortran_integer8_t, *) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -OP_FUNC_3BUF(prod, fortran_integer16, opal_fortran_integer16_t, *) +#if OMPI_HAVE_FORTRAN_INTEGER16 +OP_FUNC_3BUF(prod, fortran_integer16, ompi_fortran_integer16_t, *) #endif /* Floating point */ OP_FUNC_3BUF(prod, float, float, *) @@ -1042,39 +1042,39 @@ OP_FUNC_3BUF(prod, double, double, *) #if HAVE_LONG_DOUBLE OP_FUNC_3BUF(prod, long_double, long double, *) #endif -#if OPAL_HAVE_FORTRAN_REAL -OP_FUNC_3BUF(prod, fortran_real, opal_fortran_real_t, *) +#if OMPI_HAVE_FORTRAN_REAL +OP_FUNC_3BUF(prod, fortran_real, ompi_fortran_real_t, *) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -OP_FUNC_3BUF(prod, fortran_double_precision, opal_fortran_double_precision_t, *) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +OP_FUNC_3BUF(prod, fortran_double_precision, ompi_fortran_double_precision_t, *) #endif -#if OPAL_HAVE_FORTRAN_REAL2 -OP_FUNC_3BUF(prod, fortran_real2, opal_fortran_real2_t, *) +#if OMPI_HAVE_FORTRAN_REAL2 +OP_FUNC_3BUF(prod, fortran_real2, ompi_fortran_real2_t, *) #endif -#if OPAL_HAVE_FORTRAN_REAL4 -OP_FUNC_3BUF(prod, fortran_real4, opal_fortran_real4_t, *) +#if OMPI_HAVE_FORTRAN_REAL4 +OP_FUNC_3BUF(prod, fortran_real4, ompi_fortran_real4_t, *) #endif -#if OPAL_HAVE_FORTRAN_REAL8 -OP_FUNC_3BUF(prod, fortran_real8, opal_fortran_real8_t, *) +#if OMPI_HAVE_FORTRAN_REAL8 +OP_FUNC_3BUF(prod, fortran_real8, ompi_fortran_real8_t, *) #endif -#if OPAL_HAVE_FORTRAN_REAL16 -OP_FUNC_3BUF(prod, fortran_real16, opal_fortran_real16_t, *) +#if OMPI_HAVE_FORTRAN_REAL16 +OP_FUNC_3BUF(prod, fortran_real16, ompi_fortran_real16_t, *) #endif /* Complex */ -#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex, opal_fortran_complex_t) +#if OMPI_HAVE_FORTRAN_REAL && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex, ompi_fortran_complex_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX -COMPLEX_OP_FUNC_PROD_3BUF(fortran_double_complex, opal_fortran_double_complex_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_HAVE_FORTRAN_COMPLEX +COMPLEX_OP_FUNC_PROD_3BUF(fortran_double_complex, ompi_fortran_double_complex_t) #endif -#if OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8 -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex8, opal_fortran_complex8_t) +#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_HAVE_FORTRAN_COMPLEX8 +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex8, ompi_fortran_complex8_t) #endif -#if OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16 -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex16, opal_fortran_complex16_t) +#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_HAVE_FORTRAN_COMPLEX16 +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex16, ompi_fortran_complex16_t) #endif -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_HAVE_FORTRAN_COMPLEX32 -COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex32, opal_fortran_complex32_t) +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_HAVE_FORTRAN_COMPLEX32 +COMPLEX_OP_FUNC_PROD_3BUF(fortran_complex32, ompi_fortran_complex32_t) #endif /************************************************************************* @@ -1097,8 +1097,8 @@ FUNC_FUNC_3BUF(land, long_long_int, long long int) FUNC_FUNC_3BUF(land, unsigned_long_long, unsigned long long) #endif /* Logical */ -#if OPAL_HAVE_FORTRAN_LOGICAL -FUNC_FUNC_3BUF(land, fortran_logical, opal_fortran_logical_t) +#if OMPI_HAVE_FORTRAN_LOGICAL +FUNC_FUNC_3BUF(land, fortran_logical, ompi_fortran_logical_t) #endif /* C++ bool */ FUNC_FUNC_3BUF(land, bool, bool) @@ -1123,8 +1123,8 @@ FUNC_FUNC_3BUF(lor, long_long_int, long long int) FUNC_FUNC_3BUF(lor, unsigned_long_long, unsigned long long) #endif /* Logical */ -#if OPAL_HAVE_FORTRAN_LOGICAL -FUNC_FUNC_3BUF(lor, fortran_logical, opal_fortran_logical_t) +#if OMPI_HAVE_FORTRAN_LOGICAL +FUNC_FUNC_3BUF(lor, fortran_logical, ompi_fortran_logical_t) #endif /* C++ bool */ FUNC_FUNC_3BUF(lor, bool, bool) @@ -1149,8 +1149,8 @@ FUNC_FUNC_3BUF(lxor, long_long_int, long long int) FUNC_FUNC_3BUF(lxor, unsigned_long_long, unsigned long long) #endif /* Logical */ -#if OPAL_HAVE_FORTRAN_LOGICAL -FUNC_FUNC_3BUF(lxor, fortran_logical, opal_fortran_logical_t) +#if OMPI_HAVE_FORTRAN_LOGICAL +FUNC_FUNC_3BUF(lxor, fortran_logical, ompi_fortran_logical_t) #endif /* C++ bool */ FUNC_FUNC_3BUF(lxor, bool, bool) @@ -1175,23 +1175,23 @@ FUNC_FUNC_3BUF(band, long_long_int, long long int) FUNC_FUNC_3BUF(band, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC_3BUF(band, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC_3BUF(band, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC_3BUF(band, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC_3BUF(band, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC_3BUF(band, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC_3BUF(band, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC_3BUF(band, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC_3BUF(band, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC_3BUF(band, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC_3BUF(band, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC_3BUF(band, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC_3BUF(band, fortran_integer16, ompi_fortran_integer16_t) #endif /* Byte */ FUNC_FUNC_3BUF(band, byte, char) @@ -1216,23 +1216,23 @@ FUNC_FUNC_3BUF(bor, long_long_int, long long int) FUNC_FUNC_3BUF(bor, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC_3BUF(bor, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC_3BUF(bor, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC_3BUF(bor, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC_3BUF(bor, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC_3BUF(bor, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC_3BUF(bor, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC_3BUF(bor, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC_3BUF(bor, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC_3BUF(bor, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC_3BUF(bor, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC_3BUF(bor, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC_3BUF(bor, fortran_integer16, ompi_fortran_integer16_t) #endif /* Byte */ FUNC_FUNC_3BUF(bor, byte, char) @@ -1257,23 +1257,23 @@ FUNC_FUNC_3BUF(bxor, long_long_int, long long int) FUNC_FUNC_3BUF(bxor, unsigned_long_long, unsigned long long) #endif /* Fortran integer */ -#if OPAL_HAVE_FORTRAN_INTEGER -FUNC_FUNC_3BUF(bxor, fortran_integer, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +FUNC_FUNC_3BUF(bxor, fortran_integer, ompi_fortran_integer_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER1 -FUNC_FUNC_3BUF(bxor, fortran_integer1, opal_fortran_integer1_t) +#if OMPI_HAVE_FORTRAN_INTEGER1 +FUNC_FUNC_3BUF(bxor, fortran_integer1, ompi_fortran_integer1_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER2 -FUNC_FUNC_3BUF(bxor, fortran_integer2, opal_fortran_integer2_t) +#if OMPI_HAVE_FORTRAN_INTEGER2 +FUNC_FUNC_3BUF(bxor, fortran_integer2, ompi_fortran_integer2_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER4 -FUNC_FUNC_3BUF(bxor, fortran_integer4, opal_fortran_integer4_t) +#if OMPI_HAVE_FORTRAN_INTEGER4 +FUNC_FUNC_3BUF(bxor, fortran_integer4, ompi_fortran_integer4_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER8 -FUNC_FUNC_3BUF(bxor, fortran_integer8, opal_fortran_integer8_t) +#if OMPI_HAVE_FORTRAN_INTEGER8 +FUNC_FUNC_3BUF(bxor, fortran_integer8, ompi_fortran_integer8_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER16 -FUNC_FUNC_3BUF(bxor, fortran_integer16, opal_fortran_integer16_t) +#if OMPI_HAVE_FORTRAN_INTEGER16 +FUNC_FUNC_3BUF(bxor, fortran_integer16, ompi_fortran_integer16_t) #endif /* Byte */ FUNC_FUNC_3BUF(bxor, byte, char) @@ -1283,14 +1283,14 @@ FUNC_FUNC_3BUF(bxor, byte, char) *************************************************************************/ /* -#if OPAL_HAVE_FORTRAN_REAL -LOC_STRUCT_3BUF(2real, opal_fortran_real_t, opal_fortran_real_t) +#if OMPI_HAVE_FORTRAN_REAL +LOC_STRUCT_3BUF(2real, ompi_fortran_real_t, ompi_fortran_real_t) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION -LOC_STRUCT_3BUF(2double_precision, opal_fortran_double_precision_t, opal_fortran_double_precision_t) +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION +LOC_STRUCT_3BUF(2double_precision, ompi_fortran_double_precision_t, ompi_fortran_double_precision_t) #endif -#if OPAL_HAVE_FORTRAN_INTEGER -LOC_STRUCT_3BUF(2integer, opal_fortran_integer_t, opal_fortran_integer_t) +#if OMPI_HAVE_FORTRAN_INTEGER +LOC_STRUCT_3BUF(2integer, ompi_fortran_integer_t, ompi_fortran_integer_t) #endif LOC_STRUCT_3BUF(float_int, float, int) LOC_STRUCT_3BUF(double_int, double, int) @@ -1306,13 +1306,13 @@ LOC_STRUCT_3BUF(long_double_int, long double, int) * Max location *************************************************************************/ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_HAVE_FORTRAN_REAL LOC_FUNC_3BUF(maxloc, 2real, >) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION LOC_FUNC_3BUF(maxloc, 2double_precision, >) #endif -#if OPAL_HAVE_FORTRAN_INTEGER +#if OMPI_HAVE_FORTRAN_INTEGER LOC_FUNC_3BUF(maxloc, 2integer, >) #endif LOC_FUNC_3BUF(maxloc, float_int, >) @@ -1328,13 +1328,13 @@ LOC_FUNC_3BUF(maxloc, long_double_int, >) * Min location *************************************************************************/ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_HAVE_FORTRAN_REAL LOC_FUNC_3BUF(minloc, 2real, <) #endif -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION LOC_FUNC_3BUF(minloc, 2double_precision, <) #endif -#if OPAL_HAVE_FORTRAN_INTEGER +#if OMPI_HAVE_FORTRAN_INTEGER LOC_FUNC_3BUF(minloc, 2integer, <) #endif LOC_FUNC_3BUF(minloc, float_int, <) @@ -1422,42 +1422,42 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) /** All the Fortran integers ********************************************/ -#if OPAL_HAVE_FORTRAN_INTEGER +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER1 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER2 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER4 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER8 +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER16 +#if OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) /** All the Fortran reals ***********************************************/ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL2 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL4 +#if OMPI_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 OPAL_HAVE_FORTRAN_REAL8 +#if OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) corresponding C type Only then do we put in function pointers for REAL*16 reductions. Otherwise, just put in NULL. */ -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) /** Fortran double precision ********************************************/ -#if OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) /** Fortran logical *****************************************************/ -#if OPAL_HAVE_FORTRAN_LOGICAL +#if OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) /** Fortran complex *****************************************************/ -#if OPAL_HAVE_FORTRAN_REAL && OPAL_HAVE_FORTRAN_COMPLEX +#if OMPI_HAVE_FORTRAN_REAL && OMPI_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 OPAL_HAVE_FORTRAN_DOUBLE_PRECISION && OPAL_HAVE_FORTRAN_COMPLEX +#if OMPI_HAVE_FORTRAN_DOUBLE_PRECISION && OMPI_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 OPAL_HAVE_FORTRAN_REAL4 && OPAL_HAVE_FORTRAN_COMPLEX8 +#if OMPI_HAVE_FORTRAN_REAL4 && OMPI_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 OPAL_HAVE_FORTRAN_REAL8 && OPAL_HAVE_FORTRAN_COMPLEX16 +#if OMPI_HAVE_FORTRAN_REAL8 && OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) - we have fortran COMPILEX*32 Only then do we put in function pointers for COMPLEX*32 reductions. Otherwise, just put in NULL. */ -#if OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C && OPAL_HAVE_FORTRAN_COMPLEX32 +#if OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C && OMPI_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 @@ LOC_FUNC_3BUF(minloc, long_double_int, <) /** Fortran complex *****************************************************/ /** Fortran "2" types ***************************************************/ -#if OPAL_HAVE_FORTRAN_REAL +#if OMPI_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 OPAL_HAVE_FORTRAN_DOUBLE_PRECISION +#if OMPI_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 OPAL_HAVE_FORTRAN_INTEGER +#if OMPI_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 diff --git a/ompi/mca/osc/base/osc_base_obj_convert.c b/ompi/mca/osc/base/osc_base_obj_convert.c index d04c59cb46..01b744c6a6 100644 --- a/ompi/mca/osc/base/osc_base_obj_convert.c +++ b/ompi/mca/osc/base/osc_base_obj_convert.c @@ -149,13 +149,13 @@ static conversion_fct_t ompi_osc_base_copy_functions[DT_MAX_PREDEFINED] = { #else (conversion_fct_t)NULL, /* DT_CXX_BOOL */ #endif -#if OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_CHAR +#if OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_CHAR (conversion_fct_t)copy_char, /* DT_LOGIC */ -#elif OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_SHORT +#elif OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_SHORT (conversion_fct_t)copy_short, /* DT_LOGIC */ -#elif OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT +#elif OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT (conversion_fct_t)copy_int, /* DT_LOGIC */ -#elif OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_LONG +#elif OMPI_SIZEOF_FORTRAN_LOGICAL == SIZEOF_LONG (conversion_fct_t)copy_long, /* DT_LOGIC */ #else (conversion_fct_t)NULL, /* DT_LOGIC */ diff --git a/ompi/mpi/c/type_create_f90_integer.c b/ompi/mpi/c/type_create_f90_integer.c index 769bbbfb5f..1bfac2fd1d 100644 --- a/ompi/mpi/c/type_create_f90_integer.c +++ b/ompi/mpi/c/type_create_f90_integer.c @@ -60,11 +60,11 @@ int MPI_Type_create_f90_integer(int r, MPI_Datatype *newtype) */ if (r > 38) *newtype = &ompi_mpi_datatype_null.dt; -#if OPAL_HAVE_F90_INTEGER16 +#if OMPI_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 /* OPAL_HAVE_F90_INTEGER16 */ +#endif /* OMPI_HAVE_F90_INTEGER16 */ #if SIZEOF_LONG > SIZEOF_INT else if (r > 9) *newtype = &ompi_mpi_long.dt; #else diff --git a/ompi/mpi/f77/base/attr_fn_f.c b/ompi/mpi/f77/base/attr_fn_f.c index 6383dec0c0..7d9e230273 100644 --- a/ompi/mpi/f77/base/attr_fn_f.c +++ b/ompi/mpi/f77/base/attr_fn_f.c @@ -85,14 +85,14 @@ OMPI_GENERATE_F77_BINDINGS( MPI_TYPE_NULL_COPY_FN, 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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 @@ OMPI_GENERATE_F77_BINDINGS( MPI_COMM_NULL_COPY_FN, 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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 @@ OMPI_GENERATE_F77_BINDINGS( MPI_NULL_COPY_FN, 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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 @@ OMPI_GENERATE_F77_BINDINGS( MPI_WIN_NULL_COPY_FN, 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, MPI_Flogical* 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, ompi_fortran_logical_t* 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, MPI_Flogical* 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, ompi_fortran_logical_t* flag, MPI_Fint* ierr), (window, win_keyval, extra_state, attribute_val_in, attribute_val_out, flag, ierr) ) #endif @@ -194,9 +194,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr) + ompi_fortran_logical_t* flag, MPI_Fint* ierr) { - *flag = (MPI_Flogical) 0; + *flag = (ompi_fortran_logical_t) 0; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -204,9 +204,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 1; + *flag = (ompi_fortran_logical_t) 1; *attribute_val_out = *attribute_val_in; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -222,9 +222,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 0; + *flag = (ompi_fortran_logical_t) 0; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -232,9 +232,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 1; + *flag = (ompi_fortran_logical_t) 1; *attribute_val_out = *attribute_val_in; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -250,9 +250,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 0; + *flag = (ompi_fortran_logical_t) 0; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -261,9 +261,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 1; + *flag = (ompi_fortran_logical_t) 1; *attribute_val_out = *attribute_val_in; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -279,9 +279,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 0; + *flag = (ompi_fortran_logical_t) 0; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } @@ -289,9 +289,9 @@ void 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, - MPI_Flogical* flag, MPI_Fint* ierr ) + ompi_fortran_logical_t* flag, MPI_Fint* ierr ) { - *flag = (MPI_Flogical) 1; + *flag = (ompi_fortran_logical_t) 1; *attribute_val_out = *attribute_val_in; *ierr = OMPI_INT_2_FINT(MPI_SUCCESS); } diff --git a/ompi/mpi/f77/file_read_all_end_f.c b/ompi/mpi/f77/file_read_all_end_f.c index 9eb64f965f..626966cce9 100644 --- a/ompi/mpi/f77/file_read_all_end_f.c +++ b/ompi/mpi/f77/file_read_all_end_f.c @@ -62,7 +62,7 @@ void mpi_file_read_all_end_f(MPI_Fint *fh, char *buf, MPI_Fint *status, MPI_Fint *ierr) { MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif MPI_File c_fh = MPI_File_f2c(*fh); @@ -77,7 +77,7 @@ void mpi_file_read_all_end_f(MPI_Fint *fh, char *buf, MPI_Fint *status, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -86,7 +86,7 @@ void mpi_file_read_all_end_f(MPI_Fint *fh, char *buf, MPI_Fint *status, *ierr = OMPI_INT_2_FINT(MPI_File_read_all_end(c_fh, buf, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_all_f.c b/ompi/mpi/f77/file_read_all_f.c index 56342d4644..cea7b83549 100644 --- a/ompi/mpi/f77/file_read_all_f.c +++ b/ompi/mpi/f77/file_read_all_f.c @@ -64,7 +64,7 @@ void mpi_file_read_all_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -76,7 +76,7 @@ void mpi_file_read_all_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -87,7 +87,7 @@ void mpi_file_read_all_f(MPI_Fint *fh, char *buf, MPI_Fint *count, OMPI_FINT_2_INT(*count), c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_at_all_end_f.c b/ompi/mpi/f77/file_read_at_all_end_f.c index 40328c9320..946fba33dc 100644 --- a/ompi/mpi/f77/file_read_at_all_end_f.c +++ b/ompi/mpi/f77/file_read_at_all_end_f.c @@ -63,7 +63,7 @@ void mpi_file_read_at_all_end_f(MPI_Fint *fh, char *buf, { MPI_File c_fh = MPI_File_f2c(*fh); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_read_at_all_end_f(MPI_Fint *fh, char *buf, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -86,7 +86,7 @@ void mpi_file_read_at_all_end_f(MPI_Fint *fh, char *buf, *ierr = OMPI_FINT_2_INT(MPI_File_read_at_all_end(c_fh, buf, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_at_all_f.c b/ompi/mpi/f77/file_read_at_all_f.c index f3286e6f98..9b7ee7e50b 100644 --- a/ompi/mpi/f77/file_read_at_all_f.c +++ b/ompi/mpi/f77/file_read_at_all_f.c @@ -67,7 +67,7 @@ void mpi_file_read_at_all_f(MPI_Fint *fh, MPI_Offset *offset, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -79,7 +79,7 @@ void mpi_file_read_at_all_f(MPI_Fint *fh, MPI_Offset *offset, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -93,7 +93,7 @@ void mpi_file_read_at_all_f(MPI_Fint *fh, MPI_Offset *offset, c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_at_f.c b/ompi/mpi/f77/file_read_at_f.c index b35fd3ec97..9c80ed2fc9 100644 --- a/ompi/mpi/f77/file_read_at_f.c +++ b/ompi/mpi/f77/file_read_at_f.c @@ -66,7 +66,7 @@ void mpi_file_read_at_f(MPI_Fint *fh, MPI_Offset *offset, char *buf, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -80,7 +80,7 @@ void mpi_file_read_at_f(MPI_Fint *fh, MPI_Offset *offset, char *buf, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -93,7 +93,7 @@ void mpi_file_read_at_f(MPI_Fint *fh, MPI_Offset *offset, char *buf, OMPI_FINT_2_INT(*count), c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_f.c b/ompi/mpi/f77/file_read_f.c index 17c6c14d5c..7aec4f48d4 100644 --- a/ompi/mpi/f77/file_read_f.c +++ b/ompi/mpi/f77/file_read_f.c @@ -65,7 +65,7 @@ void mpi_file_read_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_read_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -88,7 +88,7 @@ void mpi_file_read_f(MPI_Fint *fh, char *buf, MPI_Fint *count, OMPI_FINT_2_INT(*count), c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_ordered_end_f.c b/ompi/mpi/f77/file_read_ordered_end_f.c index adc1357409..0097057a78 100644 --- a/ompi/mpi/f77/file_read_ordered_end_f.c +++ b/ompi/mpi/f77/file_read_ordered_end_f.c @@ -64,7 +64,7 @@ void mpi_file_read_ordered_end_f(MPI_Fint *fh, char *buf, { MPI_File c_fh = MPI_File_f2c(*fh); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -78,7 +78,7 @@ void mpi_file_read_ordered_end_f(MPI_Fint *fh, char *buf, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -87,7 +87,7 @@ void mpi_file_read_ordered_end_f(MPI_Fint *fh, char *buf, *ierr = OMPI_INT_2_FINT(MPI_File_read_ordered_end(c_fh, buf, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_ordered_f.c b/ompi/mpi/f77/file_read_ordered_f.c index 8906f4b414..ca948f7df3 100644 --- a/ompi/mpi/f77/file_read_ordered_f.c +++ b/ompi/mpi/f77/file_read_ordered_f.c @@ -65,7 +65,7 @@ void mpi_file_read_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_read_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -90,7 +90,7 @@ void mpi_file_read_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_read_shared_f.c b/ompi/mpi/f77/file_read_shared_f.c index 9c6d88ed24..ea0e2af1b9 100644 --- a/ompi/mpi/f77/file_read_shared_f.c +++ b/ompi/mpi/f77/file_read_shared_f.c @@ -65,7 +65,7 @@ void mpi_file_read_shared_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_read_shared_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -90,7 +90,7 @@ void mpi_file_read_shared_f(MPI_Fint *fh, char *buf, MPI_Fint *count, c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_all_end_f.c b/ompi/mpi/f77/file_write_all_end_f.c index 5b8a75999a..de83d1ae6a 100644 --- a/ompi/mpi/f77/file_write_all_end_f.c +++ b/ompi/mpi/f77/file_write_all_end_f.c @@ -62,7 +62,7 @@ void mpi_file_write_all_end_f(MPI_Fint *fh, char *buf, MPI_Fint *status, MPI_Fint *ierr) { MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif MPI_File c_fh = MPI_File_f2c(*fh); @@ -77,7 +77,7 @@ void mpi_file_write_all_end_f(MPI_Fint *fh, char *buf, MPI_Fint *status, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -86,7 +86,7 @@ void mpi_file_write_all_end_f(MPI_Fint *fh, char *buf, MPI_Fint *status, *ierr = OMPI_INT_2_FINT(MPI_File_write_all_end(c_fh, buf, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_all_f.c b/ompi/mpi/f77/file_write_all_f.c index 200e3de0ba..0a4070d979 100644 --- a/ompi/mpi/f77/file_write_all_f.c +++ b/ompi/mpi/f77/file_write_all_f.c @@ -64,7 +64,7 @@ void mpi_file_write_all_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -76,7 +76,7 @@ void mpi_file_write_all_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -87,7 +87,7 @@ void mpi_file_write_all_f(MPI_Fint *fh, char *buf, MPI_Fint *count, OMPI_FINT_2_INT(*count), c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_at_all_end_f.c b/ompi/mpi/f77/file_write_at_all_end_f.c index bbfa4ba54d..884b8e200f 100644 --- a/ompi/mpi/f77/file_write_at_all_end_f.c +++ b/ompi/mpi/f77/file_write_at_all_end_f.c @@ -63,7 +63,7 @@ void mpi_file_write_at_all_end_f(MPI_Fint *fh, char *buf, { MPI_File c_fh = MPI_File_f2c(*fh); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_write_at_all_end_f(MPI_Fint *fh, char *buf, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -86,7 +86,7 @@ void mpi_file_write_at_all_end_f(MPI_Fint *fh, char *buf, *ierr = OMPI_FINT_2_INT(MPI_File_write_at_all_end(c_fh, buf, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_at_all_f.c b/ompi/mpi/f77/file_write_at_all_f.c index 9d06ceba85..412cd2e8c8 100644 --- a/ompi/mpi/f77/file_write_at_all_f.c +++ b/ompi/mpi/f77/file_write_at_all_f.c @@ -66,7 +66,7 @@ void mpi_file_write_at_all_f(MPI_Fint *fh, MPI_Offset *offset, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -78,7 +78,7 @@ void mpi_file_write_at_all_f(MPI_Fint *fh, MPI_Offset *offset, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -92,7 +92,7 @@ void mpi_file_write_at_all_f(MPI_Fint *fh, MPI_Offset *offset, c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_at_f.c b/ompi/mpi/f77/file_write_at_f.c index c5ea665349..a88485189f 100644 --- a/ompi/mpi/f77/file_write_at_f.c +++ b/ompi/mpi/f77/file_write_at_f.c @@ -64,7 +64,7 @@ void mpi_file_write_at_f(MPI_Fint *fh, MPI_Offset *offset, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -76,7 +76,7 @@ void mpi_file_write_at_f(MPI_Fint *fh, MPI_Offset *offset, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -89,7 +89,7 @@ void mpi_file_write_at_f(MPI_Fint *fh, MPI_Offset *offset, OMPI_FINT_2_INT(*count), c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_f.c b/ompi/mpi/f77/file_write_f.c index 831b21f797..4c25d9a176 100644 --- a/ompi/mpi/f77/file_write_f.c +++ b/ompi/mpi/f77/file_write_f.c @@ -64,7 +64,7 @@ void mpi_file_write_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -76,7 +76,7 @@ void mpi_file_write_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -87,7 +87,7 @@ void mpi_file_write_f(MPI_Fint *fh, char *buf, MPI_Fint *count, OMPI_FINT_2_INT(*count), c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_ordered_end_f.c b/ompi/mpi/f77/file_write_ordered_end_f.c index c48a754da2..1935c9c1f2 100644 --- a/ompi/mpi/f77/file_write_ordered_end_f.c +++ b/ompi/mpi/f77/file_write_ordered_end_f.c @@ -63,7 +63,7 @@ void mpi_file_write_ordered_end_f(MPI_Fint *fh, char *buf, { MPI_File c_fh = MPI_File_f2c(*fh); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_write_ordered_end_f(MPI_Fint *fh, char *buf, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -86,7 +86,7 @@ void mpi_file_write_ordered_end_f(MPI_Fint *fh, char *buf, *ierr = OMPI_INT_2_FINT(MPI_File_write_ordered_end(c_fh, buf, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_ordered_f.c b/ompi/mpi/f77/file_write_ordered_f.c index fddf767eed..a299c77da0 100644 --- a/ompi/mpi/f77/file_write_ordered_f.c +++ b/ompi/mpi/f77/file_write_ordered_f.c @@ -65,7 +65,7 @@ void mpi_file_write_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_write_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -90,7 +90,7 @@ void mpi_file_write_ordered_f(MPI_Fint *fh, char *buf, MPI_Fint *count, c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/file_write_shared_f.c b/ompi/mpi/f77/file_write_shared_f.c index e13744d474..169b3bf348 100644 --- a/ompi/mpi/f77/file_write_shared_f.c +++ b/ompi/mpi/f77/file_write_shared_f.c @@ -65,7 +65,7 @@ void mpi_file_write_shared_f(MPI_Fint *fh, char *buf, MPI_Fint *count, MPI_File c_fh = MPI_File_f2c(*fh); MPI_Datatype c_type = MPI_Type_f2c(*datatype); MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -77,7 +77,7 @@ void mpi_file_write_shared_f(MPI_Fint *fh, char *buf, MPI_Fint *count, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -90,7 +90,7 @@ void mpi_file_write_shared_f(MPI_Fint *fh, char *buf, MPI_Fint *count, c_type, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/fint_2_int.h b/ompi/mpi/f77/fint_2_int.h index 05c452e0c8..bb3b9d84ee 100644 --- a/ompi/mpi/f77/fint_2_int.h +++ b/ompi/mpi/f77/fint_2_int.h @@ -27,7 +27,7 @@ * Define MACROS to take account of different size of MPI_Fint from int */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_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 OPAL_SIZEOF_FORTRAN_INTEGER > SIZEOF_INT +#elif OMPI_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 OPAL_SIZEOF_FORTRAN_LOGICAL == SIZEOF_INT +#if OMPI_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 OPAL_FORTRAN_VALUE_TRUE == 1 +# if OMPI_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 : OPAL_FORTRAN_VALUE_TRUE) +# define OMPI_INT_2_LOGICAL(a) ((a)==0? 0 : OMPI_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 OPAL_FORTRAN_VALUE_TRUE == 1 +# if OMPI_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 : OPAL_FORTRAN_VALUE_TRUE) +# define OMPI_INT_2_LOGICAL(a) ((a)==0? 0 : OMPI_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 /* OPAL_SIZEOF_FORTRAN_LOGICAL */ +#endif /* OMPI_SIZEOF_FORTRAN_LOGICAL */ #endif /* OMPI_FINT_2_INT_H */ diff --git a/ompi/mpi/f77/iprobe_f.c b/ompi/mpi/f77/iprobe_f.c index 640de942b5..939d259af8 100644 --- a/ompi/mpi/f77/iprobe_f.c +++ b/ompi/mpi/f77/iprobe_f.c @@ -64,7 +64,7 @@ void mpi_iprobe_f(MPI_Fint *source, MPI_Fint *tag, MPI_Fint *comm, { MPI_Status *c_status; MPI_Comm c_comm; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif OMPI_LOGICAL_NAME_DECL(flag); @@ -80,7 +80,7 @@ void mpi_iprobe_f(MPI_Fint *source, MPI_Fint *tag, MPI_Fint *comm, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -93,7 +93,7 @@ void mpi_iprobe_f(MPI_Fint *source, MPI_Fint *tag, MPI_Fint *comm, c_status)); if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr)) { OMPI_SINGLE_INT_2_LOGICAL(flag); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); } diff --git a/ompi/mpi/f77/probe_f.c b/ompi/mpi/f77/probe_f.c index e0740d50d6..febd0b51e4 100644 --- a/ompi/mpi/f77/probe_f.c +++ b/ompi/mpi/f77/probe_f.c @@ -63,7 +63,7 @@ void mpi_probe_f(MPI_Fint *source, MPI_Fint *tag, MPI_Fint *comm, MPI_Fint *stat { MPI_Status *c_status; MPI_Comm c_comm; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif @@ -78,7 +78,7 @@ void mpi_probe_f(MPI_Fint *source, MPI_Fint *tag, MPI_Fint *comm, MPI_Fint *stat translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -89,7 +89,7 @@ void mpi_probe_f(MPI_Fint *source, MPI_Fint *tag, MPI_Fint *comm, MPI_Fint *stat OMPI_FINT_2_INT(*tag), c_comm, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/recv_f.c b/ompi/mpi/f77/recv_f.c index 808883d6bd..3c60d30a28 100644 --- a/ompi/mpi/f77/recv_f.c +++ b/ompi/mpi/f77/recv_f.c @@ -64,7 +64,7 @@ void mpi_recv_f(char *buf, MPI_Fint *count, MPI_Fint *datatype, MPI_Fint *status, MPI_Fint *ierr) { MPI_Status *c_status; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT MPI_Status c_status2; #endif MPI_Comm c_comm = MPI_Comm_f2c(*comm); @@ -78,7 +78,7 @@ void mpi_recv_f(char *buf, MPI_Fint *count, MPI_Fint *datatype, translation necessary -- let the underlying functions write directly into the Fortran status */ -#if OPAL_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER == SIZEOF_INT c_status = (MPI_Status *) status; #else c_status = &c_status2; @@ -90,7 +90,7 @@ void mpi_recv_f(char *buf, MPI_Fint *count, MPI_Fint *datatype, c_type, OMPI_FINT_2_INT(*source), OMPI_FINT_2_INT(*tag), c_comm, c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT if (MPI_SUCCESS == OMPI_FINT_2_INT(*ierr) && MPI_STATUS_IGNORE != c_status) { MPI_Status_c2f(c_status, status); diff --git a/ompi/mpi/f77/testsome_f.c b/ompi/mpi/f77/testsome_f.c index f5f431eaf9..e816b64174 100644 --- a/ompi/mpi/f77/testsome_f.c +++ b/ompi/mpi/f77/testsome_f.c @@ -71,7 +71,7 @@ void mpi_testsome_f(MPI_Fint *incount, MPI_Fint *array_of_requests, MPI_Request *c_req; MPI_Status *c_status; int i; -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT int int_c; #endif OMPI_SINGLE_NAME_DECL(outcount); @@ -97,7 +97,7 @@ void mpi_testsome_f(MPI_Fint *incount, MPI_Fint *array_of_requests, OMPI_ARRAY_NAME_CONVERT(array_of_indices), c_status)); -#if OPAL_SIZEOF_FORTRAN_INTEGER != SIZEOF_INT +#if OMPI_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); diff --git a/ompi/mpi/f90/fortran_sizes.h.in b/ompi/mpi/f90/fortran_sizes.h.in index dfd7a1b45c..340d4befe8 100644 --- a/ompi/mpi/f90/fortran_sizes.h.in +++ b/ompi/mpi/f90/fortran_sizes.h.in @@ -19,36 +19,36 @@ ! This file is used by scripts/mpi_sizeof.f90.sh (and therefore mpi_sizeof.f90) -integer :: OPAL_SIZEOF_F90_LOGICAL +integer :: OMPI_SIZEOF_F90_LOGICAL -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 :: 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 :: OPAL_SIZEOF_F90_REAL2 -integer :: OPAL_SIZEOF_F90_REAL4 -integer :: OPAL_SIZEOF_F90_REAL8 -integer :: OPAL_SIZEOF_F90_REAL16 +integer :: OMPI_SIZEOF_F90_REAL2 +integer :: OMPI_SIZEOF_F90_REAL4 +integer :: OMPI_SIZEOF_F90_REAL8 +integer :: OMPI_SIZEOF_F90_REAL16 -integer :: OPAL_SIZEOF_F90_COMPLEX8 -integer :: OPAL_SIZEOF_F90_COMPLEX16 -integer :: OPAL_SIZEOF_F90_COMPLEX32 +integer :: OMPI_SIZEOF_F90_COMPLEX8 +integer :: OMPI_SIZEOF_F90_COMPLEX16 +integer :: OMPI_SIZEOF_F90_COMPLEX32 -parameter(OPAL_SIZEOF_F90_LOGICAL = @OPAL_SIZEOF_F90_LOGICAL@) +parameter(OMPI_SIZEOF_F90_LOGICAL = @OMPI_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(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(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(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(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@) +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@) diff --git a/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh b/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh index fada803b01..650bffd862 100755 --- a/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh +++ b/ompi/mpi/f90/scripts/mpi_sizeof.f90.sh @@ -32,7 +32,7 @@ do echo " logical*${kind}, intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_LOGICAL${kind}" + echo " size = OMPI_SIZEOF_F90_LOGICAL${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -47,7 +47,7 @@ do echo " integer*${kind}, intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_INT${kind}" + echo " size = OMPI_SIZEOF_F90_INT${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -62,7 +62,7 @@ do echo " real*${kind}, intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_REAL${kind}" + echo " size = OMPI_SIZEOF_F90_REAL${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -77,7 +77,7 @@ do echo " complex*${kind}, intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_COMPLEX${kind}" + echo " size = OMPI_SIZEOF_F90_COMPLEX${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -103,7 +103,7 @@ do echo " logical*${kind}, dimension(${dim}), intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_LOGICAL${kind}" + echo " size = OMPI_SIZEOF_F90_LOGICAL${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -118,7 +118,7 @@ do echo " integer*${kind}, dimension(${dim}), intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_INT${kind}" + echo " size = OMPI_SIZEOF_F90_INT${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -133,7 +133,7 @@ do echo " real*${kind}, dimension(${dim}), intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_REAL${kind}" + echo " size = OMPI_SIZEOF_F90_REAL${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo @@ -148,7 +148,7 @@ do echo " complex*${kind}, dimension(${dim}), intent(in) :: x" echo " integer, intent(out) :: size" echo " integer, intent(out) :: ierr" - echo " size = OPAL_SIZEOF_F90_COMPLEX${kind}" + echo " size = OMPI_SIZEOF_F90_COMPLEX${kind}" echo " ierr = 0" echo "end subroutine ${proc}" echo diff --git a/ompi/request/request.c b/ompi/request/request.c index a4e16a9192..7d5ef32c5c 100644 --- a/ompi/request/request.c +++ b/ompi/request/request.c @@ -103,7 +103,7 @@ int ompi_request_init(void) 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, OPAL_FORTRAN_HANDLE_MAX, 64) ) { + 0, OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } ompi_request_null.request.req_type = OMPI_REQUEST_NULL; diff --git a/ompi/tools/ompi_info/param.cc b/ompi/tools/ompi_info/param.cc index 9bd72455b5..968d3c498d 100644 --- a/ompi/tools/ompi_info/param.cc +++ b/ompi/tools/ompi_info/param.cc @@ -584,10 +584,10 @@ void ompi_info::do_config(bool want_all) 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", OPAL_ALIGNMENT_CXX_BOOL); + out("C bool align", "compiler:c:align:bool", OMPI_ALIGNMENT_CXX_BOOL); out("C int align", "compiler:c:align:int", OPAL_ALIGNMENT_INT); - out("C float align", "compiler:c:align:float", OPAL_ALIGNMENT_FLOAT); - out("C double align", "compiler:c:align:double", OPAL_ALIGNMENT_DOUBLE); + out("C float align", "compiler:c:align:float", OMPI_ALIGNMENT_FLOAT); + out("C double align", "compiler:c:align:double", OMPI_ALIGNMENT_DOUBLE); } out("C++ compiler", "compiler:cxx:command", OMPI_CXX); @@ -605,115 +605,115 @@ void ompi_info::do_config(bool want_all) // Will always have the size of Fortran integer out("Fort integer size", "compiler:fortran:sizeof:integer", - OPAL_SIZEOF_FORTRAN_INTEGER); + OMPI_SIZEOF_FORTRAN_INTEGER); out("Fort logical size", "compiler:fortran:sizeof:logical", - OPAL_SIZEOF_FORTRAN_LOGICAL); + OMPI_SIZEOF_FORTRAN_LOGICAL); out("Fort logical value true", "compiler:fortran:value:true", - OPAL_FORTRAN_VALUE_TRUE); + OMPI_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", - OPAL_HAVE_FORTRAN_INTEGER1 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_INTEGER1 ? "yes" : "no"); out("Fort have integer2", "compiler:fortran:have:integer2", - OPAL_HAVE_FORTRAN_INTEGER2 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_INTEGER2 ? "yes" : "no"); out("Fort have integer4", "compiler:fortran:have:integer4", - OPAL_HAVE_FORTRAN_INTEGER4 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_INTEGER4 ? "yes" : "no"); out("Fort have integer8", "compiler:fortran:have:integer8", - OPAL_HAVE_FORTRAN_INTEGER8 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_INTEGER8 ? "yes" : "no"); out("Fort have integer16", "compiler:fortran:have:integer16", - OPAL_HAVE_FORTRAN_INTEGER16 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_INTEGER16 ? "yes" : "no"); out("Fort have real4", "compiler:fortran:have:real4", - OPAL_HAVE_FORTRAN_REAL4 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_REAL4 ? "yes" : "no"); out("Fort have real8", "compiler:fortran:have:real8", - OPAL_HAVE_FORTRAN_REAL8 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_REAL8 ? "yes" : "no"); out("Fort have real16", "compiler:fortran:have:real16", - OPAL_HAVE_FORTRAN_REAL16 && OPAL_REAL16_MATCHES_C ? "yes" : "no"); + OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C ? "yes" : "no"); out("Fort have complex8", "compiler:fortran:have:complex8", - OPAL_HAVE_FORTRAN_COMPLEX8 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_COMPLEX8 ? "yes" : "no"); out("Fort have complex16", "compiler:fortran:have:complex16", - OPAL_HAVE_FORTRAN_COMPLEX16 ? "yes" : "no"); + OMPI_HAVE_FORTRAN_COMPLEX16 ? "yes" : "no"); out("Fort have complex32", "compiler:fortran:have:complex32", - OPAL_HAVE_FORTRAN_COMPLEX32 && OPAL_REAL16_MATCHES_C ? "yes" : "no"); + OMPI_HAVE_FORTRAN_COMPLEX32 && OMPI_REAL16_MATCHES_C ? "yes" : "no"); out("Fort integer1 size", "compiler:fortran:sizeof:integer1", - OPAL_HAVE_FORTRAN_INTEGER1 ? OPAL_SIZEOF_FORTRAN_INTEGER1 : -1); + OMPI_HAVE_FORTRAN_INTEGER1 ? OMPI_SIZEOF_FORTRAN_INTEGER1 : -1); out("Fort integer2 size", "compiler:fortran:sizeof:integer2", - OPAL_HAVE_FORTRAN_INTEGER2 ? OPAL_SIZEOF_FORTRAN_INTEGER2 : -1); + OMPI_HAVE_FORTRAN_INTEGER2 ? OMPI_SIZEOF_FORTRAN_INTEGER2 : -1); out("Fort integer4 size", "compiler:fortran:sizeof:integer4", - OPAL_HAVE_FORTRAN_INTEGER4 ? OPAL_SIZEOF_FORTRAN_INTEGER4 : -1); + OMPI_HAVE_FORTRAN_INTEGER4 ? OMPI_SIZEOF_FORTRAN_INTEGER4 : -1); out("Fort integer8 size", "compiler:fortran:sizeof:integer8", - OPAL_HAVE_FORTRAN_INTEGER8 ? OPAL_SIZEOF_FORTRAN_INTEGER8 : -1); + OMPI_HAVE_FORTRAN_INTEGER8 ? OMPI_SIZEOF_FORTRAN_INTEGER8 : -1); out("Fort integer16 size", "compiler:fortran:sizeof:integer17", - OPAL_HAVE_FORTRAN_INTEGER16 ? OPAL_SIZEOF_FORTRAN_INTEGER16 : -1); + OMPI_HAVE_FORTRAN_INTEGER16 ? OMPI_SIZEOF_FORTRAN_INTEGER16 : -1); out("Fort real size", "compiler:fortran:sizeof:real", - OPAL_SIZEOF_FORTRAN_REAL); + OMPI_SIZEOF_FORTRAN_REAL); out("Fort real4 size", "compiler:fortran:sizeof:real4", - OPAL_HAVE_FORTRAN_REAL4 ? OPAL_SIZEOF_FORTRAN_REAL4 : -1); + OMPI_HAVE_FORTRAN_REAL4 ? OMPI_SIZEOF_FORTRAN_REAL4 : -1); out("Fort real8 size", "compiler:fortran:sizeof:real8", - OPAL_HAVE_FORTRAN_REAL8 ? OPAL_SIZEOF_FORTRAN_REAL8 : -1); + OMPI_HAVE_FORTRAN_REAL8 ? OMPI_SIZEOF_FORTRAN_REAL8 : -1); out("Fort real16 size", "compiler:fortran:sizeof:real17", - OPAL_HAVE_FORTRAN_REAL16 ? OPAL_SIZEOF_FORTRAN_REAL16 : -1); + OMPI_HAVE_FORTRAN_REAL16 ? OMPI_SIZEOF_FORTRAN_REAL16 : -1); out("Fort dbl prec size", "compiler:fortran:sizeof:double_precision", - OPAL_SIZEOF_FORTRAN_REAL); + OMPI_SIZEOF_FORTRAN_REAL); out("Fort cplx size", "compiler:fortran:sizeof:complex", - OPAL_SIZEOF_FORTRAN_REAL); + OMPI_SIZEOF_FORTRAN_REAL); out("Fort dbl cplx size", "compiler:fortran:sizeof:double_complex", - OPAL_SIZEOF_FORTRAN_REAL); + OMPI_SIZEOF_FORTRAN_REAL); out("Fort cplx8 size", "compiler:fortran:sizeof:complex8", - OPAL_HAVE_FORTRAN_COMPLEX8 ? OPAL_SIZEOF_FORTRAN_COMPLEX8 : -1); + OMPI_HAVE_FORTRAN_COMPLEX8 ? OMPI_SIZEOF_FORTRAN_COMPLEX8 : -1); out("Fort cplx16 size", "compiler:fortran:sizeof:complex16", - OPAL_HAVE_FORTRAN_COMPLEX16 ? OPAL_SIZEOF_FORTRAN_COMPLEX16 : -1); + OMPI_HAVE_FORTRAN_COMPLEX16 ? OMPI_SIZEOF_FORTRAN_COMPLEX16 : -1); out("Fort cplx32 size", "compiler:fortran:sizeof:complex32", - OPAL_HAVE_FORTRAN_COMPLEX32 ? OPAL_SIZEOF_FORTRAN_COMPLEX32 : -1); + OMPI_HAVE_FORTRAN_COMPLEX32 ? OMPI_SIZEOF_FORTRAN_COMPLEX32 : -1); out("Fort integer align", "compiler:fortran:align:integer", - OPAL_ALIGNMENT_FORTRAN_INTEGER); + OMPI_ALIGNMENT_FORTRAN_INTEGER); out("Fort integer1 align", "compiler:fortran:align:integer1", - OPAL_HAVE_FORTRAN_INTEGER1 ? OPAL_ALIGNMENT_FORTRAN_INTEGER1 : -1); + OMPI_HAVE_FORTRAN_INTEGER1 ? OMPI_ALIGNMENT_FORTRAN_INTEGER1 : -1); out("Fort integer2 align", "compiler:fortran:align:integer2", - OPAL_HAVE_FORTRAN_INTEGER2 ? OPAL_ALIGNMENT_FORTRAN_INTEGER2 : -1); + OMPI_HAVE_FORTRAN_INTEGER2 ? OMPI_ALIGNMENT_FORTRAN_INTEGER2 : -1); out("Fort integer4 align", "compiler:fortran:align:integer4", - OPAL_HAVE_FORTRAN_INTEGER4 ? OPAL_ALIGNMENT_FORTRAN_INTEGER4 : -1); + OMPI_HAVE_FORTRAN_INTEGER4 ? OMPI_ALIGNMENT_FORTRAN_INTEGER4 : -1); out("Fort integer8 align", "compiler:fortran:align:integer8", - OPAL_HAVE_FORTRAN_INTEGER8 ? OPAL_ALIGNMENT_FORTRAN_INTEGER8 : -1); + OMPI_HAVE_FORTRAN_INTEGER8 ? OMPI_ALIGNMENT_FORTRAN_INTEGER8 : -1); out("Fort integer16 align", "compiler:fortran:align:integer16", - OPAL_HAVE_FORTRAN_INTEGER16 ? OPAL_ALIGNMENT_FORTRAN_INTEGER16 : -1); + OMPI_HAVE_FORTRAN_INTEGER16 ? OMPI_ALIGNMENT_FORTRAN_INTEGER16 : -1); out("Fort real align", "compiler:fortran:align:real", - OPAL_ALIGNMENT_FORTRAN_REAL); + OMPI_ALIGNMENT_FORTRAN_REAL); out("Fort real4 align", "compiler:fortran:align:real4", - OPAL_HAVE_FORTRAN_REAL4 ? OPAL_ALIGNMENT_FORTRAN_REAL4 : -1); + OMPI_HAVE_FORTRAN_REAL4 ? OMPI_ALIGNMENT_FORTRAN_REAL4 : -1); out("Fort real8 align", "compiler:fortran:align:real8", - OPAL_HAVE_FORTRAN_REAL8 ? OPAL_ALIGNMENT_FORTRAN_REAL8 : -1); + OMPI_HAVE_FORTRAN_REAL8 ? OMPI_ALIGNMENT_FORTRAN_REAL8 : -1); out("Fort real16 align", "compiler:fortran:align:real16", - OPAL_HAVE_FORTRAN_REAL16 ? OPAL_ALIGNMENT_FORTRAN_REAL16 : -1); + OMPI_HAVE_FORTRAN_REAL16 ? OMPI_ALIGNMENT_FORTRAN_REAL16 : -1); out("Fort dbl prec align", "compiler:fortran:align:double_precision", - OPAL_ALIGNMENT_FORTRAN_REAL); + OMPI_ALIGNMENT_FORTRAN_REAL); out("Fort cplx align", "compiler:fortran:align:complex", - OPAL_ALIGNMENT_FORTRAN_REAL); + OMPI_ALIGNMENT_FORTRAN_REAL); out("Fort dbl cplx align", "compiler:fortran:align:double_complex", - OPAL_ALIGNMENT_FORTRAN_REAL); + OMPI_ALIGNMENT_FORTRAN_REAL); out("Fort cplx8 align", "compiler:fortran:align:complex8", - OPAL_HAVE_FORTRAN_COMPLEX8 ? OPAL_ALIGNMENT_FORTRAN_COMPLEX8 : -1); + OMPI_HAVE_FORTRAN_COMPLEX8 ? OMPI_ALIGNMENT_FORTRAN_COMPLEX8 : -1); out("Fort cplx16 align", "compiler:fortran:align:complex16", - OPAL_HAVE_FORTRAN_COMPLEX16 ? OPAL_ALIGNMENT_FORTRAN_COMPLEX16 : -1); + OMPI_HAVE_FORTRAN_COMPLEX16 ? OMPI_ALIGNMENT_FORTRAN_COMPLEX16 : -1); out("Fort cplx32 align", "compiler:fortran:align:complex32", - OPAL_HAVE_FORTRAN_COMPLEX32 ? OPAL_ALIGNMENT_FORTRAN_COMPLEX32 : -1); + OMPI_HAVE_FORTRAN_COMPLEX32 ? OMPI_ALIGNMENT_FORTRAN_COMPLEX32 : -1); } else { out("Fort real size", "compiler:fortran:sizeof:real", "skipped"); diff --git a/ompi/win/win.c b/ompi/win/win.c index b81beac805..e0b266063f 100644 --- a/ompi/win/win.c +++ b/ompi/win/win.c @@ -51,7 +51,7 @@ ompi_win_init(void) /* setup window Fortran array */ OBJ_CONSTRUCT(&ompi_mpi_windows, opal_pointer_array_t); if( OPAL_SUCCESS != opal_pointer_array_init(&ompi_mpi_windows, 0, - OPAL_FORTRAN_HANDLE_MAX, 64) ) { + OMPI_FORTRAN_HANDLE_MAX, 64) ) { return OMPI_ERROR; } diff --git a/opal/class/opal_bitmap.c b/opal/class/opal_bitmap.c index 234f318744..b57da83a83 100644 --- a/opal/class/opal_bitmap.c +++ b/opal/class/opal_bitmap.c @@ -133,7 +133,7 @@ opal_bitmap_set_bit(opal_bitmap_t *bm, int bit) new_size = (int) new_size_large; /* - * No further tests against max_size (or OPAL_FORTRAN_HANDLE_MAX) are + * No further tests against max_size (or OMPI_FORTRAN_HANDLE_MAX) are * necessary, since we validated above, that the bit already is contained! */ diff --git a/opal/class/opal_bitmap.h b/opal/class/opal_bitmap.h index 8dc7b70b70..21173cfa98 100644 --- a/opal/class/opal_bitmap.h +++ b/opal/class/opal_bitmap.h @@ -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 - * OPAL_FORTRAN_HANDLE_MAX, which is min(INT_MAX, fortran INTEGER max). + * OMPI_FORTRAN_HANDLE_MAX, which is min(INT_MAX, fortran INTEGER max). * Currently the only user of this is ompi/attribute/attribute.c * */ diff --git a/opal/class/opal_pointer_array.c b/opal/class/opal_pointer_array.c index a5c0713883..827fd6b7a2 100644 --- a/opal/class/opal_pointer_array.c +++ b/opal/class/opal_pointer_array.c @@ -116,7 +116,7 @@ int opal_pointer_array_add(opal_pointer_array_t *table, void *ptr) /* need to grow table */ if (!grow_table(table, (NULL == table->addr ? TABLE_INIT : table->size * TABLE_GROW), - OPAL_FORTRAN_HANDLE_MAX)) { + OMPI_FORTRAN_HANDLE_MAX)) { OPAL_THREAD_UNLOCK(&(table->lock)); return OPAL_ERR_OUT_OF_RESOURCE; } @@ -330,7 +330,7 @@ static bool grow_table(opal_pointer_array_t *table, int soft, int hard) } /* We've already established (above) that the arithmetic - below will be less than OPAL_FORTRAN_HANDLE_MAX */ + below will be less than OMPI_FORTRAN_HANDLE_MAX */ new_size_int = (int) new_size; table->number_free += new_size_int - table->size; diff --git a/opal/include/opal_config_bottom.h b/opal/include/opal_config_bottom.h index 482f308801..e724186d8b 100644 --- a/opal/include/opal_config_bottom.h +++ b/opal/include/opal_config_bottom.h @@ -298,15 +298,15 @@ typedef OPAL_PTRDIFF_TYPE ptrdiff_t; alignment */ # define false 0 # define true 1 -# if SIZEOF_BOOL == SIZEOF_CHAR && OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_CHAR +# if SIZEOF_BOOL == SIZEOF_CHAR && OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_CHAR typedef unsigned char bool; -# elif SIZEOF_BOOL == SIZEOF_SHORT && OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_SHORT +# elif SIZEOF_BOOL == SIZEOF_SHORT && OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_SHORT typedef short bool; -# elif SIZEOF_BOOL == SIZEOF_INT && OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_INT +# elif SIZEOF_BOOL == SIZEOF_INT && OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_INT typedef int bool; -# elif SIZEOF_BOOL == SIZEOF_LONG && OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG +# elif SIZEOF_BOOL == SIZEOF_LONG && OMPI_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG typedef long bool; -# elif defined(SIZEOF_LONG_LONG) && defined(OPAL_ALIGNMENT_LONG) && SIZEOF_BOOL == SIZEOF_LONG && OPAL_ALIGNMENT_CXX_BOOL == OPAL_ALIGNMENT_LONG +# elif defined(SIZEOF_LONG_LONG) && defined(OPAL_ALIGNMENT_LONG) && SIZEOF_BOOL == SIZEOF_LONG && OMPI_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! diff --git a/opal/util/arch.c b/opal/util/arch.c index 8b26c6cf88..f2675f87ed 100644 --- a/opal/util/arch.c +++ b/opal/util/arch.c @@ -49,11 +49,11 @@ int32_t opal_arch_compute_local_id( uint32_t *me ) * placed here to explain the abstraction break and * indicate that it will eventually be fixed */ - if (1 == sizeof(opal_fortran_logical_t) ) { + if (1 == sizeof(ompi_fortran_logical_t) ) { opal_arch_setmask( me, OPAL_ARCH_LOGICALIS8); - } else if (2 == sizeof(opal_fortran_logical_t)) { + } else if (2 == sizeof(ompi_fortran_logical_t)) { opal_arch_setmask( me, OPAL_ARCH_LOGICALIS16); - } else if (4 == sizeof(opal_fortran_logical_t)) { + } else if (4 == sizeof(ompi_fortran_logical_t)) { opal_arch_setmask( me, OPAL_ARCH_LOGICALIS32); }