diff options
| -rw-r--r-- | Modules/FortranCInterface.cmake | 531 | ||||
| -rw-r--r-- | Modules/FortranCInterface.h.in | 9 | ||||
| -rw-r--r-- | Modules/FortranCInterface/CMakeLists.txt | 74 | ||||
| -rw-r--r-- | Modules/FortranCInterface/Input.cmake.in | 3 | ||||
| -rw-r--r-- | Modules/FortranCInterface/Macro.h.in | 4 | ||||
| -rw-r--r-- | Modules/FortranCInterface/Output.cmake.in | 33 | ||||
| -rw-r--r-- | Modules/FortranCInterface/call_mod.f90 | 6 | ||||
| -rw-r--r-- | Modules/FortranCInterface/call_sub.f | 4 | ||||
| -rw-r--r-- | Modules/FortranCInterface/main.F | 6 | ||||
| -rw-r--r-- | Modules/FortranCInterface/my_module.f90 | 8 | ||||
| -rw-r--r-- | Modules/FortranCInterface/my_sub.f | 2 | ||||
| -rw-r--r-- | Modules/FortranCInterface/mymodule.f90 | 8 | ||||
| -rw-r--r-- | Modules/FortranCInterface/mysub.f | 2 | ||||
| -rw-r--r-- | Modules/FortranCInterface/symbol.c.in | 4 | ||||
| -rw-r--r-- | Tests/Fortran/CMakeLists.txt | 72 | ||||
| -rw-r--r-- | Tests/Fortran/myc.c | 2 |
16 files changed, 509 insertions, 259 deletions
diff --git a/Modules/FortranCInterface.cmake b/Modules/FortranCInterface.cmake index 6551658..580f84e 100644 --- a/Modules/FortranCInterface.cmake +++ b/Modules/FortranCInterface.cmake @@ -1,231 +1,334 @@ -# FortranCInterface.cmake +# - Fortran/C Interface Detection +# This module automatically detects the API by which C and Fortran +# languages interact. Variables indicate if the mangling is found: +# FortranCInterface_GLOBAL_FOUND = Global subroutines and functions +# FortranCInterface_MODULE_FOUND = Module subroutines and functions +# (declared by "MODULE PROCEDURE") +# A function is provided to generate a C header file containing macros +# to mangle symbol names: +# FortranCInterface_HEADER(<file> +# [MACRO_NAMESPACE <macro-ns>] +# [SYMBOL_NAMESPACE <ns>] +# [SYMBOLS [<module>:]<function> ...]) +# It generates in <file> definitions of the following macros: +# #define FortranCInterface_GLOBAL (name,NAME) ... +# #define FortranCInterface_GLOBAL_(name,NAME) ... +# #define FortranCInterface_MODULE (mod,name, MOD,NAME) ... +# #define FortranCInterface_MODULE_(mod,name, MOD,NAME) ... +# These macros mangle four categories of Fortran symbols, +# respectively: +# - Global symbols without '_': call mysub() +# - Global symbols with '_' : call my_sub() +# - Module symbols without '_': use mymod; call mysub() +# - Module symbols with '_' : use mymod; call my_sub() +# If mangling for a category is not known, its macro is left undefined. +# All macros require raw names in both lower case and upper case. +# The MACRO_NAMESPACE option replaces the default "FortranCInterface_" +# prefix with a given namespace "<macro-ns>". # -# This file defines the function create_fortran_c_interface. -# this function is used to create a configured header file -# that contains a mapping from C to a Fortran function using -# the correct name mangling scheme as defined by the current -# fortran compiler. +# The SYMBOLS option lists symbols to mangle automatically with C +# preprocessor definitions: +# <function> ==> #define <ns><function> ... +# <module>:<function> ==> #define <ns><module>_<function> ... +# If the mangling for some symbol is not known then no preprocessor +# definition is created, and a warning is displayed. +# The SYMBOL_NAMESPACE option prefixes all preprocessor definitions +# generated by the SYMBOLS option with a given namespace "<ns>". # -# The function tages a list of functions and the name of -# a header file to configure. +# Example usage: +# include(FortranCInterface) +# FortranCInterface_HEADER(FC.h MACRO_NAMESPACE "FC_") +# This creates a "FC.h" header that defines mangling macros +# FC_GLOBAL(), FC_GLOBAL_(), FC_MODULE(), and FC_MODULE_(). # -# This file also defines some helper functions that are used -# to detect the fortran name mangling scheme used by the -# current Fortran compiler. -# test_fortran_mangling - test a single fortran mangling -# discover_fortran_mangling - loop over all combos of fortran -# name mangling and call test_fortran_mangling until one of them -# works. -# discover_fortran_module_mangling - try different types of -# fortran modle name mangling to find one that works +# Example usage: +# include(FortranCInterface) +# FortranCInterface_HEADER(FCMangle.h +# MACRO_NAMESPACE "FC_" +# SYMBOL_NAMESPACE "FC_" +# SYMBOLS mysub mymod:my_sub) +# This creates a "FC.h" header that defines the same FC_*() mangling +# macros as the previous example plus preprocessor symbols FC_mysub +# and FC_mymod_my_sub. # -# -# -# this function tests a single fortran mangling. -# CODE - test code to try should define a subroutine called "sub" -# PREFIX - string to put in front of sub -# POSTFIX - string to put after sub -# ISUPPER - if TRUE then sub will be called as SUB -# DOC - string used in status checking Fortran ${DOC} linkage -# SUB - the name of the SUB to call -# RESULT place to store result TRUE if this linkage works, FALSE -# if not. -# -function(test_fortran_mangling CODE PREFIX ISUPPER POSTFIX DOC SUB RESULT) - if(ISUPPER) - string(TOUPPER "${SUB}" sub) - else(ISUPPER) - string(TOLOWER "${SUB}" sub) - endif(ISUPPER) - set(FUNCTION "${PREFIX}${sub}${POSTFIX}") - # create a fortran file with sub called sub - # - set(TMP_DIR - "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckFortranLink") - file(REMOVE_RECURSE "${TMP_DIR}") - file(WRITE "${TMP_DIR}/test.f" "${CODE}" ) - message(STATUS "checking Fortran ${DOC} linkage: ${FUNCTION}") - file(WRITE "${TMP_DIR}/ctof.c" - " - extern ${FUNCTION}(); - int main() { ${FUNCTION}(); return 0;} - " - ) - file(WRITE "${TMP_DIR}/CMakeLists.txt" - " - project(testf C Fortran) - add_library(flib test.f) - add_executable(ctof ctof.c) - target_link_libraries(ctof flib) - " +# FortranCInterface is aware of possible GLOBAL and MODULE manglings +# for many Fortran compilers, but it also provides an interface to +# specify new possible manglings. Set the variables +# FortranCInterface_GLOBAL_SYMBOLS +# FortranCInterface_MODULE_SYMBOLS +# before including FortranCInterface to specify manglings of the +# symbols "MySub", "My_Sub", "MyModule:MySub", and "My_Module:My_Sub". +# For example, the code: +# set(FortranCInterface_GLOBAL_SYMBOLS mysub_ my_sub__ MYSUB_) +# # ^^^^^ ^^^^^^ ^^^^^ +# set(FortranCInterface_MODULE_SYMBOLS +# __mymodule_MOD_mysub __my_module_MOD_my_sub) +# # ^^^^^^^^ ^^^^^ ^^^^^^^^^ ^^^^^^ +# include(FortranCInterface) +# tells FortranCInterface to try given GLOBAL and MODULE manglings. +# (The carets point at raw symbol names for clarity in this example +# but are not needed.) + +#----------------------------------------------------------------------------- +# Execute at most once in a project. +if(FortranCInterface_SOURCE_DIR) + return() +endif() + +#----------------------------------------------------------------------------- +# Set up an interface detection project. +set(FortranCInterface_SOURCE_DIR ${CMAKE_ROOT}/Modules/FortranCInterface) +set(FortranCInterface_BINARY_DIR ${CMAKE_BINARY_DIR}/CMakeFiles/FortranCInterface) +configure_file(${FortranCInterface_SOURCE_DIR}/Input.cmake.in + ${FortranCInterface_BINARY_DIR}/Input.cmake @ONLY) + +# Detect the Fortran/C interface on the first run or when the +# configuration changes. +if(${FortranCInterface_BINARY_DIR}/Input.cmake + IS_NEWER_THAN ${FortranCInterface_BINARY_DIR}/Output.cmake + OR ${FortranCInterface_SOURCE_DIR}/Output.cmake.in + IS_NEWER_THAN ${FortranCInterface_BINARY_DIR}/Output.cmake + OR ${FortranCInterface_SOURCE_DIR}/CMakeLists.txt + IS_NEWER_THAN ${FortranCInterface_BINARY_DIR}/Output.cmake + OR ${CMAKE_CURRENT_LIST_FILE} + IS_NEWER_THAN ${FortranCInterface_BINARY_DIR}/Output.cmake ) - set(FORTRAN_NAME_MANGLE_TEST FALSE) - try_compile(FORTRAN_NAME_MANGLE_TEST "${TMP_DIR}" "${TMP_DIR}" - testf - OUTPUT_VARIABLE output) - if(FORTRAN_NAME_MANGLE_TEST) - set(${RESULT} TRUE PARENT_SCOPE) + message(STATUS "Detecting Fortran/C Interface") + set(_result) + + # Build a sample project which reports symbols. + try_compile(FortranCInterface_COMPILED + ${FortranCInterface_BINARY_DIR} + ${FortranCInterface_SOURCE_DIR} + FortranCInterface + OUTPUT_VARIABLE FortranCInterface_OUTPUT) + set(FortranCInterface_COMPILED ${FortranCInterface_COMPILED}) + unset(FortranCInterface_COMPILED CACHE) + + # Locate the sample project executable. + if(FortranCInterface_COMPILED) + find_program(FortranCInterface_EXE + NAMES FortranCInterface + PATHS ${FortranCInterface_BINARY_DIR} ${FortranCInterface_BINARY_DIR}/Debug + NO_DEFAULT_PATH + ) + set(FortranCInterface_EXE ${FortranCInterface_EXE}) + unset(FortranCInterface_EXE CACHE) else() - set(${RESULT} FALSE PARENT_SCOPE) + set(_result "Failed to compile") + set(FortranCInterface_EXE) + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log + "Fortran/C interface test project failed with the following output:\n" + "${FortranCInterface_OUTPUT}\n") endif() -endfunction(test_fortran_mangling) - -# this function discovers the name mangling scheme used -# for functions in a fortran module. -function(discover_fortran_module_mangling prefix suffix found) - set(CODE - " - module test_interface - interface dummy - module procedure sub - end interface - contains - subroutine sub - end subroutine - end module test_interface - ") - set(worked FALSE) - foreach(interface - "test_interface$" - "TEST_INTERFACE_mp_" - "_test_interface__" - "__test_interface__" - "__test_interface_NMOD_" - "__test_interface_MOD_") - test_fortran_mangling("${CODE}" "${interface}" - ${FORTRAN_C_MANGLING_UPPERCASE} "" "module" "sub" worked) - if(worked) - # if this is the upper case module match then - # lower case it for the extraction of pre and post strings - if("${interface}" MATCHES "TEST_INTERFACE") - string(TOLOWER "${interface}" interface) + + # Load symbols from INFO:symbol[] strings in the executable. + set(FortranCInterface_SYMBOLS) + if(FortranCInterface_EXE) + file(STRINGS "${FortranCInterface_EXE}" _info_strings + LIMIT_COUNT 8 REGEX "INFO:[^[]*\\[") + foreach(info ${_info_strings}) + if("${info}" MATCHES ".*INFO:symbol\\[([^]]*)\\].*") + string(REGEX REPLACE ".*INFO:symbol\\[([^]]*)\\].*" "\\1" symbol "${info}") + list(APPEND FortranCInterface_SYMBOLS ${symbol}) + endif() + endforeach() + elseif(NOT _result) + set(_result "Failed to load sample executable") + endif() + + set(_case_mysub "LOWER") + set(_case_my_sub "LOWER") + set(_case_MYSUB "UPPER") + set(_case_MY_SUB "UPPER") + set(_global_regex "^(_*)(mysub|MYSUB)([_$]*)$") + set(_global__regex "^(_*)(my_sub|MY_SUB)([_$]*)$") + set(_module_regex "^(_*)(mymodule|MYMODULE)([A-Za-z_$]*)(mysub|MYSUB)([_$]*)$") + set(_module__regex "^(_*)(my_module|MY_MODULE)([A-Za-z_$]*)(my_sub|MY_SUB)([_$]*)$") + + # Parse the symbol names. + foreach(symbol ${FortranCInterface_SYMBOLS}) + foreach(form "" "_") + # Look for global symbols. + string(REGEX REPLACE "${_global_${form}regex}" + "\\1;\\2;\\3" pieces "${symbol}") + list(LENGTH pieces len) + if(len EQUAL 3) + set(FortranCInterface_GLOBAL_${form}SYMBOL "${symbol}") + list(GET pieces 0 FortranCInterface_GLOBAL_${form}PREFIX) + list(GET pieces 1 name) + list(GET pieces 2 FortranCInterface_GLOBAL_${form}SUFFIX) + set(FortranCInterface_GLOBAL_${form}CASE "${_case_${name}}") + endif() + + # Look for module symbols. + string(REGEX REPLACE "${_module_${form}regex}" + "\\1;\\2;\\3;\\4;\\5" pieces "${symbol}") + list(LENGTH pieces len) + if(len EQUAL 5) + set(FortranCInterface_MODULE_${form}SYMBOL "${symbol}") + list(GET pieces 0 FortranCInterface_MODULE_${form}PREFIX) + list(GET pieces 1 module) + list(GET pieces 2 FortranCInterface_MODULE_${form}MIDDLE) + list(GET pieces 3 name) + list(GET pieces 4 FortranCInterface_MODULE_${form}SUFFIX) + set(FortranCInterface_MODULE_${form}CASE "${_case_${name}}") endif() - string(REGEX REPLACE "(.*)test_interface(.*)" "\\1" pre "${interface}") - string(REGEX REPLACE "(.*)test_interface(.*)" "\\2" post "${interface}") - set(${prefix} "${pre}" PARENT_SCOPE) - set(${suffix} "${post}" PARENT_SCOPE) - set(${found} TRUE PARENT_SCOPE) - return() - endif(worked) - endforeach(interface) - if(NOT worked) - message(STATUS "Failed to find C binding to Fortran module functions.") - set(${prefix} "BROKEN_C_FORTRAN_MODULE_BINDING" PARENT_SCOPE) - set(${suffix} "BROKEN_C_FORTRAN_MODULE_BINDING" PARENT_SCOPE) - set(${found} FALSE PARENT_SCOPE) - endif(NOT worked) -endfunction(discover_fortran_module_mangling) - - -function(discover_fortran_mangling prefix isupper suffix extra_under_score - found ) - set(CODE - " - subroutine sub - end subroutine sub - ") - foreach(post "_" "") - foreach(isup FALSE TRUE) - foreach(pre "" "_" "__") - set(worked FALSE) - test_fortran_mangling("${CODE}" "${pre}" ${isup} - "${post}" "function" sub worked ) - if(worked) - message(STATUS "found Fortran function linkage") - set(${isupper} "${isup}" PARENT_SCOPE) - set(${prefix} "${pre}" PARENT_SCOPE) - set(${suffix} "${post}" PARENT_SCOPE) - set(${found} TRUE PARENT_SCOPE) - set(CODE - " - subroutine my_sub - end subroutine my_sub - ") - set(worked FALSE) - test_fortran_mangling("${CODE}" "${pre}" ${isup} - "${post}" "function with _ " my_sub worked ) - if(worked) - set(${extra_under_score} FALSE PARENT_SCOPE) - else(worked) - test_fortran_mangling("${CODE}" "${pre}" ${isup} - "${post}_" "function with _ " my_sub worked ) - if(worked) - set(${extra_under_score} TRUE PARENT_SCOPE) - endif(worked) - endif(worked) - return() - endif() - endforeach() endforeach() endforeach() - set(${found} FALSE PARENT_SCOPE) -endfunction(discover_fortran_mangling) - -function(create_fortran_c_interface NAMESPACE FUNCTIONS HEADER) - if(NOT FORTRAN_C_MANGLING_FOUND) - # find regular fortran function mangling - discover_fortran_mangling(prefix isupper suffix extra_under found) - if(NOT found) - message(SEND_ERROR "Could not find fortran c name mangling.") - return() - endif(NOT found) - # find fortran module function mangling - set(FORTRAN_C_PREFIX "${prefix}" CACHE INTERNAL - "PREFIX for Fortran to c name mangling") - set(FORTRAN_C_SUFFIX "${suffix}" CACHE INTERNAL - "SUFFIX for Fortran to c name mangling") - set(FORTRAN_C_MANGLING_UPPERCASE ${isupper} CACHE INTERNAL - "Was fortran to c mangling found" ) - set(FORTRAN_C_MANGLING_EXTRA_UNDERSCORE ${extra_under} CACHE INTERNAL - "If a function has a _ in the name does the compiler append an extra _" ) - set(FORTRAN_C_MANGLING_FOUND TRUE CACHE INTERNAL - "Was fortran to c mangling found" ) - set(prefix ) - set(suffix ) - set(found FALSE) - # only try this if the compiler is F90 compatible - if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) - discover_fortran_module_mangling(prefix suffix found) - endif(CMAKE_Fortran_COMPILER_SUPPORTS_F90) - if(found) - message(STATUS "found Fortran module linkage") - else(found) - message(STATUS "Failed to find Fortran module linkage") - endif(found) - set(FORTRAN_C_MODULE_PREFIX "${prefix}" CACHE INTERNAL - "PREFIX for Fortran to c name mangling") - set(FORTRAN_C_MODULE_SUFFIX "${suffix}" CACHE INTERNAL - "SUFFIX for Fortran to c name mangling") - set(FORTRAN_C_MODULE_MANGLING_FOUND ${found} CACHE INTERNAL - "Was for Fortran to c name mangling found for modules") - endif(NOT FORTRAN_C_MANGLING_FOUND) - foreach(f ${${FUNCTIONS}}) - if(FORTRAN_C_MANGLING_UPPERCASE) - string(TOUPPER "${f}" fcase) + + # Construct mangling macro definitions. + set(_name_LOWER "name") + set(_name_UPPER "NAME") + foreach(form "" "_") + if(FortranCInterface_GLOBAL_${form}SYMBOL) + if(FortranCInterface_GLOBAL_${form}PREFIX) + set(_prefix "${FortranCInterface_GLOBAL_${form}PREFIX}##") + else() + set(_prefix "") + endif() + if(FortranCInterface_GLOBAL_${form}SUFFIX) + set(_suffix "##${FortranCInterface_GLOBAL_${form}SUFFIX}") + else() + set(_suffix "") + endif() + set(_name "${_name_${FortranCInterface_GLOBAL_${form}CASE}}") + set(FortranCInterface_GLOBAL${form}_MACRO + "(name,NAME) ${_prefix}${_name}${_suffix}") + endif() + if(FortranCInterface_MODULE_${form}SYMBOL) + if(FortranCInterface_MODULE_${form}PREFIX) + set(_prefix "${FortranCInterface_MODULE_${form}PREFIX}##") + else() + set(_prefix "") + endif() + if(FortranCInterface_MODULE_${form}SUFFIX) + set(_suffix "##${FortranCInterface_MODULE_${form}SUFFIX}") + else() + set(_suffix "") + endif() + set(_name "${_name_${FortranCInterface_MODULE_${form}CASE}}") + set(_middle "##${FortranCInterface_MODULE_${form}MIDDLE}##") + set(FortranCInterface_MODULE${form}_MACRO + "(mod_name,name, mod_NAME,NAME) ${_prefix}mod_${_name}${_middle}${_name}${_suffix}") + endif() + endforeach() + + # Summarize what is available. + foreach(scope GLOBAL MODULE) + if(FortranCInterface_${scope}_SYMBOL AND + FortranCInterface_${scope}__SYMBOL) + set(FortranCInterface_${scope}_FOUND 1) else() - string(TOLOWER "${f}" fcase) + set(FortranCInterface_${scope}_FOUND 0) endif() - if("${f}" MATCHES ":") - string(REGEX REPLACE "(.*):(.*)" "\\1" module "${f}") - string(REGEX REPLACE "(.*):(.*)" "\\2" function "${f}") - string(REGEX REPLACE "(.*):(.*)" "\\1" module_case "${fcase}") - string(REGEX REPLACE "(.*):(.*)" "\\2" function_case "${fcase}") + endforeach() + + # Record the detection results. + configure_file(${FortranCInterface_SOURCE_DIR}/Output.cmake.in + ${FortranCInterface_BINARY_DIR}/Output.cmake @ONLY) + file(APPEND ${FortranCInterface_BINARY_DIR}/Output.cmake "\n") + + # Report the results. + if(FortranCInterface_GLOBAL_FOUND) + if(FortranCInterface_MODULE_FOUND) + set(_result "Found GLOBAL and MODULE mangling") + else(FortranCInterface_MODULE_FOUND) + set(_result "Found GLOBAL but not MODULE mangling") + endif() + elseif(NOT _result) + set(_result "Failed to recognize symbols") + endif() + message(STATUS "Detecting Fortran/C Interface - ${_result}") +endif() + +# Load the detection results. +include(${FortranCInterface_BINARY_DIR}/Output.cmake) + +#----------------------------------------------------------------------------- +function(FortranCInterface_HEADER file) + # Parse arguments. + if(IS_ABSOLUTE "${file}") + set(FILE "${file}") + else() + set(FILE "${CMAKE_CURRENT_BINARY_DIR}/${file}") + endif() + set(MACRO_NAMESPACE "FortranCInterface_") + set(SYMBOL_NAMESPACE) + set(SYMBOLS) + set(doing) + foreach(arg ${ARGN}) + if("x${arg}" MATCHES "^x(SYMBOLS|SYMBOL_NAMESPACE|MACRO_NAMESPACE)$") + set(doing "${arg}") + elseif("x${doing}" MATCHES "^x(SYMBOLS)$") + list(APPEND "${doing}" "${arg}") + elseif("x${doing}" MATCHES "^x(SYMBOL_NAMESPACE|MACRO_NAMESPACE)$") + set("${doing}" "${arg}") + set(doing) + else() + message(AUTHOR_WARNING "Unknown argument: \"${arg}\"") + endif() + endforeach() + + # Generate macro definitions. + set(HEADER_CONTENT) + set(_desc_GLOBAL "/* Mangling for Fortran global symbols without underscores. */") + set(_desc_GLOBAL_ "/* Mangling for Fortran global symbols with underscores. */") + set(_desc_MODULE "/* Mangling for Fortran module symbols without underscores. */") + set(_desc_MODULE_ "/* Mangling for Fortran module symbols with underscores. */") + foreach(macro GLOBAL GLOBAL_ MODULE MODULE_) + if(FortranCInterface_${macro}_MACRO) set(HEADER_CONTENT "${HEADER_CONTENT} -#define ${NAMESPACE}${module}_${function} ${FORTRAN_C_MODULE_PREFIX}${module_case}${FORTRAN_C_MODULE_SUFFIX}${function_case} +${_desc_${macro}} +#define ${MACRO_NAMESPACE}${macro}${FortranCInterface_${macro}_MACRO} ") - else("${f}" MATCHES ":") - set(function "${FORTRAN_C_PREFIX}${fcase}${FORTRAN_C_SUFFIX}") - if("${f}" MATCHES "_" AND FORTRAN_C_MANGLING_EXTRA_UNDERSCORE) - set(function "${function}_") - endif("${f}" MATCHES "_" AND FORTRAN_C_MANGLING_EXTRA_UNDERSCORE) - set(HEADER_CONTENT "${HEADER_CONTENT} -#define ${NAMESPACE}${f} ${function} + endif() + endforeach() + + # Generate symbol mangling definitions. + if(SYMBOLS) + set(HEADER_CONTENT "${HEADER_CONTENT} +/*--------------------------------------------------------------------------*/ +/* Mangle some symbols automatically. */ ") - endif("${f}" MATCHES ":") + endif() + foreach(f ${SYMBOLS}) + if("${f}" MATCHES ":") + # Module symbol name. Parse "<module>:<function>" syntax. + string(REPLACE ":" ";" pieces "${f}") + list(GET pieces 0 module) + list(GET pieces 1 function) + string(TOUPPER "${module}" m_upper) + string(TOLOWER "${module}" m_lower) + string(TOUPPER "${function}" f_upper) + string(TOLOWER "${function}" f_lower) + if("${function}" MATCHES "_") + set(form "_") + else() + set(form "") + endif() + if(FortranCInterface_MODULE${form}_MACRO) + set(HEADER_CONTENT "${HEADER_CONTENT}#define ${SYMBOL_NAMESPACE}${module}_${function} ${MACRO_NAMESPACE}MODULE${form}(${m_lower},${f_lower}, ${m_upper},${f_upper})\n") + else() + message(AUTHOR_WARNING "No FortranCInterface mangling known for ${f}") + endif() + else() + # Global symbol name. + if("${f}" MATCHES "_") + set(form "_") + else() + set(form "") + endif() + string(TOUPPER "${f}" f_upper) + string(TOLOWER "${f}" f_lower) + if(FortranCInterface_GLOBAL${form}_MACRO) + set(HEADER_CONTENT "${HEADER_CONTENT}#define ${SYMBOL_NAMESPACE}${f} ${MACRO_NAMESPACE}GLOBAL${form}(${f_lower}, ${f_upper})\n") + else() + message(AUTHOR_WARNING "No FortranCInterface mangling known for ${f}") + endif() + endif() endforeach(f) - configure_file( - "${CMAKE_ROOT}/Modules/FortranCInterface.h.in" - ${HEADER} @ONLY) - message(STATUS "created ${HEADER}") -endfunction() + # Store the content. + configure_file(${FortranCInterface_SOURCE_DIR}/Macro.h.in ${FILE} @ONLY) +endfunction() diff --git a/Modules/FortranCInterface.h.in b/Modules/FortranCInterface.h.in deleted file mode 100644 index 0250175..0000000 --- a/Modules/FortranCInterface.h.in +++ /dev/null @@ -1,9 +0,0 @@ -/* This file is automatically generated by CMake, DO NOT EDIT. - It contains a mapping from Fortran functions so they can - be called from C or C++. */ - - -@HEADER_CONTENT@ - - - diff --git a/Modules/FortranCInterface/CMakeLists.txt b/Modules/FortranCInterface/CMakeLists.txt new file mode 100644 index 0000000..4bc7a10 --- /dev/null +++ b/Modules/FortranCInterface/CMakeLists.txt @@ -0,0 +1,74 @@ +cmake_minimum_required(VERSION 2.6.3) +project(FortranCInterface C Fortran) +include(${FortranCInterface_BINARY_DIR}/Input.cmake OPTIONAL) + +# Check if the C compiler supports '$' in identifiers. +include(CheckCSourceCompiles) +check_c_source_compiles(" +extern int dollar$(void); +int main() { return 0; } +" C_SUPPORTS_DOLLAR) + +# List manglings of global symbol names to try. +set(global_symbols + my_sub_ # GNU, Intel, HP, SunPro, MIPSpro + my_sub # VisualAge + mysub_ # GNU, Intel, HP, SunPro, MIPSpro + mysub # VisualAge + ${FortranCInterface_GLOBAL_SYMBOLS} + ) +list(REMOVE_DUPLICATES global_symbols) + +# List manglings of module symbol names to try. +set(module_symbols + __my_module_MOD_my_sub # GNU + __my_module_NMOD_my_sub # VisualAge + __mymodule_MOD_mysub # GNU + __mymodule_NMOD_mysub # VisualAge + my_module$my_sub # HP + my_module_mp_my_sub_ # Intel + mymodule$mysub # HP + mymodule_mp_mysub_ # Intel + ${FortranCInterface_MODULE_SYMBOLS} + ) +list(REMOVE_DUPLICATES module_symbols) + +# Note that some compiler manglings cannot be invoked from C: +# MIPSpro uses "MY_SUB.in.MY_MODULE" +# SunPro uses "my_module.my_sub_" + +# Add module symbols only with Fortran90. +if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) + set(myfort_modules mymodule.f90 my_module.f90) + set(call_mod call_mod.f90) + set_property(SOURCE main.F PROPERTY COMPILE_DEFINITIONS CALL_MOD) +else() + set(module_symbols) +endif() + +# Generate C symbol sources. +foreach(symbol IN LISTS global_symbols module_symbols) + # Skip symbols with '$' if C cannot handle them. + if(C_SUPPORTS_DOLLAR OR NOT "${symbol}" MATCHES "\\$") + if("${symbol}" MATCHES "SUB") + set(upper "-UPPER") + else() + set(upper) + endif() + string(REPLACE "$" "S" name "${symbol}") + set(source ${CMAKE_CURRENT_BINARY_DIR}/symbols/${name}${upper}.c) + configure_file(${CMAKE_CURRENT_SOURCE_DIR}/symbol.c.in ${source} @ONLY) + list(APPEND symbol_sources ${source}) + endif() +endforeach() + +# Provide symbols through Fortran. +add_library(myfort STATIC mysub.f my_sub.f ${myfort_modules}) + +# Provide symbols through C but fall back to Fortran. +add_library(symbols STATIC ${symbol_sources}) +target_link_libraries(symbols myfort) + +# Require symbols through Fortran. +add_executable(FortranCInterface main.F call_sub.f ${call_mod}) +target_link_libraries(FortranCInterface symbols) diff --git a/Modules/FortranCInterface/Input.cmake.in b/Modules/FortranCInterface/Input.cmake.in new file mode 100644 index 0000000..f261e3b --- /dev/null +++ b/Modules/FortranCInterface/Input.cmake.in @@ -0,0 +1,3 @@ +set(CMAKE_Fortran_COMPILER_ID "@CMAKE_Fortran_COMPILER_ID@") +set(FortranCInterface_GLOBAL_SYMBOLS "@FortranCInterface_GLOBAL_SYMBOLS@") +set(FortranCInterface_MODULE_SYMBOLS "@FortranCInterface_MODULE_SYMBOLS@") diff --git a/Modules/FortranCInterface/Macro.h.in b/Modules/FortranCInterface/Macro.h.in new file mode 100644 index 0000000..d015a62 --- /dev/null +++ b/Modules/FortranCInterface/Macro.h.in @@ -0,0 +1,4 @@ +#ifndef @MACRO_NAMESPACE@HEADER_INCLUDED +#define @MACRO_NAMESPACE@HEADER_INCLUDED +@HEADER_CONTENT@ +#endif diff --git a/Modules/FortranCInterface/Output.cmake.in b/Modules/FortranCInterface/Output.cmake.in new file mode 100644 index 0000000..bce410e --- /dev/null +++ b/Modules/FortranCInterface/Output.cmake.in @@ -0,0 +1,33 @@ +# Global symbol without underscore. +set(FortranCInterface_GLOBAL_SYMBOL "@FortranCInterface_GLOBAL_SYMBOL@") +set(FortranCInterface_GLOBAL_PREFIX "@FortranCInterface_GLOBAL_PREFIX@") +set(FortranCInterface_GLOBAL_SUFFIX "@FortranCInterface_GLOBAL_SUFFIX@") +set(FortranCInterface_GLOBAL_CASE "@FortranCInterface_GLOBAL_CASE@") +set(FortranCInterface_GLOBAL_MACRO "@FortranCInterface_GLOBAL_MACRO@") + +# Global symbol with underscore. +set(FortranCInterface_GLOBAL__SYMBOL "@FortranCInterface_GLOBAL__SYMBOL@") +set(FortranCInterface_GLOBAL__PREFIX "@FortranCInterface_GLOBAL__PREFIX@") +set(FortranCInterface_GLOBAL__SUFFIX "@FortranCInterface_GLOBAL__SUFFIX@") +set(FortranCInterface_GLOBAL__CASE "@FortranCInterface_GLOBAL__CASE@") +set(FortranCInterface_GLOBAL__MACRO "@FortranCInterface_GLOBAL__MACRO@") + +# Module symbol without underscore. +set(FortranCInterface_MODULE_SYMBOL "@FortranCInterface_MODULE_SYMBOL@") +set(FortranCInterface_MODULE_PREFIX "@FortranCInterface_MODULE_PREFIX@") +set(FortranCInterface_MODULE_MIDDLE "@FortranCInterface_MODULE_MIDDLE@") +set(FortranCInterface_MODULE_SUFFIX "@FortranCInterface_MODULE_SUFFIX@") +set(FortranCInterface_MODULE_CASE "@FortranCInterface_MODULE_CASE@") +set(FortranCInterface_MODULE_MACRO "@FortranCInterface_MODULE_MACRO@") + +# Module symbol with underscore. +set(FortranCInterface_MODULE__SYMBOL "@FortranCInterface_MODULE__SYMBOL@") +set(FortranCInterface_MODULE__PREFIX "@FortranCInterface_MODULE__PREFIX@") +set(FortranCInterface_MODULE__MIDDLE "@FortranCInterface_MODULE__MIDDLE@") +set(FortranCInterface_MODULE__SUFFIX "@FortranCInterface_MODULE__SUFFIX@") +set(FortranCInterface_MODULE__CASE "@FortranCInterface_MODULE__CASE@") +set(FortranCInterface_MODULE__MACRO "@FortranCInterface_MODULE__MACRO@") + +# Summarize what was found. +set(FortranCInterface_GLOBAL_FOUND @FortranCInterface_GLOBAL_FOUND@) +set(FortranCInterface_MODULE_FOUND @FortranCInterface_MODULE_FOUND@) diff --git a/Modules/FortranCInterface/call_mod.f90 b/Modules/FortranCInterface/call_mod.f90 new file mode 100644 index 0000000..9b6af64 --- /dev/null +++ b/Modules/FortranCInterface/call_mod.f90 @@ -0,0 +1,6 @@ +subroutine call_mod + use mymodule + use my_module + call mysub() + call my_sub() +end subroutine call_mod diff --git a/Modules/FortranCInterface/call_sub.f b/Modules/FortranCInterface/call_sub.f new file mode 100644 index 0000000..ce3d50b --- /dev/null +++ b/Modules/FortranCInterface/call_sub.f @@ -0,0 +1,4 @@ + subroutine call_sub + call mysub() + call my_sub() + end diff --git a/Modules/FortranCInterface/main.F b/Modules/FortranCInterface/main.F new file mode 100644 index 0000000..84991b0 --- /dev/null +++ b/Modules/FortranCInterface/main.F @@ -0,0 +1,6 @@ + program main + call call_sub() +#ifdef CALL_MOD + call call_mod() +#endif + end diff --git a/Modules/FortranCInterface/my_module.f90 b/Modules/FortranCInterface/my_module.f90 new file mode 100644 index 0000000..82713b4 --- /dev/null +++ b/Modules/FortranCInterface/my_module.f90 @@ -0,0 +1,8 @@ +module my_module + interface my_interface + module procedure my_sub + end interface +contains + subroutine my_sub + end subroutine my_sub +end module my_module diff --git a/Modules/FortranCInterface/my_sub.f b/Modules/FortranCInterface/my_sub.f new file mode 100644 index 0000000..247ba06 --- /dev/null +++ b/Modules/FortranCInterface/my_sub.f @@ -0,0 +1,2 @@ + subroutine my_sub + end diff --git a/Modules/FortranCInterface/mymodule.f90 b/Modules/FortranCInterface/mymodule.f90 new file mode 100644 index 0000000..ef6281a --- /dev/null +++ b/Modules/FortranCInterface/mymodule.f90 @@ -0,0 +1,8 @@ +module mymodule + interface myinterface + module procedure mysub + end interface +contains + subroutine mysub + end subroutine mysub +end module mymodule diff --git a/Modules/FortranCInterface/mysub.f b/Modules/FortranCInterface/mysub.f new file mode 100644 index 0000000..1c27ff4 --- /dev/null +++ b/Modules/FortranCInterface/mysub.f @@ -0,0 +1,2 @@ + subroutine mysub + end diff --git a/Modules/FortranCInterface/symbol.c.in b/Modules/FortranCInterface/symbol.c.in new file mode 100644 index 0000000..369fa45 --- /dev/null +++ b/Modules/FortranCInterface/symbol.c.in @@ -0,0 +1,4 @@ +const char* @symbol@(void) +{ + return "INFO:symbol[@symbol@]"; +} diff --git a/Tests/Fortran/CMakeLists.txt b/Tests/Fortran/CMakeLists.txt index c435faa..312b4d7 100644 --- a/Tests/Fortran/CMakeLists.txt +++ b/Tests/Fortran/CMakeLists.txt @@ -15,47 +15,48 @@ function(test_fortran_c_interface_module) # test the C to Fortran interface module include(FortranCInterface) if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) - if(FORTRAN_C_MODULE_MANGLING_FOUND) + if(NOT CMAKE_Fortran_COMPILER_ID MATCHES "SunPro|MIPSpro") + set(module_expected 1) + endif() + if(FortranCInterface_MODULE_FOUND OR module_expected) set(srcs foo.f) set(FORTRAN_FUNCTIONS test_mod:sub) - else(FORTRAN_C_MODULE_MANGLING_FOUND) - if(CMAKE_Fortran_COMPILER_ID MATCHES "SunPro|MIPSpro") - message("${CMAKE_Fortran_COMPILER_ID} compilers do not support" - " linking Fortran module procedures from C") - else() - message("This will fail, but let the user see the error") - set(srcs foo.f) - set(FORTRAN_FUNCTIONS test_mod:sub) - endif() - endif(FORTRAN_C_MODULE_MANGLING_FOUND) + set(MYC_DEFS TEST_MOD) + else() + message("${CMAKE_Fortran_COMPILER_ID} compilers do not support" + " linking Fortran module procedures from C") + endif() endif() - set(FORTRAN_FUNCTIONS ${FORTRAN_FUNCTIONS} my_sub mysub ) - create_fortran_c_interface("F_" FORTRAN_FUNCTIONS - "${testf_BINARY_DIR}/foo.h") + list(APPEND FORTRAN_FUNCTIONS my_sub mysub) + FortranCInterface_HEADER(foo.h + MACRO_NAMESPACE "FC_" + SYMBOL_NAMESPACE "F_" + SYMBOLS ${FORTRAN_FUNCTIONS} + ) include_directories("${testf_BINARY_DIR}") - + # if the name mangling is not found for a F90 compiler # print out some diagnostic stuff for the dashboard - if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) - if(NOT FORTRAN_C_MODULE_MANGLING_FOUND) - file(GLOB_RECURSE O_OBJFILES - "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckFortranLink/*.o" - "*.o" ) - file(GLOB_RECURSE OBJ_OBJFILES - "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckFortranLink/*.obj") - find_program(DUMPBIN dumpbin) - find_program(NM nm) - foreach(ofile ${O_OBJFILES} ${OBJ_OBJFILES}) - if(DEPENDS) - execute_process(COMMAND ${DUMPBIN} /symbols "${ofile}" - OUTPUT_VARIABLE out) - message("symbols in ${ofile}:\n${out}") - endif() - if(NM) - execute_process(COMMAND ${NM} "${ofile}" OUTPUT_VARIABLE out) - message("symbols in ${ofile}:\n${out}") - endif() - endforeach() + if(NOT FortranCInterface_GLOBAL_FOUND OR + (NOT FortranCInterface_MODULE_FOUND AND module_expected) ) + find_program(FortranCInterface_EXE + NAMES FortranCInterface + PATHS ${FortranCInterface_BINARY_DIR} ${FortranCInterface_BINARY_DIR}/Debug + NO_DEFAULT_PATH + ) + find_program(DUMPBIN dumpbin) + find_program(NM nm) + if(FortranCInterface_EXE) + if(DEPENDS) + execute_process(COMMAND ${DUMPBIN} /symbols "${FortranCInterface_EXE}" + OUTPUT_VARIABLE out) + message("symbols in ${FortranCInterface_EXE}:\n${out}") + endif() + if(NM) + execute_process(COMMAND ${NM} "${FortranCInterface_EXE}" + OUTPUT_VARIABLE out) + message("symbols in ${FortranCInterface_EXE}:\n${out}") + endif() endif() endif() message("Fortran = ${CMAKE_Fortran_COMPILER_ID}") @@ -65,6 +66,7 @@ function(test_fortran_c_interface_module) add_library(myc myc.c) target_link_libraries(myc myfort) + set_property(TARGET myc PROPERTY COMPILE_DEFINITIONS ${MYC_DEFS}) add_library(mycxx mycxx.cxx) target_link_libraries(mycxx myc) diff --git a/Tests/Fortran/myc.c b/Tests/Fortran/myc.c index b817dff..efd9b68 100644 --- a/Tests/Fortran/myc.c +++ b/Tests/Fortran/myc.c @@ -5,7 +5,7 @@ int myc(void) { F_mysub(); F_my_sub(); -#ifdef F_test_mod_sub +#ifdef TEST_MOD F_test_mod_sub(); #endif return 0; |