Merge pull request #569 from thelfer/556-cmake-export-compile-flags-i…

…n-dedicated-variables

Fix Issue #556

CMakeLists.txt

@@ -694,12 +694,16 @@ endif(install-system-libraries)
 
 # install tfel-modules-common.cmake
 
+configure_file(${PROJECT_SOURCE_DIR}/cmake/modules/tfel-modules-common.cmake.in
+               ${PROJECT_BINARY_DIR}/cmake/modules/tfel-modules-common.cmake
+               @ONLY)
+
 if(TFEL_APPEND_SUFFIX)
-  install(FILES cmake/modules/tfel-modules-common.cmake
+  install(FILES ${PROJECT_SOURCE_DIR}/cmake/modules/tfel-modules-common.cmake
           DESTINATION "share/tfel-${TFEL_SUFFIX}/cmake"
           COMPONENT core)
 else(TFEL_APPEND_SUFFIX)
-  install(FILES cmake/modules/tfel-modules-common.cmake
+  install(FILES ${PROJECT_SOURCE_DIR}/cmake/modules/tfel-modules-common.cmake
           DESTINATION "share/tfel/cmake"
           COMPONENT core)
 endif(TFEL_APPEND_SUFFIX)

cmake/modules/CodeCoverage.cmake

@@ -86,11 +86,11 @@ IF(NOT CMAKE_COMPILER_IS_GNUCXX)
 	ENDIF()
 ENDIF() # NOT CMAKE_COMPILER_IS_GNUCXX
 
-SET(CMAKE_CXX_FLAGS_COVERAGE
+SET(TFEL_CMAKE_CXX_FLAGS_COVERAGE
     "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
     CACHE STRING "Flags used by the C++ compiler during coverage builds."
     FORCE )
-SET(CMAKE_C_FLAGS_COVERAGE
+SET(TFEL_CMAKE_C_FLAGS_COVERAGE
     "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
     CACHE STRING "Flags used by the C compiler during coverage builds."
     FORCE )

cmake/modules/compiler.cmake

@@ -131,12 +131,16 @@ option(enable-fast-math "enable -ffast-math compiler flag" OFF)
 option(PATHSCALE_COMPILER "set true if using the PathScale compiler" OFF)
 
 if(NOT USE_EXTERNAL_COMPILER_FLAGS)
-  set(CMAKE_C_FLAGS           "")
-  set(CMAKE_C_FLAGS_RELEASE "")
-  set(CMAKE_C_FLAGS_DEBUG   "")
-  set(CMAKE_CXX_FLAGS         "")
-  set(CMAKE_CXX_FLAGS_RELEASE "")
-  set(CMAKE_CXX_FLAGS_DEBUG   "")
+  set(CMAKE_C_FLAGS             "")
+  set(CMAKE_C_FLAGS_RELEASE     "")
+  set(CMAKE_C_FLAGS_DEBUG       "")
+  set(CMAKE_C_FLAGS_PROFILING   "")
+  set(CMAKE_C_FLAGS_COVERAGE    "")
+  set(CMAKE_CXX_FLAGS           "")
+  set(CMAKE_CXX_FLAGS_RELEASE   "")
+  set(CMAKE_CXX_FLAGS_DEBUG     "")
+  set(CMAKE_CX_FLAGS_PROFILING  "")
+  set(CMAKE_CXX_FLAGS_COVERAGE  "")
 endif(NOT USE_EXTERNAL_COMPILER_FLAGS)
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -186,6 +190,39 @@ add_definitions("-DCOMPILER_WARNINGS=\\\"\"${COMPILER_WARNINGS}\"\\\"")
 add_definitions("-DCOMPILER_FLAGS=\\\"\"${COMPILER_FLAGS}\"\\\"")
 add_definitions("-DCOMPILER_CXXFLAGS=\\\"\"${COMPILER_CXXFLAGS}\"\\\"")
 
+# export variables defining compilation options as cmake lists
+set(TFEL_COMPILER_FLAGS      "${COMPILER_FLAGS}")
+set(TFEL_COMPILER_CXXFLAGS   "${COMPILER_CXXFLAGS}")
+set(TFEL_COMPILER_WARNINGS   "${COMPILER_WARNINGS}")
+set(TFEL_OPTIMISATION_FLAGS0 "${OPTIMISATION_FLAGS0}")
+set(TFEL_OPTIMISATION_FLAGS  "${OPTIMISATION_FLAGS}")
+set(TFEL_OPTIMISATION_FLAGS2 "${OPTIMISATION_FLAGS2}")
+separate_arguments(TFEL_COMPILER_FLAGS)
+separate_arguments(TFEL_COMPILER_CXXFLAGS)
+separate_arguments(TFEL_COMPILER_WARNINGS)
+separate_arguments(TFEL_OPTIMISATION_FLAGS0)
+separate_arguments(TFEL_OPTIMISATION_FLAGS)
+separate_arguments(TFEL_OPTIMISATION_FLAGS2)
+
+set(TFEL_CMAKE_C_FLAGS "${COMPILER_FLAGS} ${COMPILER_CFLAGS}")
+set(TFEL_CMAKE_CXX_FLAGS "${VISIBILITY_FLAGS} ${COMPILER_WARNINGS} ${COMPILER_FLAGS} ${COMPILER_CXXFLAGS}")
+if(CMAKE_BUILD_TYPE STREQUAL "Profiling")
+  set(TFEL_CMAKE_CXX_FLAGS_PROFILING "${OPTIMISATION_FLAGS} ${TFEL_CMAKE_CXX_FLAGS_PROFILING}")
+  if(NOT enable-portable-build)
+    set(TFEL_CMAKE_CXX_FLAGS_PROFILING "${OPTIMISATION_FLAGS_MARCH} ${TFEL_CMAKE_CXX_FLAGS_PROFILING}")
+  endif(NOT enable-portable-build)
+elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
+  set(TFEL_CMAKE_CXX_FLAGS_RELEASE "${OPTIMISATION_FLAGS} ${TFEL_CMAKE_CXX_FLAGS_RELEASE}")
+  if(NOT enable-portable-build)
+    set(TFEL_CMAKE_CXX_FLAGS_RELEASE "${OPTIMISATION_FLAGS_MARCH} ${TFEL_CMAKE_CXX_FLAGS_RELEASE}")
+  endif(NOT enable-portable-build)
+else(CMAKE_BUILD_TYPE STREQUAL "Profiling")
+  set(TFEL_CMAKE_CXX_FLAGS "${OPTIMISATION_FLAGS} ${TFEL_CMAKE_CXX_FLAGS}")
+  if(NOT enable-portable-build)
+    set(TFEL_CMAKE_CXX_FLAGS "${OPTIMISATION_FLAGS_MARCH} ${TFEL_CMAKE_CXX_FLAGS}")
+  endif(NOT enable-portable-build)
+endif(CMAKE_BUILD_TYPE STREQUAL "Profiling")
+
 # This option has been added for building conda package.
 # It circumvents the following issue: `cmake` discards `Boost_INCLUDEDIRS`
 # which is equal to `$PREFIX/include`. The same applies to
@@ -198,22 +235,31 @@ add_definitions("-DCOMPILER_CXXFLAGS=\\\"\"${COMPILER_CXXFLAGS}\"\\\"")
 # See https://github.com/thelfer/staged-recipes/tree/master/recipes/tfel for a recipe
 # showing how to build `TFEL` with `conda`.
 if(NOT USE_EXTERNAL_COMPILER_FLAGS)
-  set(CMAKE_C_FLAGS "${COMPILER_FLAGS} ${COMPILER_CFLAGS}")
-  set(CMAKE_CXX_FLAGS "${VISIBILITY_FLAGS} ${COMPILER_WARNINGS} ${COMPILER_FLAGS} ${COMPILER_CXXFLAGS}")
-  if(CMAKE_BUILD_TYPE STREQUAL "Profiling")
-    set(CMAKE_CXX_FLAGS_PROFILING "${OPTIMISATION_FLAGS} ${CMAKE_CXX_FLAGS_PROFILING}")
-    if(NOT enable-portable-build)
-      set(CMAKE_CXX_FLAGS_PROFILING "${OPTIMISATION_FLAGS_MARCH} ${CMAKE_CXX_FLAGS_PROFILING}")
-    endif(NOT enable-portable-build)
-  elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
-    set(CMAKE_CXX_FLAGS_RELEASE   "${OPTIMISATION_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
-    if(NOT enable-portable-build)
-      set(CMAKE_CXX_FLAGS_RELEASE "${OPTIMISATION_FLAGS_MARCH} ${CMAKE_CXX_FLAGS_RELEASE}")
-    endif(NOT enable-portable-build)
-  else(CMAKE_BUILD_TYPE STREQUAL "Profiling")
-    set(CMAKE_CXX_FLAGS           "${OPTIMISATION_FLAGS} ${CMAKE_CXX_FLAGS}")
-    if(NOT enable-portable-build)
-      set(CMAKE_CXX_FLAGS "${OPTIMISATION_FLAGS_MARCH} ${CMAKE_CXX_FLAGS}")
-    endif(NOT enable-portable-build)
-  endif(CMAKE_BUILD_TYPE STREQUAL "Profiling")
+  set(CMAKE_C_FLAGS                      "${TFEL_CMAKE_C_FLAGS}")
+  set(CMAKE_C_FLAGS_DEBUG                "${TFEL_CMAKE_C_FLAGS_DEBUG}")
+  set(CMAKE_C_FLAGS_RELEASE              "${TFEL_CMAKE_C_FLAGS_RELEASE}")
+  set(CMAKE_C_FLAGS_COVERAGE             "${TFEL_CMAKE_C_FLAGS_COVERAGE}")
+  set(CMAKE_C_FLAGS_PROFILING            "${TFEL_CMAKE_C_FLAGS_PROFILING}")
+  set(CMAKE_CXX_FLAGS                    "${TFEL_CMAKE_CXX_FLAGS}")
+  set(CMAKE_CXX_FLAGS_DEBUG              "${TFEL_CMAKE_CXX_FLAGS_DEBUG}")
+  set(CMAKE_CXX_FLAGS_RELEASE            "${TFEL_CMAKE_CXX_FLAGS_RELEASE}")
+  set(CMAKE_CXX_FLAGS_COVERAGE           "${TFEL_CMAKE_CXX_FLAGS_COVERAGE}")
+  set(CMAKE_CXX_FLAGS_PROFILING          "${TFEL_CMAKE_CXX_FLAGS_PROFILING}")
+  set(CMAKE_EXE_LINKER_FLAGS_COVERAGE    "${TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE}")
+  set(CMAKE_MODULE_LINKER_FLAGS_COVERAGE "${TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE}")
+  set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "${TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE}")
 endif(NOT USE_EXTERNAL_COMPILER_FLAGS)
+# normalize variables for generating tfel-modules-common.cmake
+separate_arguments(TFEL_CMAKE_C_FLAGS)
+separate_arguments(TFEL_CMAKE_C_FLAGS_DEBUG)
+separate_arguments(TFEL_CMAKE_C_FLAGS_RELEASE)
+separate_arguments(TFEL_CMAKE_C_FLAGS_COVERAGE)
+separate_arguments(TFEL_CMAKE_C_FLAGS_PROFILING)
+separate_arguments(TFEL_CMAKE_CXX_FLAGS)
+separate_arguments(TFEL_CMAKE_CXX_FLAGS_DEBUG)
+separate_arguments(TFEL_CMAKE_CXX_FLAGS_RELEASE)
+separate_arguments(TFEL_CMAKE_CXX_FLAGS_COVERAGE)
+separate_arguments(TFEL_CMAKE_CXX_FLAGS_PROFILING)
+separate_arguments(TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE)
+separate_arguments(TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE)
+separate_arguments(TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE)

cmake/modules/gcc.cmake

@@ -44,47 +44,47 @@ option(enable-sanitize-options "enable various gcc sanitize options (undefined,
 
 option(enable-glibcxx-debug "use the debug version of the C++ standard as implemented by the glib C++ library" OFF)
 if(enable-glibcxx-debug)
-SET(CMAKE_CXX_FLAGS_DEBUG "-g -D_GLIBCXX_DEBUG" CACHE STRING
-    "Flags used by the C++ compiler during debug builds."
-    FORCE)
+  set(TFEL_CMAKE_CXX_FLAGS_DEBUG "-g -D_GLIBCXX_DEBUG" CACHE STRING
+      "Flags used by the C++ compiler during debug builds."
+      FORCE)
 else(enable-glibcxx-debug)
-SET(CMAKE_CXX_FLAGS_DEBUG "-g" CACHE STRING
-    "Flags used by the C++ compiler during debug builds."
-    FORCE)
+  set(TFEL_CMAKE_CXX_FLAGS_DEBUG "-g" CACHE STRING
+      "Flags used by the C++ compiler during debug builds."
+      FORCE)
 endif(enable-glibcxx-debug)
 
-SET(CMAKE_C_FLAGS_DEBUG "-g" CACHE STRING
+set(TFEL_CMAKE_C_FLAGS_DEBUG "-g" CACHE STRING
     "Flags used by the C compiler during debug builds."
     FORCE)
 
 # coverage
-SET(CMAKE_CXX_FLAGS_COVERAGE "-O0 -g -DNDEBUG -fprofile-arcs -ftest-coverage" CACHE STRING
+set(TFEL_CMAKE_CXX_FLAGS_COVERAGE "-O0 -g -DNDEBUG -fprofile-arcs -ftest-coverage" CACHE STRING
     "Flags used by the C++ compiler during builds with tests coverage checks."
     FORCE)
-SET(CMAKE_C_FLAGS_COVERAGE "-O0 -g -DNDEBUG -fprofile-arcs -ftest-coverage" CACHE STRING
+set(TFEL_CMAKE_C_FLAGS_COVERAGE "-O0 -g -DNDEBUG -fprofile-arcs -ftest-coverage" CACHE STRING
     "Flags used by the C compiler during builds with tests coverage checks."
     FORCE)
-set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+set(TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE
   "-fprofile-arcs -ftest-coverage -lgcov")
-set(CMAKE_MODULE_LINKER_FLAGS_COVERAGE
+set(TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE
   "-fprofile-arcs -ftest-coverage -lgcov")
-set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+set(TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE
   "-fprofile-arcs -ftest-coverage -lgcov")
-MARK_AS_ADVANCED(CMAKE_CXX_FLAGS_COVERAGE
-  CMAKE_C_FLAGS_COVERAGE
-  CMAKE_EXE_LINKER_FLAGS_COVERAGE
-  CMAKE_MODULE_LINKER_FLAGS_COVERAGE
-  CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
+mark_as_advanced(TFEL_CMAKE_CXX_FLAGS_COVERAGE
+                 TFEL_CMAKE_C_FLAGS_COVERAGE
+                 TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE
+                 TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE
+                 TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE)
 
 # profiling
-SET(CMAKE_CXX_FLAGS_PROFILING "-pg" CACHE STRING
+set(TFEL_CMAKE_CXX_FLAGS_PROFILING "-pg" CACHE STRING
     "Flags used by the C++ compiler during profiled builds."
     FORCE)
-SET(CMAKE_C_FLAGS_PROFILING "-pg" CACHE STRING
+set(TFEL_CMAKE_C_FLAGS_PROFILING "-pg" CACHE STRING
     "Flags used by the C compiler during profiled builds."
     FORCE)
-MARK_AS_ADVANCED(CMAKE_CXX_FLAGS_PROFILING
-  CMAKE_C_FLAGS_PROFILING)
+mark_as_advanced(TFEL_CMAKE_CXX_FLAGS_PROFILING
+                 TFEL_CMAKE_C_FLAGS_PROFILING)
 
 # tfel_add_cxx_compiler_flag_if_available(COMPILER_FLAGS "fanalyzer")
 

cmake/modules/intel.cmake

@@ -14,7 +14,7 @@ else(${DIAG_DISABLE_FLAG_AVAILABLE})
 endif(${DIAG_DISABLE_FLAG_AVAILABLE})
 
 tfel_add_cxx_compiler_flag_if_available(OPTIMISATION_FLAGS_MARCH "xHost")
-tfel_add_cxx_compiler_flag_if_available(CMAKE_CXX_FLAGS    "ipo")
+tfel_add_cxx_compiler_flag_if_available(TFEL_CMAKE_CXX_FLAGS     "ipo")
 
 tfel_add_cxx_compiler_flag_if_available(VISIBILITY_FLAGS "fvisibility=hidden")
 tfel_add_cxx_compiler_flag_if_available(VISIBILITY_FLAGS "fvisibility-inlines-hidden")

cmake/modules/tfel-modules-common.cmake.in

@@ -0,0 +1,32 @@
+if(TFEL_DIR)
+  set(TFEL_MODULE_PATH ${TFEL_DIR})
+else(TFEL_DIR)
+  if(TFELHOME)
+    set(TFEL_MODULE_PATH ${TFELHOME})
+  else(TFELHOME)
+    if(DEFINED ENV{TFELHOME})
+	  set(TFEL_MODULE_PATH "$ENV{TFELHOME}")      
+    endif(DEFINED ENV{TFELHOME})
+  endif(TFELHOME)
+endif(TFEL_DIR)
+
+set(TFEL_CXX_STANDARD                       "20")
+set(TFEL_COMPILER_FLAGS                     "@TFEL_COMPILER_FLAGS@")
+set(TFEL_COMPILER_CXXFLAGS                  "@TFEL_COMPILER_CXXFLAGS@")
+set(TFEL_COMPILER_WARNINGS                  "@TFEL_COMPILER_WARNINGS@")
+set(TFEL_OPTIMISATION_FLAGS0                "@TFEL_OPTIMISATION_FLAGS0@")
+set(TFEL_OPTIMISATION_FLAGS                 "@TFEL_OPTIMISATION_FLAGS@")
+set(TFEL_OPTIMISATION_FLAGS2                "@TFEL_OPTIMISATION_FLAGS2@")
+set(TFEL_CMAKE_C_FLAGS                      "@TFEL_CMAKE_C_FLAGS@")
+set(TFEL_CMAKE_C_FLAGS_DEBUG                "@TFEL_CMAKE_C_FLAGS_DEBUG@")
+set(TFEL_CMAKE_C_FLAGS_RELEASE              "@TFEL_CMAKE_C_FLAGS_RELEASE@")
+set(TFEL_CMAKE_C_FLAGS_COVERAGE             "@TFEL_CMAKE_C_FLAGS_COVERAGE@")
+set(TFEL_CMAKE_C_FLAGS_PROFILING            "@TFEL_CMAKE_C_FLAGS_PROFILING@")
+set(TFEL_CMAKE_CXX_FLAGS                    "@TFEL_CMAKE_CXX_FLAGS@")
+set(TFEL_CMAKE_CXX_FLAGS_DEBUG              "@TFEL_CMAKE_CXX_FLAGS_DEBUG@")
+set(TFEL_CMAKE_CXX_FLAGS_RELEASE            "@TFEL_CMAKE_CXX_FLAGS_RELEASE@")
+set(TFEL_CMAKE_CXX_FLAGS_COVERAGE           "@TFEL_CMAKE_CXX_FLAGS_COVERAGE@")
+set(TFEL_CMAKE_CXX_FLAGS_PROFILING          "@TFEL_CMAKE_CXX_FLAGS_PROFILING@")
+set(TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE    "@TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE@")
+set(TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE "@TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE@")
+set(TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE "@TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE@")

docs/web/CMakeLists.txt

@@ -143,7 +143,6 @@ pandoc_html(release-notes-3.2   "--toc" "--toc-depth=2" "--number-sections" "-c
 pandoc_html(release-notes-3.2.1 "--toc" "--toc-depth=2")
 pandoc_html(release-notes-3.2.2 "--toc" "--toc-depth=2")
 pandoc_html(release-notes-3.2.3 "--toc" "--toc-depth=2")
-pandoc_html(release-notes-3.2.3 "--toc" "--toc-depth=2")
 pandoc_html(release-notes-3.2.4 "--toc" "--toc-depth=2")
 pandoc_html(release-notes-3.2.5 "--toc" "--toc-depth=2")
 pandoc_html(release-notes-3.2.6 "--toc" "--toc-depth=2")
@@ -220,15 +219,13 @@ pandoc_html(IsotropicStrainHardeningMisesCreep-keywords "--toc" "--toc-depth=1")
 pandoc_html(MaterialLaw-keywords "--toc" "--toc-depth=1")
 pandoc_html(MaterialProperty-keywords "--toc" "--toc-depth=1")
 pandoc_html(Model-keywords "--toc" "--toc-depth=1")
-pandoc_html(MTest-keywords "--toc" "--toc-depth=1")
 pandoc_html(MultipleIsotropicMisesFlows-keywords "--toc" "--toc-depth=1")
 pandoc_html(RungeKuttaFiniteStrain-keywords "--toc" "--toc-depth=1")
 pandoc_html(RungeKuttaGenericBehaviour-keywords "--toc" "--toc-depth=1")
 pandoc_html(RungeKutta-keywords "--toc" "--toc-depth=1")
 pandoc_html(RungeKuttaModel-keywords "--toc" "--toc-depth=1")
 
 # mtest keywords
-
 pandoc_html(MTest-keywords "--toc" "--toc-depth=1")
 
 if(TFEL_APPEND_SUFFIX)

docs/web/libraries_usage.md

@@ -143,3 +143,34 @@ find_package(TFELMathCubicSpline REQUIRED HINTS "${TFEL_DIR}/share/tfel/cmake")
 add_executable(test main.cxx)
 target_link_libraries(test tfel::TFELMathCubicSpline)
 ~~~~
+
+## Exported variables
+
+The `tfel-modules-common.cmake` file defines the following variables:
+
+- `TFEL_CXX_STANDARD`:
+- `TFEL_COMPILER_FLAGS`:
+- `TFEL_COMPILER_CXXFLAGS`:
+- `TFEL_COMPILER_WARNINGS`:
+- `TFEL_OPTIMISATION_FLAGS0`:
+- `TFEL_OPTIMISATION_FLAGS`:
+- `TFEL_OPTIMISATION_FLAGS2`:
+- `TFEL_CMAKE_C_FLAGS`:
+- `TFEL_CMAKE_C_FLAGS_DEBUG`:
+- `TFEL_CMAKE_C_FLAGS_RELEASE`:
+- `TFEL_CMAKE_C_FLAGS_COVERAGE`:
+- `TFEL_CMAKE_C_FLAGS_PROFILING`:
+- `TFEL_CMAKE_CXX_FLAGS`:
+- `TFEL_CMAKE_CXX_FLAGS_DEBUG`:
+- `TFEL_CMAKE_CXX_FLAGS_RELEASE`:
+- `TFEL_CMAKE_CXX_FLAGS_COVERAGE`:
+- `TFEL_CMAKE_CXX_FLAGS_PROFILING`:
+- `TFEL_CMAKE_EXE_LINKER_FLAGS_COVERAGE`:
+- `TFEL_CMAKE_MODULE_LINKER_FLAGS_COVERAGE`:
+- `TFEL_CMAKE_SHARED_LINKER_FLAGS_COVERAGE`:
+
+The `tfel-modules-common.cmake` can be included as follows:
+
+~~~~{.cmake}
+include("${TFEL_DIR}/share/tfel/cmake/tfel-modules-common.cmake")
+~~~~