cmake_minimum_required (VERSION 3.0) project(testf C CXX Fortran) if(NOT DEFINED CMake_TEST_NESTED_MAKE_PROGRAM AND NOT CMAKE_GENERATOR MATCHES "Visual Studio") set(CMake_TEST_NESTED_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}") endif() message("CTEST_FULL_OUTPUT ") set(CMAKE_VERBOSE_MAKEFILE 1) message("ENV_FLAGS = $ENV{FFLAGS}") message("CMAKE_Fortran_COMPILER_INIT = ${CMAKE_Fortran_COMPILER_INIT}") message("CMAKE_Fortran_COMPILER_FULLPATH = ${CMAKE_Fortran_COMPILER_FULLPATH}") message("CMAKE_Fortran_COMPILER = ${CMAKE_Fortran_COMPILER}") message("CMAKE_Fortran_FLAGS = ${CMAKE_Fortran_FLAGS}") set(_SHARED SHARED) if(CMAKE_Fortran_COMPILER_ID MATCHES "^(XL|VisualAge)$") # We do not implement SHARED Fortran libs on AIX yet! # Workaround: Set LINKER_LANGUAGE to C, which uses 'xlc' and Fortran implicits. set(_SHARED STATIC) elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU") # g77 2.96 does not support shared libs on Itanium because g2c is not -fPIC execute_process(COMMAND ${CMAKE_Fortran_COMPILER} --version OUTPUT_VARIABLE output ERROR_VARIABLE output) if("${output}" MATCHES "Red Hat .* 2\\.96") set(_SHARED STATIC) endif() endif() # Pick a module .def file with the properly mangled symbol name. set(world_def "") if(WIN32 AND NOT CYGWIN) if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU") set(world_def world_gnu.def) elseif(CMAKE_Fortran_COMPILER_ID MATCHES "Intel" OR CMAKE_GENERATOR MATCHES "Visual Studio") # Intel plugin set(world_def world_icl.def) endif() endif() add_library(hello STATIC hello.f) add_library(world ${_SHARED} world.f ${world_def}) add_executable(testf testf.f) target_link_libraries(testf hello world) function(test_fortran_c_interface_module) message(STATUS "Testing FortranCInterface module") # test the C to Fortran interface module include(FortranCInterface) FortranCInterface_VERIFY() FortranCInterface_VERIFY(CXX) if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) if(NOT CMAKE_Fortran_COMPILER_ID MATCHES "SunPro|MIPSpro|PathScale|Absoft") set(module_expected 1) endif() if(FortranCInterface_MODULE_FOUND OR module_expected) set(srcs foo.f) set(FORTRAN_FUNCTIONS test_mod:sub) set(MYC_DEFS TEST_MOD) else() message("${CMAKE_Fortran_COMPILER_ID} compilers do not support" " linking Fortran module procedures from C") endif() endif() 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(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}") message("C = ${CMAKE_C_COMPILER_ID}") add_library(myfort mysub.f ${srcs}) 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) add_executable(mainc mainc.c) target_link_libraries(mainc myc) add_executable(maincxx maincxx.c) target_link_libraries(maincxx mycxx) # print out some stuff to help debug on machines via cdash file(READ "${testf_BINARY_DIR}/foo.h" fooh) message("foo.h contents:\n${fooh}") endfunction() # if the id's match or the compilers are compatible, then # call the test_fortran_c_interface_module function if("${CMAKE_Fortran_COMPILER_ID}:${CMAKE_C_COMPILER_ID}" MATCHES "(Intel:MSVC|Absoft:GNU)" OR (CMAKE_Fortran_COMPILER_ID MATCHES CMAKE_C_COMPILER_ID )) test_fortran_c_interface_module() else() message("Fortran does not match c compiler") message("Fortran = ${CMAKE_Fortran_COMPILER_ID}") message("C = ${CMAKE_C_COMPILER_ID}") # hack to make g77 work after CL has been enabled # as a languge, cmake needs language specific versions # of these variables.... if(WIN32 AND CMAKE_Fortran_COMPILER_ID MATCHES "GNU") set(CMAKE_CREATE_CONSOLE_EXE ) set(CMAKE_LIBRARY_PATH_FLAG "-L") set(CMAKE_LINK_LIBRARY_FLAG "-l") set(CMAKE_LINK_LIBRARY_SUFFIX ) endif() # gnu and sunpro do not use the same flags here... # however if LDFLAGS is used to set -m64 it causes odd stuf # with the fortran build if( (CMAKE_C_COMPILER_ID MATCHES "GNU") AND (CMAKE_Fortran_COMPILER_ID MATCHES "SunPro")) set(CMAKE_EXE_LINKER_FLAGS "") set(CMAKE_Fortran_FLAGS "") endif() endif() set(TEST_MODULE_DEPENDS 0) if(CMAKE_Fortran_COMPILER_SUPPORTS_F90) add_executable(test_module test_module_main.f90 test_module_implementation.f90 test_module_interface.f90) add_executable(test_use_in_comment_fixedform test_use_in_comment_fixedform.f) set_property(SOURCE test_use_in_comment_fixedform.f PROPERTY Fortran_FORMAT FIXED) add_executable(test_use_in_comment_freeform test_use_in_comment_freeform.f90) set_property(SOURCE test_use_in_comment_freeform.f90 PROPERTY Fortran_FORMAT FREE) add_executable(test_in_interface in_interface/main.f90 in_interface/module.f90) add_definitions(-DFOO -DBAR=1) include_directories(${testf_SOURCE_DIR}/include) add_executable(test_preprocess test_preprocess.F90) set(TEST_MODULE_DEPENDS 1) endif() if(TEST_MODULE_DEPENDS) # Build the external project separately using a custom target. # Make sure it uses the same build configuration as this test. if(CMAKE_CONFIGURATION_TYPES) set(External_CONFIG_TYPE -C "${CMAKE_CFG_INTDIR}") set(External_BUILD_TYPE) else() set(External_CONFIG_TYPE) set(External_BUILD_TYPE -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}) endif() set(External_SOURCE_DIR "${testf_SOURCE_DIR}/External") set(External_BINARY_DIR "${testf_BINARY_DIR}/External") if("${testf_BINARY_DIR}" MATCHES " ") # Our build tree has a space, so the build tool supports spaces. # Test using modules from a path with spaces. set(External_BINARY_DIR "${External_BINARY_DIR} Build") endif() add_custom_command( OUTPUT ${testf_BINARY_DIR}/ExternalProject COMMAND ${CMAKE_CTEST_COMMAND} ARGS ${External_CONFIG_TYPE} --build-and-test ${External_SOURCE_DIR} ${External_BINARY_DIR} --build-noclean --build-two-config --build-project ExtFort --build-generator ${CMAKE_GENERATOR} --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}" --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}" --build-options -DCMAKE_Fortran_COMPILER:STRING=${CMAKE_Fortran_COMPILER} -DCMAKE_Fortran_FLAGS:STRING=${CMAKE_Fortran_FLAGS} -DCMAKE_Fortran_FLAGS_DEBUG:STRING=${CMAKE_Fortran_FLAGS_DEBUG} -DCMAKE_Fortran_FLAGS_RELEASE:STRING=${CMAKE_Fortran_FLAGS_RELEASE} -DCMAKE_Fortran_FLAGS_MINSIZEREL:STRING=${CMAKE_Fortran_FLAGS_MINSIZEREL} -DCMAKE_Fortran_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_Fortran_FLAGS_RELWITHDEBINFO} -DCMAKE_MAKE_PROGRAM:FILEPATH=${CMake_TEST_NESTED_MAKE_PROGRAM} ${External_BUILD_TYPE} VERBATIM ) add_custom_target(ExternalTarget ALL DEPENDS ${testf_BINARY_DIR}/ExternalProject) # Test module output directory if available. if(CMAKE_Fortran_MODDIR_FLAG) set(Library_MODDIR "${testf_BINARY_DIR}/Library/modules") else() set(Library_MODDIR "${testf_BINARY_DIR}/Library") endif() add_subdirectory(Library) add_subdirectory(Executable) endif()