diff --git a/contrib/platform/win32/CMakeModules/f77_check.cmake b/contrib/platform/win32/CMakeModules/f77_check.cmake
index abebcc6a61..196a99807c 100644
--- a/contrib/platform/win32/CMakeModules/f77_check.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_check.cmake
@@ -9,7 +9,7 @@
 #
 
 
-# OMPI_F77_CHECK(Fortran type, c type required, 
+# OMPI_FORTRAN_CHECK(Fortran type, c type required, 
 #                types to search, expected size)
 #----------------------------------------------------------
 # Check Fortran type, including:
@@ -21,15 +21,15 @@
 #
 # types to search is a list of values
 
-MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
+MACRO(OMPI_FORTRAN_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
 
   STRING(REPLACE "*" "" TYPE_NAME ${FORTRAN_TYPE})
   STRING(REPLACE " " "_" TYPE_NAME ${TYPE_NAME})
   STRING(TOLOWER ${TYPE_NAME} TYPE_NAME_L)
 
-  INCLUDE(F77_check_type)
-  INCLUDE(F77_get_alignment)
-  INCLUDE(F77_get_sizeof)
+  INCLUDE(FORTRAN_check_type)
+  INCLUDE(FORTRAN_get_alignment)
+  INCLUDE(FORTRAN_get_sizeof)
   INCLUDE(ompi_find_type)
 
   SET(ofc_expected_size ${EXPECTED_SIZE})
@@ -38,10 +38,10 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
   SET(ofc_type_alignment ${SIZEOF_INT})
   SET(ofc_c_type ${ompi_fortran_bogus_type_t})
 
-  IF(OMPI_WANT_F77_BINDINGS)
-    IF(NOT DEFINED F77_SETUP_${TYPE_NAME}_DONE)
+  IF(OMPI_WANT_FORTRAN_BINDINGS)
+    IF(NOT DEFINED FORTRAN_SETUP_${TYPE_NAME}_DONE)
 
-    OMPI_F77_CHECK_TYPE(${FORTRAN_TYPE} ofc_have_type)
+    OMPI_FORTRAN_CHECK_TYPE(${FORTRAN_TYPE} ofc_have_type)
 
     IF(ofc_have_type)
       # What is the size of this type?
@@ -57,7 +57,7 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
       # (i.e,. the compiler *might* support that type).  If the size
       # doesn't match the expected size, then the compiler doesn't
       # really support it.
-      OMPI_F77_GET_SIZEOF(${FORTRAN_TYPE} ofc_type_size)
+      OMPI_FORTRAN_GET_SIZEOF(${FORTRAN_TYPE} ofc_type_size)
 
       IF(NOT ${ofc_expected_size} STREQUAL "-1" AND NOT ${ofc_type_size} EQUAL "${ofc_expected_size}")
         MESSAGE(STATUS "*** Fortran 77 ${FORTRAN_TYPE} does not have expected size!")
@@ -71,17 +71,17 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
           OMPI_FIND_TYPE(${FORTRAN_TYPE} "${TYPE_LIST}" ${C_TYPE} ${ofc_type_size} ofc_c_type)
         ENDIF(NOT "${TYPE_LIST}" STREQUAL "")
 
-        OMPI_F77_GET_ALIGNMENT(${FORTRAN_TYPE} ofc_type_alignment)
+        OMPI_FORTRAN_GET_ALIGNMENT(${FORTRAN_TYPE} ofc_type_alignment)
 
       ENDIF(NOT ${ofc_expected_size} STREQUAL "-1" AND NOT ${ofc_type_size} EQUAL "${ofc_expected_size}")
-      SET(F77_SETUP_${TYPE_NAME}_DONE TRUE CACHE INTERNAL "F77 ${TYPE_NAME} check done or not.")
+      SET(FORTRAN_SETUP_${TYPE_NAME}_DONE TRUE CACHE INTERNAL "FORTRAN ${TYPE_NAME} check done or not.")
      ENDIF(ofc_have_type)
 
     SET(OMPI_HAVE_FORTRAN_${TYPE_NAME}_C ${ofc_have_type} CACHE INTERNAL "OMPI_HAVE_FORTRAN_${TYPE_NAME}")
     SET(OMPI_SIZEOF_FORTRAN_${TYPE_NAME}_C ${ofc_type_size} CACHE INTERNAL "OMPI_SIZEOF_FORTRAN_${TYPE_NAME}")
     SET(OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}_C ${ofc_type_alignment} CACHE INTERNAL "OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}")
 
-    ENDIF(NOT DEFINED F77_SETUP_${TYPE_NAME}_DONE)
+    ENDIF(NOT DEFINED FORTRAN_SETUP_${TYPE_NAME}_DONE)
 
     SET(OMPI_HAVE_FORTRAN_${TYPE_NAME} ${OMPI_HAVE_FORTRAN_${TYPE_NAME}_C}
         CACHE INTERNAL "OMPI_HAVE_FORTRAN_${TYPE_NAME}")
@@ -90,12 +90,12 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
     SET(OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME} ${OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}_C}
         CACHE INTERNAL "OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME}")
 
-  ELSEIF(NOT OMPI_WANT_F77_BINDINGS)
-    UNSET(F77_SETUP_${TYPE_NAME}_DONE)
+  ELSEIF(NOT OMPI_WANT_FORTRAN_BINDINGS)
+    UNSET(FORTRAN_SETUP_${TYPE_NAME}_DONE)
     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}")
-  ENDIF(OMPI_WANT_F77_BINDINGS)
+  ENDIF(OMPI_WANT_FORTRAN_BINDINGS)
 
   IF(NOT "${TYPE_LIST}" STREQUAL "")
     SET(ompi_fortran_${TYPE_NAME_L}_t ${ofc_c_type} CACHE INTERNAL "ompi_fortran_${TYPE_NAME_L}_t")
@@ -111,4 +111,4 @@ MACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
   OMPI_DEF_VAR(OMPI_ALIGNMENT_FORTRAN_${TYPE_NAME} "Alignment of Fortran 77 `${FORTRAN_TYPE}'." 0 1)
   OMPI_DEF_VAR(ompi_fortran_${TYPE_NAME_L}_t "C type corresponding to Fortran 77 `${FORTRAN_TYPE}'." 0 0)
 
-ENDMACRO(OMPI_F77_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
+ENDMACRO(OMPI_FORTRAN_CHECK FORTRAN_TYPE C_TYPE TYPE_LIST EXPECTED_SIZE)
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 23bc374bbf..e4147e5ccb 100644
--- a/contrib/platform/win32/CMakeModules/f77_check_real16_c_equiv.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_check_real16_c_equiv.cmake
@@ -9,17 +9,17 @@
 #
 
 
-# OMPI_F77_CHECK_REAL16_C_EQUIV
+# OMPI_FORTRAN_CHECK_REAL16_C_EQUIV
 # ----------------------------------------------------
-MACRO(OMPI_F77_CHECK_REAL16_C_EQUIV)
+MACRO(OMPI_FORTRAN_CHECK_REAL16_C_EQUIV)
   SET(OMPI_REAL16_MATCHES_C 0)
 
-  IF(OMPI_WANT_F77_BINDINGS AND OMPI_HAVE_FORTRAN_REAL16 AND NOT DEFINED REAL16_MATCHES_CHECK_DONE)
+  IF(OMPI_WANT_FORTRAN_BINDINGS AND OMPI_HAVE_FORTRAN_REAL16 AND NOT DEFINED REAL16_MATCHES_CHECK_DONE)
     IF(NOT ${ompi_fortran_real16_t} STREQUAL "")
       STRING(TOUPPER ${ompi_fortran_real16_t} REAL16_C_TYPE)
 
       IF(${OMPI_SIZEOF_FORTRAN_REAL16} EQUAL SIZEOF_${REAL16_C_TYPE})
-        OMPI_F77_MAKE_C_FUNCTION(ompi_ac_c_fn c)
+        OMPI_FORTRAN_MAKE_C_FUNCTION(ompi_ac_c_fn c)
         FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest_c.c
           "#include <stdio.h>\n"
           "#include <stdlib.h>\n"
@@ -52,7 +52,7 @@ MACRO(OMPI_F77_CHECK_REAL16_C_EQUIV)
           RESULT_VARIABLE RESULT
           ERROR_VARIABLE ERROR)
       
