CMake/Modules/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>".
#
# 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>".
#
# 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_().
#
# 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.
#
# 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()

#-----------------------------------------------------------------------------
# Verify that C and Fortran are available.
foreach(lang C Fortran)
  if(NOT CMAKE_${lang}_COMPILER_LOADED)
    message(FATAL_ERROR
      "FortranCInterface requires the ${lang} language to be enabled.")
  endif()
endforeach()

#-----------------------------------------------------------------------------
# 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
    )
  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 "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()

  # 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()
    endforeach()
  endforeach()

  # 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()
      set(FortranCInterface_${scope}_FOUND 0)
    endif()
  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}
${_desc_${macro}}
#define ${MACRO_NAMESPACE}${macro}${FortranCInterface_${macro}_MACRO}
")
    endif()
  endforeach()

  # Generate symbol mangling definitions.
  if(SYMBOLS)
    set(HEADER_CONTENT "${HEADER_CONTENT}
/*--------------------------------------------------------------------------*/
/* Mangle some symbols automatically.                                       */
")
  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)

  # Store the content.
  configure_file(${FortranCInterface_SOURCE_DIR}/Macro.h.in ${FILE} @ONLY)
endfunction()