[CMake] Fortran-C mixed code (possible solution)

[Radu Serban]

Arjen Markus wrote:
>> But knowing the Fortran name mangling scheme is still crucial (if
>> interested,  see below why). For now I rely on the user to provide the
>> case (lower or upper)  and number of appended underscores (none, one,
>> or two) which determine it. The  defaults I provide (lower case with
>> one underscore) is probably the most common  one, but I'd be much
>> happier if I could automatically determine it at  configuration time...
>> Any suggestions?
>>

> Now the fun part:
> You can simply provide _both_ of these wrappers in your Fortran-compatible
> library. The Fortran compiler will generate a routine with a name that
> depends on its mangling scheme, but the linker will pick out the right
> version.
> 
> The only problem left is Fortran compilers that produce the same
> mangled name but different methods for passing the length of character
> strings.
> Of course, the compatibility library will be bit larger, but it solves
> your problem in what I think an elegant way.

Hi Arjen,

That's not what I want for several reasons:
1) I really think this is something that the build system should take care of. I 
intend to provide cmake only as an alternative to autotools and determining the 
Fortran name mangling scheme with the later is no problem.
2) A typical Fortran-C interface library (and we provide such libraries for 3 
different solvers) contains around 30 different functions which would then 
require 180 wrappers (for all combinations lower/upper case and none/one/two 
underscores)! A nightmare of (unnecessary) code duplication.
3) We distribute our solvers open source and we'd like to keep the sources as 
clean and readable as possible.

In any case, I think I have a solution. I seems to work, but then I've only 
tried it on my Linux box. It's probably not the cleanest implementation (I've 
only started using cmake very recently). I copied the relevant portion of my 
CMakeLists.txt below. I'd appreciate any comments and suggestions, both on 
whether it can be simplified/cleaned-up and also on whether it's portable.

Thanks,
--Radu

   # Enable Fortran support
   ENABLE_LANGUAGE(Fortran)

   # Determine the Fortran name-mangling scheme. We do this by:
   #  1) create a library from a Fortran source file which defines a function 
"sundials"
   #  2) attempt to link with this library a C source file which calls the 
"sundials"
   #     function using various possible schemes (6 different schemes, corresponding
   #     to all combinations lower/upper case and none/one/two underscores)

   SET(HAVE_SCHEME FALSE)

   # Create a CMakeLists.txt file which will generate the "flib" library
   FILE(WRITE ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CMakeLists.txt
     "PROJECT(FortranTest Fortran)\n"
     "SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
     "ADD_LIBRARY(flib ftest.f)\n"
     )

   # Create a simple Fortran source which defines the subroutine "sundials"
   FILE(WRITE ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/ftest.f
     "        SUBROUTINE sundials\n"
     "        RETURN\n"
     "        END\n"
     )

   # Use TRY_COMPILE to make the target "flib"
   TRY_COMPILE(
     FTEST_OK
     ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
     ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
     flib
     OUTPUT_VARIABLE MY_OUTPUT
     )

   # Continue only if we were successful in creating the "flib" library
   IF(FTEST_OK)

     # Overwrite CMakeLists.txt with one which will generate the "ctest" executable
     FILE(WRITE 
${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CMakeLists.txt
       "PROJECT(FortranTest C)\n"
       "#SET(CMAKE_VERBOSE_MAKEFILE ON)\n"
       "ADD_EXECUTABLE(ctest ctest.c)\n"
       "TARGET_LINK_LIBRARIES(ctest \"-L. -lflib\")\n"
       )

     # Define the list "options" of all possible schemes that we want to consider
     # Get its length and initialize the counter "iopt" to zero
     SET(options sundials sundials_ sundials__ SUNDIALS SUNDIALS_ SUNDIALS__)
     LIST(LENGTH options imax)
     SET(iopt 0)

     # We will attempt to sucessfully generate the "ctest" executable as long as
     # there still are entries in the "options" list
     WHILE(${iopt} LESS ${imax})

       # Get the current list entry (current scheme)
       LIST(GET options ${iopt} opt)

       # Generate a simple C source which calls the "sundials" function using the
       # current scheme
       FILE(WRITE ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/ctest.c
         "int main(){${opt}();return(0);}\n"
         )

       # Use TRY_COMPILE to make the "ctest" executable from the current C source
       # and linking to the previously created "flib" library.
       # QUESTION: Is this method of linking the "flib" library portable?
       TRY_COMPILE(
         CTEST_OK
         ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
         ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp
         ctest
         CMAKE_FLAGS -DLINK_LIBRARIES:STRING="-L. -lflib"
         OUTPUT_VARIABLE MY_OUTPUT
         )

       # To ensure we do not use stuff from the previous attempts, we must 
remove the
       # CMakeFiles directory.
       # QUESTION: I didn't think I'll have to do this, but it doesn't work 
otherwise
       FILE(REMOVE_RECURSE 
${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CMakeFiles)

       MESSAGE("${iopt}  ${opt}  ... ${CTEST_OK}")

       # Test if we successfully created the "ctest" executable.
       # If yes, flag that we have successfuly determined the name mangling scheme,
       # save the current scheme, and set the counter "iopt" to "imax" so that we
       # exit the while loop.
       # Otherwise, increment the counter "iopt" and go back in the while loop.
       IF(CTEST_OK)
         SET(SCHEME ${opt})
         SET(HAVE_SCHEME TRUE)
         SET(iopt ${imax})
       ELSE(CTEST_OK)
         MATH(EXPR iopt ${iopt}+1)
       ENDIF(CTEST_OK)

     ENDWHILE(${iopt} LESS ${imax})

   ENDIF(FTEST_OK)

   IF(NOT HAVE_SCHEME)
     message("Unable to determine Fortran name mangling scheme")
   ENDIF(NOT HAVE_SCHEME)