-        EXECUTE_PROCESS(COMMAND ${F77} conftest_f.f conftest_c.obj ${F77_OUTPUT_OBJ}conftest
+        EXECUTE_PROCESS(COMMAND ${FORTRAN} conftest_f.f conftest_c.obj ${FORTRAN_OUTPUT_OBJ}conftest
           WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
           OUTPUT_VARIABLE OUTPUT
           RESULT_VARIABLE RESULT
@@ -90,10 +90,10 @@ MACRO(OMPI_F77_CHECK_REAL16_C_EQUIV)
       MESSAGE(STATUS "Check if REAL*16 bit-matches C...skipped. (no REAL*16)")
     ENDIF(NOT ${ompi_fortran_real16_t} STREQUAL "")
 
-  ELSEIF(NOT OMPI_WANT_F77_BINDINGS)
+  ELSEIF(NOT OMPI_WANT_FORTRAN_BINDINGS)
     UNSET(REAL16_MATCHES_CHECK_DONE CACHE)
-  ENDIF(OMPI_WANT_F77_BINDINGS AND OMPI_HAVE_FORTRAN_REAL16  AND NOT DEFINED REAL16_MATCHES_CHECK_DONE)
+  ENDIF(OMPI_WANT_FORTRAN_BINDINGS AND OMPI_HAVE_FORTRAN_REAL16  AND NOT DEFINED REAL16_MATCHES_CHECK_DONE)
 
   OMPI_DEF_VAR(OMPI_REAL16_MATCHES_C "if REAL*16 bit-matches C." 0 1)
 
-ENDMACRO(OMPI_F77_CHECK_REAL16_C_EQUIV)
+ENDMACRO(OMPI_FORTRAN_CHECK_REAL16_C_EQUIV)
diff --git a/contrib/platform/win32/CMakeModules/f77_check_type.cmake b/contrib/platform/win32/CMakeModules/f77_check_type.cmake
index 52d8717802..f5fa4b5921 100644
--- a/contrib/platform/win32/CMakeModules/f77_check_type.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_check_type.cmake
@@ -8,12 +8,12 @@
 # $HEADER$
 #
 
-# OMPI_F77_CHECK_TYPE
+# OMPI_FORTRAN_CHECK_TYPE
 #         in: TYPE         - fortran type to check.
 #        out: HAVE_TYPE    - 0/1 whether we have that type.
 # -----------------------------------------------------------------
 
-MACRO(OMPI_F77_CHECK_TYPE TYPE HAVE_TYPE)
+MACRO(OMPI_FORTRAN_CHECK_TYPE TYPE HAVE_TYPE)
 
   IF(NOT DEFINED ${TYPE_NAME}_CHECK_DONE)
 
@@ -24,7 +24,7 @@ MACRO(OMPI_F77_CHECK_TYPE TYPE HAVE_TYPE)
       "\t ${TYPE} bogus_variable \n"
       "\t END \n")
 
-    EXECUTE_PROCESS(COMMAND ${F77} check_fortran_type.f
+    EXECUTE_PROCESS(COMMAND ${FORTRAN} check_fortran_type.f
       WORKING_DIRECTORY  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
       OUTPUT_VARIABLE    OUTPUT
       RESULT_VARIABLE    RESULT
@@ -42,4 +42,4 @@ MACRO(OMPI_F77_CHECK_TYPE TYPE HAVE_TYPE)
 
   ENDIF(NOT DEFINED ${TYPE_NAME}_CHECK_DONE)
 
-ENDMACRO(OMPI_F77_CHECK_TYPE TYPE HAVE_TYPE)
\ No newline at end of file
+ENDMACRO(OMPI_FORTRAN_CHECK_TYPE TYPE HAVE_TYPE)
\ No newline at end of file
diff --git a/contrib/platform/win32/CMakeModules/f77_find_ext_symbol_convention.cmake b/contrib/platform/win32/CMakeModules/f77_find_ext_symbol_convention.cmake
index 3beff6d199..648b7f9400 100644
--- a/contrib/platform/win32/CMakeModules/f77_find_ext_symbol_convention.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_find_ext_symbol_convention.cmake
@@ -9,19 +9,19 @@
 #
 
 
-MACRO(OMPI_F77_FIND_EXT_SYMBOL_CONVENTION)
+MACRO(OMPI_FORTRAN_FIND_EXT_SYMBOL_CONVENTION)
   IF(NOT SYMBOL_CONVENTION_CHECK_DONE)
-    SET(OMPI_F77_DOUBLE_UNDERSCORE 0
+    SET(OMPI_FORTRAN_DOUBLE_UNDERSCORE 0
       CACHE INTERNAL "external symbol convention - double underscore")
-    SET(OMPI_F77_SINGLE_UNDERSCORE 0
+    SET(OMPI_FORTRAN_SINGLE_UNDERSCORE 0
       CACHE INTERNAL "external symbol convention - single underscore")
-    SET(OMPI_F77_CAPS 0
+    SET(OMPI_FORTRAN_CAPS 0
       CACHE INTERNAL "external symbol convention - captital")
-    SET(OMPI_F77_PLAIN 0
+    SET(OMPI_FORTRAN_PLAIN 0
       CACHE INTERNAL "external symbol convention - plain")
 
     # make sure we know our linking convention...
-    MESSAGE(STATUS "Check ${F77} external symbol convention...")
+    MESSAGE(STATUS "Check ${FORTRAN} external symbol convention...")
     FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.f
       "\t subroutine FOO_bar(a) \n"
       "\t integer a \n"
@@ -29,7 +29,7 @@ MACRO(OMPI_F77_FIND_EXT_SYMBOL_CONVENTION)
       "\t return \n"
       "\t end \n")
 
-    EXECUTE_PROCESS(COMMAND ${F77} ${F77_OPTION_COMPILE} conftest.f ${F77_OUTPUT_OBJ}conftest.lib
+    EXECUTE_PROCESS(COMMAND ${FORTRAN} ${FORTRAN_OPTION_COMPILE} conftest.f ${FORTRAN_OUTPUT_OBJ}conftest.lib
       WORKING_DIRECTORY  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
       OUTPUT_VARIABLE    OUTPUT
       RESULT_VARIABLE    RESULT
@@ -52,41 +52,41 @@ MACRO(OMPI_F77_FIND_EXT_SYMBOL_CONVENTION)
 
     # set up the corresponding values
     IF(NOT DOUBLE_UNDERSCORE STREQUAL "")
-      SET(OMPI_F77_DOUBLE_UNDERSCORE 1
+      SET(OMPI_FORTRAN_DOUBLE_UNDERSCORE 1
         CACHE INTERNAL "external symbol convention - double underscore")
       SET(FUNC_NAME "foo_bar__")
-      SET(ompi_cv_f77_external_symbol "double underscore"
-        CACHE INTERNAL "F77 external symbol convention")
+      SET(ompi_cv_fortran_external_symbol "double underscore"
+        CACHE INTERNAL "FORTRAN external symbol convention")
     ELSEIF(NOT SINGLE_UNDERSCORE STREQUAL "")
-      SET(OMPI_F77_SINGLE_UNDERSCORE 1
+      SET(OMPI_FORTRAN_SINGLE_UNDERSCORE 1
         CACHE INTERNAL "external symbol convention - single underscore")
       SET(FUNC_NAME "foo_bar_")
-      SET(ompi_cv_f77_external_symbol "single underscore"
-        CACHE INTERNAL "F77 external symbol convention")
+      SET(ompi_cv_fortran_external_symbol "single underscore"
+        CACHE INTERNAL "FORTRAN external symbol convention")
     ELSEIF(NOT MIXED_CASE STREQUAL "")
-      SET(OMPI_F77_CAPS 1
+      SET(OMPI_FORTRAN_CAPS 1
         CACHE INTERNAL "external symbol convention - captital")
       SET(FUNC_NAME "FOO_bar")
-      SET(ompi_cv_f77_external_symbol "mixed case"
-        CACHE INTERNAL "F77 external symbol convention")
+      SET(ompi_cv_fortran_external_symbol "mixed case"
+        CACHE INTERNAL "FORTRAN external symbol convention")
     ELSEIF(NOT NO_UNDERSCORE STREQUAL "")
-      SET(OMPI_F77_PLAIN 1
+      SET(OMPI_FORTRAN_PLAIN 1
         CACHE INTERNAL "external symbol convention - plain")
       SET(FUNC_NAME "foo_bar")
-      SET(ompi_cv_f77_external_symbol "no underscore"
-        CACHE INTERNAL "F77 external symbol convention")
+      SET(ompi_cv_fortran_external_symbol "no underscore"
+        CACHE INTERNAL "FORTRAN external symbol convention")
     ELSEIF(NOT UPPER_CASE STREQUAL "")
-      SET(OMPI_F77_CAPS 1
+      SET(OMPI_FORTRAN_CAPS 1
         CACHE INTERNAL "external symbol convention - captital")
       SET(FUNC_NAME "FOO_BAR")
-      SET(ompi_cv_f77_external_symbol "upper case"
-        CACHE INTERNAL "F77 external symbol convention")
+      SET(ompi_cv_fortran_external_symbol "upper case"
+        CACHE INTERNAL "FORTRAN external symbol convention")
     ELSE(NOT UPPER_CASE STREQUAL "")
       MESSAGE(FATAL_ERROR "unknow Fortran naming convertion.")
-      SET(ompi_cv_f77_external_symbol "unknow")
+      SET(ompi_cv_fortran_external_symbol "unknow")
     ENDIF(NOT DOUBLE_UNDERSCORE STREQUAL "")
 
-    MESSAGE(STATUS "Check ${F77} external symbol convention...${ompi_cv_f77_external_symbol}")
+    MESSAGE(STATUS "Check ${FORTRAN} external symbol convention...${ompi_cv_fortran_external_symbol}")
 
     # now test if we can link the library with c program
     FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest_c.c 
@@ -95,9 +95,9 @@ MACRO(OMPI_F77_FIND_EXT_SYMBOL_CONVENTION)
     FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CMakeLists.txt
       "CMAKE_MINIMUM_REQUIRED(VERSION 2.4.6 FATAL_ERROR)\n"
       "PROJECT(conftest_c C)\n"
-      "IF(NOT \"${F77_LIB_PATH}\" STREQUAL \"\")\n"
-      "  LINK_DIRECTORIES(\"${F77_LIB_PATH}\")\n"
-      "ENDIF(NOT \"${F77_LIB_PATH}\" STREQUAL \"\")\n"
+      "IF(NOT \"${FORTRAN_LIB_PATH}\" STREQUAL \"\")\n"
+      "  LINK_DIRECTORIES(\"${FORTRAN_LIB_PATH}\")\n"
+      "ENDIF(NOT \"${FORTRAN_LIB_PATH}\" STREQUAL \"\")\n"
       "LINK_DIRECTORIES(${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/)\n"
       "ADD_EXECUTABLE(conftest_c conftest_c.c)\n"
       "TARGET_LINK_LIBRARIES(conftest_c ${OUTPUT_OBJ_FILE})\n")
@@ -122,15 +122,15 @@ MACRO(OMPI_F77_FIND_EXT_SYMBOL_CONVENTION)
 
   ENDIF(NOT SYMBOL_CONVENTION_CHECK_DONE)
 
-ENDMACRO(OMPI_F77_FIND_EXT_SYMBOL_CONVENTION)
+ENDMACRO(OMPI_FORTRAN_FIND_EXT_SYMBOL_CONVENTION)
 
 
 # return the corresponding C function name
-# OMPI_F77_MAKE_C_FUNCTION
+# OMPI_FORTRAN_MAKE_C_FUNCTION
 #             in: FUNCTION_NAME     -Fortran function name
 #            out: OUTPUT_VARIABLE   -C function name
-MACRO(OMPI_F77_MAKE_C_FUNCTION OUTPUT_VARIABLE FUNCTION_NAME)
-  IF("${ompi_cv_f77_external_symbol}" STREQUAL "double underscore")
+MACRO(OMPI_FORTRAN_MAKE_C_FUNCTION OUTPUT_VARIABLE FUNCTION_NAME)
+  IF("${ompi_cv_fortran_external_symbol}" STREQUAL "double underscore")
     # so the general rule is that if there is an _ in the function
     # name, then there are two trailing underscores.  Otherwise,
     # there is only one trailing underscore.
@@ -141,17 +141,17 @@ MACRO(OMPI_F77_MAKE_C_FUNCTION OUTPUT_VARIABLE FUNCTION_NAME)
     ELSE("${RESULT}" STREQUAL "")
       SET(${OUTPUT_VARIABLE} "${${OUTPUT_VARIABLE}}__")
     ENDIF("${RESULT}" STREQUAL "")
-  ELSEIF("${ompi_cv_f77_external_symbol}" STREQUAL "single underscore")
+  ELSEIF("${ompi_cv_fortran_external_symbol}" STREQUAL "single underscore")
     STRING(TOLOWER ${FUNCTION_NAME} ${OUTPUT_VARIABLE})
     SET(${OUTPUT_VARIABLE} "${${OUTPUT_VARIABLE}}_")
-  ELSEIF("${ompi_cv_f77_external_symbol}" STREQUAL "mixed case")
+  ELSEIF("${ompi_cv_fortran_external_symbol}" STREQUAL "mixed case")
     SET(${OUTPUT_VARIABLE} ${FUNCTION_NAME})
-  ELSEIF("${ompi_cv_f77_external_symbol}" STREQUAL "no underscore")
+  ELSEIF("${ompi_cv_fortran_external_symbol}" STREQUAL "no underscore")
     STRING(TOLOWER ${FUNCTION_NAME} ${OUTPUT_VARIABLE})
-  ELSEIF("${ompi_cv_f77_external_symbol}" STREQUAL "upper case")
+  ELSEIF("${ompi_cv_fortran_external_symbol}" STREQUAL "upper case")
     STRING(TOUPPER ${FUNCTION_NAME} ${OUTPUT_VARIABLE})
-  ELSE("${ompi_cv_f77_external_symbol}" STREQUAL "double underscore")
-    MESSAGE(FATAL_ERROR "unknown naming convention: ${ompi_cv_f77_external_symbol}")
-  ENDIF("${ompi_cv_f77_external_symbol}" STREQUAL "double underscore")
+  ELSE("${ompi_cv_fortran_external_symbol}" STREQUAL "double underscore")
+    MESSAGE(FATAL_ERROR "unknown naming convention: ${ompi_cv_fortran_external_symbol}")
+  ENDIF("${ompi_cv_fortran_external_symbol}" STREQUAL "double underscore")
 
-ENDMACRO(OMPI_F77_MAKE_C_FUNCTION OUTPUT_VARIABLE FUNCTION_NAME)
\ No newline at end of file
+ENDMACRO(OMPI_FORTRAN_MAKE_C_FUNCTION OUTPUT_VARIABLE FUNCTION_NAME)
\ No newline at end of file
diff --git a/contrib/platform/win32/CMakeModules/f77_get_alignment.cmake b/contrib/platform/win32/CMakeModules/f77_get_alignment.cmake
index ab9a6895ae..cd5c16060f 100644
--- a/contrib/platform/win32/CMakeModules/f77_get_alignment.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_get_alignment.cmake
@@ -8,17 +8,17 @@
 # $HEADER$
 #
 
-# OMPI_F77_GET_ALIGNMENT
+# OMPI_FORTRAN_GET_ALIGNMENT
 #             in: TYPE         - fortran type to check
 #            out: ALIGNMENT    - alignment to return
 # ----------------------------------------------------
 
-INCLUDE(F77_find_ext_symbol_convention)
+INCLUDE(FORTRAN_find_ext_symbol_convention)
 
-MACRO(OMPI_F77_GET_ALIGNMENT TYPE OUTPUT_VARIABLE)
+MACRO(OMPI_FORTRAN_GET_ALIGNMENT TYPE OUTPUT_VARIABLE)
   MESSAGE(STATUS "Check alignment of Fortran ${TYPE}...")
 
-  OMPI_F77_MAKE_C_FUNCTION(ompi_ac_align_fn align)
+  OMPI_FORTRAN_MAKE_C_FUNCTION(ompi_ac_align_fn align)
 
   FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.f
     "\t program falign\n"
@@ -70,7 +70,7 @@ MACRO(OMPI_F77_GET_ALIGNMENT TYPE OUTPUT_VARIABLE)
     RESULT_VARIABLE RESULT
     ERROR_VARIABLE ERROR)
   
-  EXECUTE_PROCESS(COMMAND ${F77} conftest.f conftest.obj -o conftest
+  EXECUTE_PROCESS(COMMAND ${FORTRAN} conftest.f conftest.obj -o conftest
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
     OUTPUT_VARIABLE OUTPUT
     RESULT_VARIABLE RESULT
@@ -96,4 +96,4 @@ MACRO(OMPI_F77_GET_ALIGNMENT TYPE OUTPUT_VARIABLE)
     ENDIF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftestval)
   ENDIF(RESULT)
 
-ENDMACRO(OMPI_F77_GET_ALIGNMENT TYPE OUTPUT_VARIABLE)
+ENDMACRO(OMPI_FORTRAN_GET_ALIGNMENT TYPE OUTPUT_VARIABLE)
diff --git a/contrib/platform/win32/CMakeModules/f77_get_fortran_handle_max.cmake b/contrib/platform/win32/CMakeModules/f77_get_fortran_handle_max.cmake
index bd9bd1ae77..3266d1dde4 100644
--- a/contrib/platform/win32/CMakeModules/f77_get_fortran_handle_max.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_get_fortran_handle_max.cmake
@@ -9,21 +9,21 @@
 #
 
 
-# OMPI_F77_GET_FORTRAN_HANDLE_MAX()
+# OMPI_FORTRAN_GET_FORTRAN_HANDLE_MAX()
 # -------------------------------------------------------
 # Find the maximum value of fortran integers, then calculate
 # min(INT_MAX, max fortran INTEGER).  This represents the maximum
 # number of fortran MPI handle index.
-MACRO(OMPI_F77_GET_FORTRAN_HANDLE_MAX)
+MACRO(OMPI_FORTRAN_GET_FORTRAN_HANDLE_MAX)
 
     #store previous value for later use.
     IF(DEFINED OMPI_FINT_MAX)
         SET(OMPI_FINT_MAX_OLD ${OMPI_FINT_MAX})
     ENDIF(DEFINED OMPI_FINT_MAX)
 
-    IF(NOT OMPI_WANT_F77_BINDINGS)
+    IF(NOT OMPI_WANT_FORTRAN_BINDINGS)
         SET(OMPI_FINT_MAX 0 CACHE INTERNAL "fortran int max")
-    ELSE(NOT OMPI_WANT_F77_BINDINGS)
+    ELSE(NOT OMPI_WANT_FORTRAN_BINDINGS)
         # 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.
@@ -34,7 +34,7 @@ MACRO(OMPI_F77_GET_FORTRAN_HANDLE_MAX)
             SET(OMPI_FINT_MAX ${OMPI_FINT_MAX}f CACHE INTERNAL "fortran int max")
             MATH(EXPR OMPI_NUMF ${OMPI_NUMF}-1)
         ENDWHILE(${OMPI_NUMF} GREATER 0)
-    ENDIF(NOT OMPI_WANT_F77_BINDINGS)
+    ENDIF(NOT OMPI_WANT_FORTRAN_BINDINGS)
 
     #OMPI_CINT_MAX doesn't change, check only once and cache the result.
     IF(NOT DEFINED CINT_MAX_CHECK_DONE)
@@ -103,4 +103,4 @@ MACRO(OMPI_F77_GET_FORTRAN_HANDLE_MAX)
 
     OMPI_DEF_VAR(OMPI_FORTRAN_HANDLE_MAX "Max handle value for fortran MPI handles, effectively min(INT_MAX, max fortran INTEGER value)." 0 1)
 
-ENDMACRO(OMPI_F77_GET_FORTRAN_HANDLE_MAX)
+ENDMACRO(OMPI_FORTRAN_GET_FORTRAN_HANDLE_MAX)
diff --git a/contrib/platform/win32/CMakeModules/f77_get_sizeof.cmake b/contrib/platform/win32/CMakeModules/f77_get_sizeof.cmake
index da58da9fbe..2f9a77559f 100644
--- a/contrib/platform/win32/CMakeModules/f77_get_sizeof.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_get_sizeof.cmake
@@ -9,15 +9,15 @@
 #
 
 
-# OMPI_F77_GET_SIZEOF(type, variable to set)
+# OMPI_FORTRAN_GET_SIZEOF(type, variable to set)
 # ------------------------------------------
 
-INCLUDE(F77_find_ext_symbol_convention)
+INCLUDE(FORTRAN_find_ext_symbol_convention)
 
-MACRO(OMPI_F77_GET_SIZEOF TYPE OUTPUT_VARIABLE)
+MACRO(OMPI_FORTRAN_GET_SIZEOF TYPE OUTPUT_VARIABLE)
   MESSAGE(STATUS "Check size of Fortran 77 ${TYPE}...")
   
-  OMPI_F77_MAKE_C_FUNCTION(ompi_ac_size_fn size)
+  OMPI_FORTRAN_MAKE_C_FUNCTION(ompi_ac_size_fn size)
   
   FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest.f
     "\t program fsize \n"
@@ -61,14 +61,14 @@ MACRO(OMPI_F77_GET_SIZEOF TYPE OUTPUT_VARIABLE)
 
   # generate the Fortran object file
   # some Fortran compilers don't allow to compile and link in one step. :-(
-  EXECUTE_PROCESS(COMMAND ${F77} ${F77_OPTION_COMPILE} conftest.f ${F77_OUTPUT_OBJ}conftest.obj
+  EXECUTE_PROCESS(COMMAND ${FORTRAN} ${FORTRAN_OPTION_COMPILE} conftest.f ${FORTRAN_OUTPUT_OBJ}conftest.obj
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
     OUTPUT_VARIABLE OUTPUT
     RESULT_VARIABLE RESULT
     ERROR_VARIABLE ERROR)
 
   # link the C and Fortran object files.
-  EXECUTE_PROCESS(COMMAND ${F77} conftest.obj conftest_c.obj ${F77_OUTPUT_EXE}conftest.exe
+  EXECUTE_PROCESS(COMMAND ${FORTRAN} conftest.obj conftest_c.obj ${FORTRAN_OUTPUT_EXE}conftest.exe
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
     OUTPUT_VARIABLE OUTPUT
     RESULT_VARIABLE RESULT
@@ -95,4 +95,4 @@ MACRO(OMPI_F77_GET_SIZEOF TYPE OUTPUT_VARIABLE)
     ENDIF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftestval)
   ENDIF(RESULT)
 
-ENDMACRO(OMPI_F77_GET_SIZEOF TYPE OUTPUT_VARIABLE)
\ No newline at end of file
+ENDMACRO(OMPI_FORTRAN_GET_SIZEOF TYPE OUTPUT_VARIABLE)
\ No newline at end of file
diff --git a/contrib/platform/win32/CMakeModules/f77_get_value_true.cmake b/contrib/platform/win32/CMakeModules/f77_get_value_true.cmake
index 9d01988ab5..a312d5a2a7 100644
--- a/contrib/platform/win32/CMakeModules/f77_get_value_true.cmake
+++ b/contrib/platform/win32/CMakeModules/f77_get_value_true.cmake
@@ -9,16 +9,16 @@
 #
 
 
-# OMPI_F77_GET_VALUE_TRUE()
+# OMPI_FORTRAN_GET_VALUE_TRUE()
 # -------------------------------------------------------
 # Determine the value of .TRUE. of this Fortran compiler.
-MACRO(OMPI_F77_GET_VALUE_TRUE)
+MACRO(OMPI_FORTRAN_GET_VALUE_TRUE)
 
-    IF(OMPI_WANT_F77_BINDINGS AND NOT DEFINED FORTRAN_VALUE_CHECK_DONE)
+    IF(OMPI_WANT_FORTRAN_BINDINGS AND NOT DEFINED FORTRAN_VALUE_CHECK_DONE)
 
         MESSAGE(STATUS "Check Fortran value for .TRUE. logical type...")
 
-        OMPI_F77_MAKE_C_FUNCTION(ompi_print_logical_fn print)
+        OMPI_FORTRAN_MAKE_C_FUNCTION(ompi_print_logical_fn print)
 
         FILE(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/conftest_c.c 
             "#include <stdio.h>\n"
@@ -74,7 +74,7 @@ MACRO(OMPI_F77_GET_VALUE_TRUE)
             MESSAGE(FATAL_ERROR "Could not determine value of Fortran .TRUE..  Aborting.")
         ENDIF(RESULT)
 
-        EXECUTE_PROCESS(COMMAND ${F77} ${F77_OPTION_COMPILE} conftest_f.f ${F77_OUTPUT_OBJ}conftest_f.obj
+        EXECUTE_PROCESS(COMMAND ${FORTRAN} ${FORTRAN_OPTION_COMPILE} conftest_f.f ${FORTRAN_OUTPUT_OBJ}conftest_f.obj
             WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
             OUTPUT_VARIABLE OUTPUT
             RESULT_VARIABLE RESULT
@@ -85,7 +85,7 @@ MACRO(OMPI_F77_GET_VALUE_TRUE)
             MESSAGE(FATAL_ERROR "Could not determine value of Fortran .TRUE..  Aborting.")
         ENDIF(RESULT)
 
-        EXECUTE_PROCESS(COMMAND ${F77} conftest_f.obj conftest_c.obj ${F77_OUTPUT_EXE}conftest.exe
+        EXECUTE_PROCESS(COMMAND ${FORTRAN} conftest_f.obj conftest_c.obj ${FORTRAN_OUTPUT_EXE}conftest.exe
             WORKING_DIRECTORY ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
             OUTPUT_VARIABLE OUTPUT
             RESULT_VARIABLE RESULT
@@ -118,11 +118,11 @@ MACRO(OMPI_F77_GET_VALUE_TRUE)
             ENDIF(EXISTS ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/fortran_true_value)
         ENDIF(RESULT)
 
-    ELSEIF(NOT OMPI_WANT_F77_BINDINGS)
+    ELSEIF(NOT OMPI_WANT_FORTRAN_BINDINGS)
         SET(OMPI_FORTRAN_VALUE_TRUE 0)
         UNSET(FORTRAN_VALUE_CHECK_DONE CACHE)
-    ENDIF(OMPI_WANT_F77_BINDINGS AND NOT DEFINED FORTRAN_VALUE_CHECK_DONE)
+    ENDIF(OMPI_WANT_FORTRAN_BINDINGS AND NOT DEFINED FORTRAN_VALUE_CHECK_DONE)
 
     OMPI_DEF_VAR(OMPI_FORTRAN_VALUE_TRUE "Fortran value for .TRUE. logical type" 0 1)
 
-ENDMACRO(OMPI_F77_GET_VALUE_TRUE)
+ENDMACRO(OMPI_FORTRAN_GET_VALUE_TRUE)
diff --git a/contrib/platform/win32/CMakeModules/ompi_configure.cmake b/contrib/platform/win32/CMakeModules/ompi_configure.cmake
index 1b94e4b4d5..75ebfc2979 100644
--- a/contrib/platform/win32/CMakeModules/ompi_configure.cmake
+++ b/contrib/platform/win32/CMakeModules/ompi_configure.cmake
@@ -140,7 +140,7 @@ OMPI_DEF(OMPI_BUILD_CXXFLAGS "${CMAKE_CXX_FLAGS} " "C++ flags" 1 1)
 
 SET(OMPI_BUILD_CXXCPPFLAGS ${OMPI_BUILD_CPPFLAGS})
 
-OMPI_DEF(OMPI_BUILD_FFLAGS " " "F77 flags." 1 1)
+OMPI_DEF(OMPI_BUILD_FFLAGS " " "FORTRAN flags." 1 1)
 
 OMPI_DEF(OMPI_BUILD_FCFLAGS " " "F90 flags." 1 1)
 
@@ -207,7 +207,7 @@ OMPI_DEF_OPT (OMPI_PROVIDE_MPI_FILE_INTERFACE "Whether OMPI should provide MPI F
 
 OMPI_DEF_OPT(OMPI_WANT_CXX_BINDINGS "Whether we want MPI cxx support or not." ON)
 
-OMPI_DEF_OPT(OMPI_WANT_F77_BINDINGS "Whether we want MPI F77 support or not." OFF)
+OMPI_DEF_OPT(OMPI_WANT_FORTRAN_BINDINGS "Whether we want MPI FORTRAN support or not." OFF)
 
 OMPI_DEF_OPT(OMPI_WANT_F90_BINDINGS "Whether we want MPI F90 support or not." OFF)
 
@@ -255,6 +255,8 @@ OMPI_DEF_OPT(OMPI_RELEASE_BUILD "Whether it is a build for binary release (this
 
 OMPI_DEF_OPT(OMPI_WANT_JAVA_BINDINGS "Whether we want to enable MPI Java support." OFF)
 
+OMPI_DEF_OPT(OPAL_HAVE_HWLOC "Whether we have hwloc support or not" ON)
+
 OMPI_DEF(OMPI_ENABLE_CONTRIB_vt 0 "Whether we want to enable VampirTrace support." 0 1)
 
 IF (NOT MSVC)
@@ -626,40 +628,40 @@ OMPI_CHECK_TYPES (uintptr_t UINTPTR_T none c)
 ###################################################################
 #                      Check Fortran 77 types                     #
 ###################################################################
-INCLUDE(setup_F77)
-INCLUDE(f77_check)
-INCLUDE(f77_check_real16_c_equiv)
-INCLUDE(f77_get_value_true)
-INCLUDE(f77_get_fortran_handle_max)
+INCLUDE(setup_FORTRAN)
+INCLUDE(fortran_check)
+INCLUDE(fortran_check_real16_c_equiv)
+INCLUDE(fortran_get_value_true)
+INCLUDE(fortran_get_fortran_handle_max)
 
 IF(WIN32)
   OMPI_DEF(ompi_fortran_bogus_type_t "int" "A bogus type that allows us to have sentinel type values that are still valid." 0 1)
 ENDIF(WIN32)
 
 # We want to set the #define's for all of these, so invoke the macros
-# regardless of whether we have F77 support or not.
-OMPI_F77_CHECK("CHARACTER" "yes" "char;int32_t;int;int64_t;long long;long" "-1")
-OMPI_F77_CHECK("LOGICAL" "yes" "char;int;long long;long" "-1")
-OMPI_F77_CHECK("LOGICAL*1" "yes" "char;short;int;long long;long" "1")
-OMPI_F77_CHECK("LOGICAL*2" "yes" "short;int;long long;long" "2")
-OMPI_F77_CHECK("LOGICAL*4" "yes" "int;long long;long" "4")
-OMPI_F77_CHECK("LOGICAL*8" "yes" "int;long long;long" "8")
-OMPI_F77_CHECK("INTEGER" "yes" "int;long long;long" "-1")
-OMPI_F77_CHECK("INTEGER*1" "no" "char;short;int;long long;long" "1")
-OMPI_F77_CHECK("INTEGER*2" "no" "short;int;long long;long" "2")
-OMPI_F77_CHECK("INTEGER*4" "no" "int;long long;long" "4")
-OMPI_F77_CHECK("INTEGER*8" "no" "int;long long;long" "8")
-OMPI_F77_CHECK("INTEGER*16" "no" "int;long long;long" "16")
+# regardless of whether we have FORTRAN support or not.
+OMPI_FORTRAN_CHECK("CHARACTER" "yes" "char;int32_t;int;int64_t;long long;long" "-1")
+OMPI_FORTRAN_CHECK("LOGICAL" "yes" "char;int;long long;long" "-1")
+OMPI_FORTRAN_CHECK("LOGICAL*1" "yes" "char;short;int;long long;long" "1")
+OMPI_FORTRAN_CHECK("LOGICAL*2" "yes" "short;int;long long;long" "2")
+OMPI_FORTRAN_CHECK("LOGICAL*4" "yes" "int;long long;long" "4")
+OMPI_FORTRAN_CHECK("LOGICAL*8" "yes" "int;long long;long" "8")
+OMPI_FORTRAN_CHECK("INTEGER" "yes" "int;long long;long" "-1")
+OMPI_FORTRAN_CHECK("INTEGER*1" "no" "char;short;int;long long;long" "1")
+OMPI_FORTRAN_CHECK("INTEGER*2" "no" "short;int;long long;long" "2")
+OMPI_FORTRAN_CHECK("INTEGER*4" "no" "int;long long;long" "4")
+OMPI_FORTRAN_CHECK("INTEGER*8" "no" "int;long long;long" "8")
+OMPI_FORTRAN_CHECK("INTEGER*16" "no" "int;long long;long" "16")
 
-OMPI_F77_CHECK("REAL" "yes" "float;double;long double" "-1")
-OMPI_F77_CHECK("REAL*2" "no" "float;double;long double" "2")
-OMPI_F77_CHECK("REAL*4" "no" "float;double;long double" "4")
-OMPI_F77_CHECK("REAL*8" "no" "float;double;long double" "8")
-OMPI_F77_CHECK("REAL*16" "no" "float;double;long double" "16")
-OMPI_F77_CHECK("DOUBLE PRECISION" "yes" "float;double;long double" "-1")
+OMPI_FORTRAN_CHECK("REAL" "yes" "float;double;long double" "-1")
+OMPI_FORTRAN_CHECK("REAL*2" "no" "float;double;long double" "2")
+OMPI_FORTRAN_CHECK("REAL*4" "no" "float;double;long double" "4")
+OMPI_FORTRAN_CHECK("REAL*8" "no" "float;double;long double" "8")
+OMPI_FORTRAN_CHECK("REAL*16" "no" "float;double;long double" "16")
+OMPI_FORTRAN_CHECK("DOUBLE PRECISION" "yes" "float;double;long double" "-1")
 
-OMPI_F77_CHECK("COMPLEX" "yes" "" "-1")
-OMPI_F77_CHECK("DOUBLE COMPLEX" "yes" "" "-1")
+OMPI_FORTRAN_CHECK("COMPLEX" "yes" "" "-1")
+OMPI_FORTRAN_CHECK("DOUBLE COMPLEX" "yes" "" "-1")
 
 # The complex*N tests are a bit different (note: the complex tests are
 # the same as all the rest, because complex is a composite of two
@@ -672,37 +674,37 @@ OMPI_F77_CHECK("DOUBLE COMPLEX" "yes" "" "-1")
 #    have a back-end C type for it)
 # b) compiler supports complex*N
 
-OMPI_F77_CHECK("COMPLEX*8" "no" "" "8")
-OMPI_F77_CHECK("COMPLEX*16" "no" "" "16")
-OMPI_F77_CHECK("COMPLEX*32" "no" "" "32")
+OMPI_FORTRAN_CHECK("COMPLEX*8" "no" "" "8")
+OMPI_FORTRAN_CHECK("COMPLEX*16" "no" "" "16")
+OMPI_FORTRAN_CHECK("COMPLEX*32" "no" "" "32")
 
-OMPI_F77_CHECK_REAL16_C_EQUIV()
+OMPI_FORTRAN_CHECK_REAL16_C_EQUIV()
 
 # Regardless of whether we have fortran bindings, or even a fortran
 # compiler, get the max value for a fortran MPI handle (this macro
 # handles the case where we don't have a fortran compiler).
 
-OMPI_F77_GET_FORTRAN_HANDLE_MAX()
+OMPI_FORTRAN_GET_FORTRAN_HANDLE_MAX()
 
 #
 # Check for Fortran compilers value of TRUE and for the correct assumption
 # on LOGICAL for conversion into what C considers to be a true value
 #
-OMPI_F77_GET_VALUE_TRUE()
-#OMPI_F77_CHECK_LOGICAL_ARRAY
+OMPI_FORTRAN_GET_VALUE_TRUE()
+#OMPI_FORTRAN_CHECK_LOGICAL_ARRAY
 
 #
-# There are 2 layers to the MPI f77 layer. The only extra thing that
-# determine f77 bindings is that fortran can be disabled by user. In
+# There are 2 layers to the MPI fortran layer. The only extra thing that
+# determine fortran bindings is that fortran can be disabled by user. In
 # such cases, we need to not build the target at all.  One layer
-# generates MPI_f77* bindings. The other layer generates PMPI_f77*
+# generates MPI_fortran* bindings. The other layer generates PMPI_fortran*
 # bindings. The following conditions determine whether each (or both)
 # these layers are built.
 #
 # Superceeding clause:
 #   - fortran77 bindings should be enabled, else everything is
 #     disabled
-# 1. MPI_f77* bindings are needed if:
+# 1. MPI_fortran* bindings are needed if:
 #   - Profiling is not required
 #   - Profiling is required but weak symbols are not
 #     supported
@@ -711,17 +713,17 @@ OMPI_F77_GET_VALUE_TRUE()
 # need to be built or NOT
 #
 
-IF(NOT WANT_MPI_PROFILING OR OMPI_PROFILING_COMPILE_SEPARATELY AND  OMPI_WANT_F77_BINDINGS)
-  SET(WANT_MPI_F77_BINDINGS_LAYER 1)
-ELSE(NOT WANT_MPI_PROFILING OR OMPI_PROFILING_COMPILE_SEPARATELY AND  OMPI_WANT_F77_BINDINGS)
-  SET(WANT_MPI_F77_BINDINGS_LAYER 0) 
-ENDIF(NOT WANT_MPI_PROFILING OR OMPI_PROFILING_COMPILE_SEPARATELY AND  OMPI_WANT_F77_BINDINGS)
+IF(NOT WANT_MPI_PROFILING OR OMPI_PROFILING_COMPILE_SEPARATELY AND  OMPI_WANT_FORTRAN_BINDINGS)
+  SET(WANT_MPI_FORTRAN_BINDINGS_LAYER 1)
+ELSE(NOT WANT_MPI_PROFILING OR OMPI_PROFILING_COMPILE_SEPARATELY AND  OMPI_WANT_FORTRAN_BINDINGS)
+  SET(WANT_MPI_FORTRAN_BINDINGS_LAYER 0) 
+ENDIF(NOT WANT_MPI_PROFILING OR OMPI_PROFILING_COMPILE_SEPARATELY AND  OMPI_WANT_FORTRAN_BINDINGS)
 
-IF(WANT_MPI_PROFILING AND OMPI_WANT_F77_BINDINGS)
-  SET(WANT_MPI_F77_BINDINGS_LAYER 1)
-ELSE(WANT_MPI_PROFILING AND OMPI_WANT_F77_BINDINGS)
-  SET(WANT_MPI_F77_BINDINGS_LAYER 0) 
-ENDIF(WANT_MPI_PROFILING AND OMPI_WANT_F77_BINDINGS)
+IF(WANT_MPI_PROFILING AND OMPI_WANT_FORTRAN_BINDINGS)
+  SET(WANT_MPI_FORTRAN_BINDINGS_LAYER 1)
+ELSE(WANT_MPI_PROFILING AND OMPI_WANT_FORTRAN_BINDINGS)
+  SET(WANT_MPI_FORTRAN_BINDINGS_LAYER 0) 
+ENDIF(WANT_MPI_PROFILING AND OMPI_WANT_FORTRAN_BINDINGS)
 
 
 IF(WIN32)
@@ -755,8 +757,6 @@ IF(WIN32)
   OMPI_DEF_CACHE(MCA_pml_DIRECT_CALL_HEADER " " STRING "Header pml includes to be direct called." 1 1)
 
   OMPI_DEF_CACHE(OMPI_MPI_CONTRIBS none STRING "List of contributed package names that will be built." 1 1)
-
-  OMPI_DEF(OPAL_HAVE_HWLOC 0 "Whether we have hwloc support or not" 0 1)
   
   OMPI_DEF(OPAL_HAVE_HWLOC_XML 0 "Enable xml support or not" 0 1)
   
@@ -789,14 +789,14 @@ OMPI_DEF(OMPI_CXX ${CXX_COMPILER_NAME} "OMPI underlying C++ compiler name." 1 1)
 
 OMPI_DEF(OMPI_CXX_ABSOLUTE ${CMAKE_CXX_COMPILER} "OMPI underlying C++ compiler absolute path." 1 1)
 
-IF(OMPI_WANT_F77_BINDINGS)
-  GET_FILENAME_COMPONENT(F77_COMPILER_NAME ${CMAKE_Fortran_COMPILER} NAME_WE)
-  OMPI_DEF(OMPI_F77 ${F77_COMPILER_NAME} "OMPI underlying Fortran 77 compiler name." 1 1)
-  OMPI_DEF(OMPI_F77_ABSOLUTE ${CMAKE_Fortran_COMPILER} "OMPI underlying Fortran 77 compiler absolute path" 1 1)
-ELSE(OMPI_WANT_F77_BINDINGS)
-  OMPI_DEF(OMPI_F77 "none" "OMPI underlying Fortran 77 compiler name." 1 1)
-  OMPI_DEF(OMPI_F77_ABSOLUTE "none" "OMPI underlying Fortran 77 compiler absolute path" 1 1)
-ENDIF(OMPI_WANT_F77_BINDINGS)
+IF(OMPI_WANT_FORTRAN_BINDINGS)
+  GET_FILENAME_COMPONENT(FORTRAN_COMPILER_NAME ${CMAKE_Fortran_COMPILER} NAME_WE)
+  OMPI_DEF(OMPI_FORTRAN ${FORTRAN_COMPILER_NAME} "OMPI underlying Fortran 77 compiler name." 1 1)
+  OMPI_DEF(OMPI_FORTRAN_ABSOLUTE ${CMAKE_Fortran_COMPILER} "OMPI underlying Fortran 77 compiler absolute path" 1 1)
+ELSE(OMPI_WANT_FORTRAN_BINDINGS)
+  OMPI_DEF(OMPI_FORTRAN "none" "OMPI underlying Fortran 77 compiler name." 1 1)
+  OMPI_DEF(OMPI_FORTRAN_ABSOLUTE "none" "OMPI underlying Fortran 77 compiler absolute path" 1 1)
+ENDIF(OMPI_WANT_FORTRAN_BINDINGS)
 
 IF(OMPI_WANT_F90_BINDINGS)
   GET_FILENAME_COMPONENT(F90_COMPILER_NAME ${CMAKE_Fortran_COMPILER} NAME_WE)
diff --git a/contrib/platform/win32/CMakeModules/setup_f77.cmake b/contrib/platform/win32/CMakeModules/setup_f77.cmake
index 83f2a3af7a..c48c4f9cd6 100644
--- a/contrib/platform/win32/CMakeModules/setup_f77.cmake
+++ b/contrib/platform/win32/CMakeModules/setup_f77.cmake
@@ -8,7 +8,7 @@
 # $HEADER$
 #
 
-# first try to find a f77 compiler, will be checked when f77 support is enabled.
+# first try to find a fortran compiler, will be checked when fortran support is enabled.
 
 # There might be a bug in CMake, the CMAKE_GENERATOR_FC is set to "ifort" by default,
 # which causes CMake can't find the correct Fortran compiler.
@@ -17,30 +17,30 @@ SET(CMAKE_GENERATOR_FC "")
 include(CMakeDetermineFortranCompiler)
 include(CMakeFortranInformation)
 
-IF(OMPI_WANT_F77_BINDINGS AND NOT F77_SETUP_DONE)
+IF(OMPI_WANT_FORTRAN_BINDINGS AND NOT FORTRAN_SETUP_DONE)
 
   SET(OMPI_MPI_INTEGER_KIND 0 CACHE INTERNAL "MPI_INTEGER_KIND")
   SET(OMPI_MPI_ADDRESS_KIND 0 CACHE INTERNAL "MPI_ADDRESS_KIND")
   SET(OMPI_MPI_OFFSET_KIND 0 CACHE INTERNAL "MPI_OFFSET_KIND")
   SET(OMPI_FORTRAN_STATUS_SIZE 0 CACHE INTERNAL "MPI_STATUS_SIZE")
 
-  GET_FILENAME_COMPONENT(F77_NAME ${CMAKE_Fortran_COMPILER} NAME)
-  GET_FILENAME_COMPONENT(F77_PATH ${CMAKE_Fortran_COMPILER} PATH)
+  GET_FILENAME_COMPONENT(FORTRAN_NAME ${CMAKE_Fortran_COMPILER} NAME)
+  GET_FILENAME_COMPONENT(FORTRAN_PATH ${CMAKE_Fortran_COMPILER} PATH)
 
-  SET(F77 ${F77_NAME} CACHE INTERNAL "Name of the fortran compiler.")
+  SET(FORTRAN ${FORTRAN_NAME} CACHE INTERNAL "Name of the fortran compiler.")
 
   # Default compiler settings.
-  IF(${F77} STREQUAL "ifort.exe")
+  IF(${FORTRAN} STREQUAL "ifort.exe")
     #settings for Intel Fortran
-    SET(F77_OPTION_COMPILE "/c" CACHE INTERNAL
+    SET(FORTRAN_OPTION_COMPILE "/c" CACHE INTERNAL
       "Fortran compiler option for compiling without linking.")
-    SET(F77_OUTPUT_OBJ "/Fo" CACHE INTERNAL
+    SET(FORTRAN_OUTPUT_OBJ "/Fo" CACHE INTERNAL
       "Fortran compiler option for setting object file name.")
-    SET(F77_OUTPUT_EXE "/Fe" CACHE INTERNAL
+    SET(FORTRAN_OUTPUT_EXE "/Fe" CACHE INTERNAL
       "Fortran compiler option for setting executable file name.")
-    SET(F77_DYNAMIC_FLAG_DEBUG "/MDd" CACHE INTERNAL
+    SET(FORTRAN_DYNAMIC_FLAG_DEBUG "/MDd" CACHE INTERNAL
       "Compile flag for using dynamically-loaded, multithread C runtime (Debug).")
-    SET(F77_DYNAMIC_FLAG "/MD" CACHE INTERNAL
+    SET(FORTRAN_DYNAMIC_FLAG "/MD" CACHE INTERNAL
       "Compile flag for using dynamically-loaded, multithread C runtime.")
 
     IF(NOT "$ENV{IFORT_COMPILER11}" STREQUAL "")
@@ -50,48 +50,48 @@ IF(OMPI_WANT_F77_BINDINGS AND NOT F77_SETUP_DONE)
     ENDIF(NOT "$ENV{IFORT_COMPILER11}" STREQUAL "")
 
     IF(CMAKE_CL_64)
-      SET(F77_LIB_PATH "${IFORT_LIB_PATH}/intel64")
+      SET(FORTRAN_LIB_PATH "${IFORT_LIB_PATH}/intel64")
     ELSE(CMAKE_CL_64)
-      SET(F77_LIB_PATH "${IFORT_LIB_PATH}/ia32")
+      SET(FORTRAN_LIB_PATH "${IFORT_LIB_PATH}/ia32")
     ENDIF(CMAKE_CL_64)
 
-    IF(NOT F77_LIB_PATH)
+    IF(NOT FORTRAN_LIB_PATH)
       IF(CMAKE_CL_64)
-        FIND_LIBRARY(F77_IFCONSOL_LIB ifconsol.lib PATHS ${F77_PATH}/../../intel64)
+        FIND_LIBRARY(FORTRAN_IFCONSOL_LIB ifconsol.lib PATHS ${FORTRAN_PATH}/../../intel64)
       ELSE(CMAKE_CL_64)
-        FIND_LIBRARY(F77_IFCONSOL_LIB ifconsol.lib PATHS ${F77_PATH}/../../ia32)
+        FIND_LIBRARY(FORTRAN_IFCONSOL_LIB ifconsol.lib PATHS ${FORTRAN_PATH}/../../ia32)
       ENDIF(CMAKE_CL_64)
-      GET_FILENAME_COMPONENT(F77_LIB_PATH ${F77_IFCONSOL_LIB} PATH)
-      UNSET(F77_IFCONSOL_LIB CACHE)
-    ELSE(NOT F77_LIB_PATH)
-      STRING(REPLACE "\\" "/" F77_LIB_PATH ${F77_LIB_PATH})
-    ENDIF(NOT F77_LIB_PATH)
-  ELSEIF(${F77} STREQUAL "g95.exe")
+      GET_FILENAME_COMPONENT(FORTRAN_LIB_PATH ${FORTRAN_IFCONSOL_LIB} PATH)
+      UNSET(FORTRAN_IFCONSOL_LIB CACHE)
+    ELSE(NOT FORTRAN_LIB_PATH)
+      STRING(REPLACE "\\" "/" FORTRAN_LIB_PATH ${FORTRAN_LIB_PATH})
+    ENDIF(NOT FORTRAN_LIB_PATH)
+  ELSEIF(${FORTRAN} STREQUAL "g95.exe")
     #settings for G95
-    SET(F77_OPTION_COMPILE "-c" CACHE INTERNAL
+    SET(FORTRAN_OPTION_COMPILE "-c" CACHE INTERNAL
       "Fortran compiler option for compiling without linking.")
-    SET(F77_OUTPUT_OBJ "-o" CACHE INTERNAL
+    SET(FORTRAN_OUTPUT_OBJ "-o" CACHE INTERNAL
       "Fortran compiler option for setting object file name.")
-    SET(F77_OUTPUT_EXE "-o" CACHE INTERNAL
+    SET(FORTRAN_OUTPUT_EXE "-o" CACHE INTERNAL
       "Fortran compiler option for setting executable file name.")
-  ELSE(${F77} STREQUAL "ifort.exe")
+  ELSE(${FORTRAN} STREQUAL "ifort.exe")
     # in other case, let user specify their fortran configrations.
-    SET(F77_OPTION_COMPILE "-c" CACHE STRING
+    SET(FORTRAN_OPTION_COMPILE "-c" CACHE STRING
       "Fortran compiler option for compiling without linking.")
-    SET(F77_OUTPUT_OBJ "-o" CACHE STRING
+    SET(FORTRAN_OUTPUT_OBJ "-o" CACHE STRING
       "Fortran compiler option for setting object file name.")
-    SET(F77_OUTPUT_EXE "-o" CACHE STRING
+    SET(FORTRAN_OUTPUT_EXE "-o" CACHE STRING
       "Fortran compiler option for setting executable file name.")
-    SET(F77_LIB_PATH "" CACHE PATH
+    SET(FORTRAN_LIB_PATH "" CACHE PATH
       "Library path for the fortran compiler")
-    SET(F77_INCLUDE_PATH "" CACHE PATH
+    SET(FORTRAN_INCLUDE_PATH "" CACHE PATH
       "Include path for the fortran compiler")
-  ENDIF(${F77} STREQUAL "ifort.exe")
+  ENDIF(${FORTRAN} STREQUAL "ifort.exe")
 
   # Export env variables for fortran compiler.
-  SET(ENV{PATH} "${C_COMPILER_PATH};${F77_PATH};$ENV{PATH}")
-  SET(ENV{LIB} "${C_COMPILER_LIB};${F77_LIB_PATH};$ENV{LIB}")
-  SET(ENV{INCLUDE} "${C_COMPILER_INCLUDE};${F77_INCLUDE_PATH};$ENV{INCLUDE}")
+  SET(ENV{PATH} "${C_COMPILER_PATH};${FORTRAN_PATH};$ENV{PATH}")
+  SET(ENV{LIB} "${C_COMPILER_LIB};${FORTRAN_LIB_PATH};$ENV{LIB}")
+  SET(ENV{INCLUDE} "${C_COMPILER_INCLUDE};${FORTRAN_INCLUDE_PATH};$ENV{INCLUDE}")
   SET(ENV{LIBPATH} "${C_COMPILER_LIBPATH};$ENV{LIBPATH}")
 
   # make sure the compiler actually works, if not cross-compiling
@@ -102,7 +102,7 @@ IF(OMPI_WANT_F77_BINDINGS AND NOT F77_SETUP_DONE)
        "\t END \n")
 
   # lets use execute_process to run the compile test
-  EXECUTE_PROCESS(COMMAND ${F77} testFortranCompiler.f
+  EXECUTE_PROCESS(COMMAND ${FORTRAN} testFortranCompiler.f
                   WORKING_DIRECTORY  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
                   OUTPUT_VARIABLE    OUTPUT
                   RESULT_VARIABLE    RESULT
@@ -110,43 +110,43 @@ IF(OMPI_WANT_F77_BINDINGS AND NOT F77_SETUP_DONE)
 
 
   IF(RESULT)
-    SET(F77_SETUP_DONE FALSE CACHE INTERNAL "f77 setup done.")
+    SET(FORTRAN_SETUP_DONE FALSE CACHE INTERNAL "fortran setup done.")
     MESSAGE(STATUS "${OUTPUT}\n${ERROR}")
-    MESSAGE(STATUS "Fortran compiler ${F77} can't compile a simple fortran program.")
+    MESSAGE(STATUS "Fortran compiler ${FORTRAN} can't compile a simple fortran program.")
     MESSAGE(FATAL_ERROR "Cannot continue. Please check Fortran compiler installation, or disable Fortran 77 support.")
   ELSE(RESULT)
-    MESSAGE(STATUS "Checking for working Fortran compiler...${F77}")
-    SET(F77_SETUP_DONE TRUE CACHE INTERNAL "f77 setup done.")
+    MESSAGE(STATUS "Checking for working Fortran compiler...${FORTRAN}")
+    SET(FORTRAN_SETUP_DONE TRUE CACHE INTERNAL "fortran setup done.")
   ENDIF(RESULT)
 
-  INCLUDE(F77_find_ext_symbol_convention)
+  INCLUDE(FORTRAN_find_ext_symbol_convention)
   # make sure we know the linking convention
   # this macro will also test linking with C code
-  OMPI_F77_FIND_EXT_SYMBOL_CONVENTION()
+  OMPI_FORTRAN_FIND_EXT_SYMBOL_CONVENTION()
 
-ELSEIF(NOT OMPI_WANT_F77_BINDINGS)
-    SET(OMPI_F77_DOUBLE_UNDERSCORE 0
+ELSEIF(NOT OMPI_WANT_FORTRAN_BINDINGS)
+    SET(OMPI_FORTRAN_DOUBLE_UNDERSCORE 0
       CACHE INTERNAL "external symbol convention - double underscore")
-    SET(OMPI_F77_SINGLE_UNDERSCORE 0
+    SET(OMPI_FORTRAN_SINGLE_UNDERSCORE 0
       CACHE INTERNAL "external symbol convention - single underscore")
-    SET(OMPI_F77_CAPS 0
+    SET(OMPI_FORTRAN_CAPS 0
       CACHE INTERNAL "external symbol convention - captital")
-    SET(OMPI_F77_PLAIN 0
+    SET(OMPI_FORTRAN_PLAIN 0
       CACHE INTERNAL "external symbol convention - plain")
     
     UNSET(SYMBOL_CONVENTION_CHECK_DONE CACHE)
-    UNSET(F77_OPTION_COMPILE CACHE)
-    UNSET(F77_OUTPUT_OBJ CACHE)
-    UNSET(F77_OUTPUT_EXE CACHE)
-    UNSET(F77_LIB_PATH CACHE)
-    UNSET(F77_INCLUDE_PATH CACHE)
-    UNSET(F77_IFCONSOL_LIB CACHE)
-    UNSET(F77_SETUP_DONE CACHE)
-ENDIF(OMPI_WANT_F77_BINDINGS AND NOT F77_SETUP_DONE)
+    UNSET(FORTRAN_OPTION_COMPILE CACHE)
+    UNSET(FORTRAN_OUTPUT_OBJ CACHE)
+    UNSET(FORTRAN_OUTPUT_EXE CACHE)
+    UNSET(FORTRAN_LIB_PATH CACHE)
+    UNSET(FORTRAN_INCLUDE_PATH CACHE)
+    UNSET(FORTRAN_IFCONSOL_LIB CACHE)
+    UNSET(FORTRAN_SETUP_DONE CACHE)
+ENDIF(OMPI_WANT_FORTRAN_BINDINGS AND NOT FORTRAN_SETUP_DONE)
 
-# a few definitions needed by OMPI_F77_FIND_EXT_SYMBOL_CONVENTION check.
-OMPI_DEF_VAR(OMPI_F77_DOUBLE_UNDERSCORE "Whether fortran symbols have a trailing double underscore or not." 0 1)
-OMPI_DEF_VAR(OMPI_F77_SINGLE_UNDERSCORE "Whether fortran symbols have a trailing single underscore or not." 0 1)
-OMPI_DEF_VAR(OMPI_F77_CAPS "Whether fortran symbols are all caps or not." 0 1)
-OMPI_DEF_VAR(OMPI_F77_PLAIN "Whether fortran symbols have no trailing underscore or not." 0 1)
+# a few definitions needed by OMPI_FORTRAN_FIND_EXT_SYMBOL_CONVENTION check.
+OMPI_DEF_VAR(OMPI_FORTRAN_DOUBLE_UNDERSCORE "Whether fortran symbols have a trailing double underscore or not." 0 1)
+OMPI_DEF_VAR(OMPI_FORTRAN_SINGLE_UNDERSCORE "Whether fortran symbols have a trailing single underscore or not." 0 1)
+OMPI_DEF_VAR(OMPI_FORTRAN_CAPS "Whether fortran symbols are all caps or not." 0 1)
+OMPI_DEF_VAR(OMPI_FORTRAN_PLAIN "Whether fortran symbols have no trailing underscore or not." 0 1)
 
diff --git a/ompi/CMakeLists.txt b/ompi/CMakeLists.txt
index 44510a86e9..7a08e74456 100644
--- a/ompi/CMakeLists.txt
+++ b/ompi/CMakeLists.txt
@@ -95,7 +95,7 @@ ELSE(OMPI_ENABLE_MPI_PROFILING)
 ENDIF(OMPI_ENABLE_MPI_PROFILING)
 
 
-IF(OMPI_WANT_MPIFH_BINDINGS)
+IF(OMPI_WANT_FORTRAN_BINDINGS)
   # A handful of files in mpi/fortran/base must be included in libmpi, in order to build the
   # Fortran 77 glue into libmpi
   FILE(GLOB OMPI_FORTRAN_BASE_FILES "mpi/fortran/base/*.c")
diff --git a/ompi/mpi/CMakeLists.txt b/ompi/mpi/CMakeLists.txt
index a7d72f2877..ae15443b72 100644
--- a/ompi/mpi/CMakeLists.txt
+++ b/ompi/mpi/CMakeLists.txt
@@ -13,8 +13,8 @@ ELSE(OMPI_WANT_CXX_BINDINGS)
   MESSAGE(STATUS "Skipping MPI C++ interface")
 ENDIF(OMPI_WANT_CXX_BINDINGS)
 
-IF(OMPI_WANT_F77_BINDINGS)
-  ADD_SUBDIRECTORY(f77)
-ELSE(OMPI_WANT_F77_BINDINGS)
-  MESSAGE(STATUS "Skipping MPI F77 interface")
-ENDIF(OMPI_WANT_F77_BINDINGS)
+IF(OMPI_WANT_FORTRAN_BINDINGS)
+  ADD_SUBDIRECTORY(fortran)
+ELSE(OMPI_WANT_FORTRAN_BINDINGS)
+  MESSAGE(STATUS "Skipping MPI FORTRAN interface")
+ENDIF(OMPI_WANT_FORTRAN_BINDINGS)
diff --git a/ompi/tools/CMakeLists.txt b/ompi/tools/CMakeLists.txt
index 76a8dce203..1d51511ff1 100644
--- a/ompi/tools/CMakeLists.txt
+++ b/ompi/tools/CMakeLists.txt
@@ -105,19 +105,19 @@ IF(OMPI_WANT_CXX_BINDINGS)
   CONFIGURE_WRAPPER_DATA_FILE(mpicxx)
 ENDIF(OMPI_WANT_CXX_BINDINGS)
 
-IF(OMPI_WANT_F77_BINDINGS)
+IF(OMPI_WANT_FORTRAN_BINDINGS)
   # select debug or release libraries at configure time
   IF(WINDOWS_VS)
     IF(OMPI_DEBUG_BUILD)
-      SET(OMPI_WRAPPER_EXTRA_LIBS "libmpi_f77d.lib ${OMPI_WRAPPER_BASE_LIBS}")
+      SET(OMPI_WRAPPER_EXTRA_LIBS "libmpi_fortrand.lib ${OMPI_WRAPPER_BASE_LIBS}")
     ELSE(OMPI_DEBUG_BUILD)
-      SET(OMPI_WRAPPER_EXTRA_LIBS "libmpi_f77.lib ${OMPI_WRAPPER_BASE_LIBS}")
+      SET(OMPI_WRAPPER_EXTRA_LIBS "libmpi_fortran.lib ${OMPI_WRAPPER_BASE_LIBS}")
     ENDIF(OMPI_DEBUG_BUILD)
   ELSEIF(WINDOWS_MINGW)
     IF(OMPI_DEBUG_BUILD)
-      SET(OMPI_WRAPPER_EXTRA_LIBS "-lmpi_f77d ${OMPI_WRAPPER_BASE_LIBS}")
+      SET(OMPI_WRAPPER_EXTRA_LIBS "-lmpi_fortrand ${OMPI_WRAPPER_BASE_LIBS}")
     ELSE(OMPI_DEBUG_BUILD)
-      SET(OMPI_WRAPPER_EXTRA_LIBS "-lmpi_f77 ${OMPI_WRAPPER_BASE_LIBS}")
+      SET(OMPI_WRAPPER_EXTRA_LIBS "-lmpi_fortran ${OMPI_WRAPPER_BASE_LIBS}")
     ENDIF(OMPI_DEBUG_BUILD)
   ENDIF(WINDOWS_VS)
 
@@ -126,15 +126,15 @@ IF(OMPI_WANT_F77_BINDINGS)
       "")
   ELSE(BUILD_SHARED_LIBS)
     IF(OMPI_DEBUG_BUILD)
-      SET(OMPI_WRAPPER_EXTRA_FFLAGS "${F77_DYNAMIC_FLAG_DEBUG}")
+      SET(OMPI_WRAPPER_EXTRA_FFLAGS "${FORTRAN_DYNAMIC_FLAG_DEBUG}")
     ELSE(OMPI_DEBUG_BUILD)
-      SET(OMPI_WRAPPER_EXTRA_FFLAGS "${F77_DYNAMIC_FLAG}")
+      SET(OMPI_WRAPPER_EXTRA_FFLAGS "${FORTRAN_DYNAMIC_FLAG}")
     ENDIF(OMPI_DEBUG_BUILD)
   ENDIF(BUILD_SHARED_LIBS)
 
-  CONFIGURE_WRAPPER_DATA_FILE(mpif77)
+  CONFIGURE_WRAPPER_DATA_FILE(mpifortran)
   UNSET(OMPI_WRAPPER_EXTRA_LIBS)
-ENDIF(OMPI_WANT_F77_BINDINGS)
+ENDIF(OMPI_WANT_FORTRAN_BINDINGS)
 
 #IF(OMPI_WANT_F90_BINDINGS)
 #  CONFIGURE_WRAPPER_DATA_FILE(mpif90)
diff --git a/opal/include/CMakeLists.txt b/opal/include/CMakeLists.txt
index 71a118ab8f..c28dc295c4 100644
--- a/opal/include/CMakeLists.txt
+++ b/opal/include/CMakeLists.txt
@@ -20,7 +20,7 @@ STRING(REPLACE "#cmakedefine OMPI_HAVE_FORTRAN_" "#define OMPI_HAVE_FORTRAN_"  M
 STRING(REPLACE "{OMPI_PROVIDE_MPI_FILE_INTERFACE}"
  "{OMPI_PROVIDE_MPI_FILE_INTERFACE_VAL}" MPI_H_OUT "${MPI_H_OUT}")
 STRING(REPLACE "\${OMPI_WANT_CXX_BINDINGS}" "1" MPI_H_OUT "${MPI_H_OUT}")
-STRING(REPLACE "\${OMPI_WANT_F77_BINDINGS}" "1" MPI_H_OUT "${MPI_H_OUT}")
+STRING(REPLACE "\${OMPI_WANT_FORTRAN_BINDINGS}" "1" MPI_H_OUT "${MPI_H_OUT}")
 STRING(REPLACE "\${OMPI_WANT_F90_BINDINGS}" "1" MPI_H_OUT "${MPI_H_OUT}")
 STRING(REPLACE "\${OMPI_WANT_MPI_CXX_SEEK}" "1" MPI_H_OUT "${MPI_H_OUT}")
 STRING(REPLACE "\${OMPI_WANT_MPI_INTERFACE_WARNING}" "1" MPI_H_OUT "${MPI_H_OUT}")
@@ -30,7 +30,7 @@ FILE(WRITE ${OpenMPI_BINARY_DIR}/ompi/include/mpi.h.in "${MPI_H_OUT}")
 # generate mpi.h
 CONFIGURE_FILE(${OpenMPI_BINARY_DIR}/ompi/include/mpi.h.in ${OpenMPI_BINARY_DIR}/ompi/include/mpi.h)
 
-IF(OMPI_WANT_F77_BINDINGS)
+IF(OMPI_WANT_FORTRAN_BINDINGS)
   CONFIGURE_FILE(${OpenMPI_SOURCE_DIR}/ompi/include/mpif.h.in ${OpenMPI_BINARY_DIR}/ompi/include/mpif.h)
   CONFIGURE_FILE(${OpenMPI_SOURCE_DIR}/ompi/include/mpif-config.h.in ${OpenMPI_BINARY_DIR}/ompi/include/mpif-config.h)
-ENDIF(OMPI_WANT_F77_BINDINGS)
+ENDIF(OMPI_WANT_FORTRAN_BINDINGS)
diff --git a/opal/tools/wrappers/CMakeLists.txt b/opal/tools/wrappers/CMakeLists.txt
index af0acd7454..4ead4cf85c 100644
--- a/opal/tools/wrappers/CMakeLists.txt
+++ b/opal/tools/wrappers/CMakeLists.txt
@@ -45,17 +45,17 @@ IF(OMPI_WANT_CXX_BINDINGS)
     DESTINATION bin)
 ENDIF(OMPI_WANT_CXX_BINDINGS)
 
-IF(OMPI_WANT_F77_BINDINGS)
+IF(OMPI_WANT_FORTRAN_BINDINGS)
   ADD_CUSTOM_COMMAND(TARGET opal-wrapper
   POST_BUILD
   COMMAND ${CMAKE_COMMAND} -E copy
   ${OpenMPI_BINARY_DIR}/${CMAKE_CFG_INTDIR}/opal-wrapper${OMPI_EXE_DEBUG_POSTFIX}.exe
-  ${PROJECT_BINARY_DIR}/mpif77${OMPI_EXE_DEBUG_POSTFIX}.exe
-  COMMENT "Copying F77 compiler wrappers...")
+  ${PROJECT_BINARY_DIR}/mpifortran${OMPI_EXE_DEBUG_POSTFIX}.exe
+  COMMENT "Copying FORTRAN compiler wrappers...")
 
-  INSTALL(FILES ${PROJECT_BINARY_DIR}/mpif77${OMPI_EXE_DEBUG_POSTFIX}.exe
+  INSTALL(FILES ${PROJECT_BINARY_DIR}/mpifortran${OMPI_EXE_DEBUG_POSTFIX}.exe
     DESTINATION bin)
-ENDIF(OMPI_WANT_F77_BINDINGS)
+ENDIF(OMPI_WANT_FORTRAN_BINDINGS)
 
 ADD_CUSTOM_COMMAND (TARGET opal-wrapper
   POST_BUILD