Enable compiler detection only if not added as subproject (#20)

Compiler detection is dangerous if this project is added via add_subdirectory() or FetchContent as it tries to enable languages which might be disabled on purpose in the super-project.
Therefore, compiler detection is disabled if used as a subproject.

Author: havogt

CMakeLists.txt

@@ -12,8 +12,9 @@ include(CTest)
 set(REQUIRED_BOOST_VERSION 1.58)
 find_package(Boost ${REQUIRED_BOOST_VERSION} REQUIRED)
 
-option(CPP_BINDGEN_GT_LEGACY "Enables the legacy mode for API compatibility with GridTools 1.x" OFF)
-mark_as_advanced(CPP_BINDGEN_GT_LEGACY)
+if(NOT CPP_BINDGEN_GT_LEGACY)
+    set(CPP_BINDGEN_GT_LEGACY OFF)
+endif()
 
 # if used via FetchContent/add_subdirectory() we need to make the add_bindings_library() available here
 include(${CMAKE_CURRENT_LIST_DIR}/cmake/bindings.cmake)

cmake/cpp_bindgen.cmake.in

@@ -70,7 +70,7 @@ function(cpp_bindgen_enable_fortran_library target_name)
             target_link_libraries(fortran_bindings_handle PUBLIC c_bindings_handle)
             target_include_directories(fortran_bindings_handle PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
             include(${__C_BINDINGS_CMAKE_DIR}/fortran_helpers.cmake)
-            gen_enable_fortran_preprocessing_on_target(fortran_bindings_handle)
+            cpp_bindgen_enable_fortran_preprocessing_on_target(fortran_bindings_handle)
         endif()
         if(NOT TARGET ${target_name}_fortran)
             set_source_files_properties(GT_${${target_name}_fortran_bindings_path} PROPERTIES GENERATED TRUE)

cmake/detect_features.cmake

@@ -1,51 +1,68 @@
+if(NOT DEFINED CPP_BINDGEN_ENABLE_COMPILER_DETECTION)
+    if(${PROJECT_SOURCE_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
+        # If turned OFF, it will still use the compilers,
+        # - if they are available from a super-project, or
+        # - if compilers are forced to on via other options.
+        set(CPP_BINDGEN_ENABLE_COMPILER_DETECTION OFF)
+    else()
+        set(CPP_BINDGEN_ENABLE_COMPILER_DETECTION ON)
+    endif()
+endif()
+
 macro(detect_cuda)
-    if(NOT DEFINED CPP_BINDGEN_TEST_CUDA)
-        # detect CUDA support
-        include(CheckLanguage)
-        check_language(CUDA)
+    if(CPP_BINDGEN_ENABLE_COMPILER_DETECTION)
+        if(NOT DEFINED CPP_BINDGEN_TEST_CUDA)
+            # detect CUDA support
+            include(CheckLanguage)
+            check_language(CUDA)
 
-        if(CMAKE_CUDA_COMPILER)
-            enable_language (CUDA)
+            if(CMAKE_CUDA_COMPILER)
+                enable_language (CUDA)
+                message(STATUS "Enable CUDA tests")
+                set(CUDA_AVAILABLE ON)
+            else()
+                message(STATUS "Disable CUDA tests")
+                set(CUDA_AVAILABLE OFF)
+            endif()
+        elseif(CPP_BINDGEN_TEST_CUDA)
+            enable_language(CUDA)
             message(STATUS "Enable CUDA tests")
             set(CUDA_AVAILABLE ON)
         else()
             message(STATUS "Disable CUDA tests")
             set(CUDA_AVAILABLE OFF)
         endif()
-    elseif(CPP_BINDGEN_TEST_CUDA)
-        enable_language(CUDA)
-        message(STATUS "Enable CUDA tests")
-        set(CUDA_AVAILABLE ON)
-    else()
-        message(STATUS "Disable CUDA tests")
-        set(CUDA_AVAILABLE OFF)
     endif()
 endmacro(detect_cuda)
 
 include (CMakeDependentOption)
 
 macro(detect_fortran_compiler)
-    CMAKE_DEPENDENT_OPTION (CPP_BINDGEN_REQUIRE_TEST_Fortran "CMake will abort if no Fortran compiler can be found"
-        OFF "BUILD_TESTING" OFF)
+    if(CPP_BINDGEN_ENABLE_COMPILER_DETECTION)
+        CMAKE_DEPENDENT_OPTION (CPP_BINDGEN_REQUIRE_TEST_Fortran "CMake will abort if no Fortran compiler can be found"
+            OFF "BUILD_TESTING" OFF)
 
-    include(CheckLanguage)
-    check_language(Fortran)
-    if (CMAKE_Fortran_COMPILER OR CPP_BINDGEN_REQUIRE_TEST_Fortran)
-        enable_language(Fortran)
-    else()
-        message(WARNING "Fortran Compiler has not been found. Tests using Fortran will not be built!")
+        include(CheckLanguage)
+        check_language(Fortran)
+        if (CMAKE_Fortran_COMPILER OR CPP_BINDGEN_REQUIRE_TEST_Fortran)
+            enable_language(Fortran)
+        else()
+            message(WARNING "Fortran Compiler has not been found. Tests using Fortran will not be built!")
+        endif()
     endif()
 endmacro(detect_fortran_compiler)
 
 macro(detect_c_compiler)
-    CMAKE_DEPENDENT_OPTION (CPP_BINDGEN_REQUIRE_TEST_C "CMake will abort if no C compiler can be found"
-        OFF "BUILD_TESTING" OFF)
+    if(CPP_BINDGEN_ENABLE_COMPILER_DETECTION)
+        CMAKE_DEPENDENT_OPTION (CPP_BINDGEN_REQUIRE_TEST_C "CMake will abort if no C compiler can be found"
+            OFF "BUILD_TESTING" OFF)
 
-    include(CheckLanguage)
-    check_language(C)
-    if (CMAKE_C_COMPILER OR CPP_BINDGEN_REQUIRE_TEST_C)
-        enable_language(C)
-    else()
-        message(WARNING "C Compiler has not been found. Tests using C will not be built!")
+        include(CheckLanguage)
+        check_language(C)
+        if (CMAKE_C_COMPILER OR CPP_BINDGEN_REQUIRE_TEST_C)
+            enable_language(C)
+        else()
+            message(WARNING "C Compiler has not been found. Tests using C will not be built!")
+        endif()
     endif()
 endmacro(detect_c_compiler)

cmake/fortran_helpers.cmake

@@ -1,4 +1,4 @@
-function(gen_enable_fortran_openacc_on_target target)
+function(cpp_bindgen_enable_fortran_openacc_on_target target)
     # TODO check if find_package(OpenACC) solves this problem
     if(CMAKE_Fortran_COMPILER_ID STREQUAL "Cray")
         target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:-h acc>)
@@ -10,7 +10,7 @@ function(gen_enable_fortran_openacc_on_target target)
     endif()
 endfunction()
 
-function(gen_enable_fortran_preprocessing_on_target target)
+function(cpp_bindgen_enable_fortran_preprocessing_on_target target)
     if (CMAKE_Fortran_COMPILER_ID STREQUAL "Cray")
         target_compile_options(${target} PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:-eF>)
     else()

tests/CMakeLists.txt

@@ -16,6 +16,12 @@ endif()
 include(${PROJECT_SOURCE_DIR}/cmake/detect_features.cmake)
 detect_cuda()
 
+# If clang+nvcc, we disable the tests, if CUDA < 10.0 because nvcc has problems with C++14 in this combination
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL Clang AND DEFINED CMAKE_CUDA_COMPILER AND "${CMAKE_CUDA_COMPILER_VERSION}" VERSION_LESS "10.0")
+  message("NVCC < 10.0 is not supported with Clang as host compiler. Disabling CUDA tests.")
+  set(CUDA_AVAILABLE OFF)
+endif()
+
 include(${PROJECT_SOURCE_DIR}/cmake/workaround_thread.cmake)
 _fix_threads_flags()
 

tests/regression/array/CMakeLists.txt

@@ -4,3 +4,4 @@ add_executable(gen_regression_array_driver_fortran driver.f90)
 target_link_libraries(gen_regression_array_driver_fortran gen_regression_array_fortran)
 add_test(NAME gen_regression_array_driver_fortran
     COMMAND $<TARGET_FILE:gen_regression_array_driver_fortran>)
+set_target_properties(gen_regression_array_driver_fortran PROPERTIES LINKER_LANGUAGE Fortran)

tests/regression/array_gt_legacy/CMakeLists.txt

@@ -4,3 +4,4 @@ add_executable(gen_regression_array_gt_legacy_driver_fortran driver.f90)
 target_link_libraries(gen_regression_array_gt_legacy_driver_fortran gen_regression_array_gt_legacy_fortran)
 add_test(NAME gen_regression_array_gt_legacy_driver_fortran
     COMMAND $<TARGET_FILE:gen_regression_array_gt_legacy_driver_fortran>)
+set_target_properties(gen_regression_array_gt_legacy_driver_fortran PROPERTIES LINKER_LANGUAGE Fortran)

tests/regression/simple/CMakeLists.txt

@@ -5,6 +5,7 @@ if(CMAKE_Fortran_COMPILER_LOADED)
     target_link_libraries(gen_regression_simple_driver_fortran gen_regression_simple_fortran)
     add_test(NAME gen_regression_simple_driver_fortran
         COMMAND $<TARGET_FILE:gen_regression_simple_driver_fortran>)
+    set_target_properties(gen_regression_simple_driver_fortran PROPERTIES LINKER_LANGUAGE Fortran)
 endif()
 
 if(CMAKE_C_COMPILER_LOADED)