Change f77 to fortran for the rest of windows build files.
This commit was SVN r26558.
Этот коммит содержится в:
Shiqing Fan
родитель
166d254d4e
Коммит
aa6cde9886
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
ENDMACRO(OMPI_FORTRAN_CHECK_TYPE TYPE HAVE_TYPE)
|
||||
@ -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)
|
||||
ENDMACRO(OMPI_FORTRAN_MAKE_C_FUNCTION OUTPUT_VARIABLE FUNCTION_NAME)
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
ENDMACRO(OMPI_FORTRAN_GET_SIZEOF TYPE OUTPUT_VARIABLE)
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
|
||||
@ -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")
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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
|
||||
|
||||
Загрузка…
x
Ссылка в новой задаче
Block a user