From 227c7be1af1d9f7787b9ee0b2006813c5b78a1c7 Mon Sep 17 00:00:00 2001 From: Tom Finegan Date: Sat, 23 Dec 2017 09:27:47 -0800 Subject: [PATCH] Additional CMake flag handling improvements. - Stop forcing AS/C/CXX/LINKER flags into the cache. - Don't cache internal build system variables. - Fix usages of PARENT_SCOPE rendered incorrect by previous patch. - Fix usage of local variables within if() statements in macros; functions appear to allow for omission of ${} around vars in simple boolean checks. Macros apparently require ${} for all usages of if(). --- cmake/compiler_flags.cmake | 29 +++++++------- cmake/compiler_tests.cmake | 80 ++++++++++++++++++-------------------- 2 files changed, 52 insertions(+), 57 deletions(-) diff --git a/cmake/compiler_flags.cmake b/cmake/compiler_flags.cmake index ea67d25..2e78e22 100644 --- a/cmake/compiler_flags.cmake +++ b/cmake/compiler_flags.cmake @@ -22,7 +22,7 @@ macro (add_c_flag_if_supported c_flag) unset(C_FLAG_SUPPORTED CACHE) message("Checking C compiler flag support for: " ${c_flag}) check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED) - if (C_FLAG_SUPPORTED) + if (${C_FLAG_SUPPORTED}) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${c_flag}" CACHE STRING "") else () set(DRACO_FAILED_C_FLAGS "${DRACO_FAILED_C_FLAGS} ${c_flag}" CACHE STRING @@ -44,7 +44,7 @@ macro (add_cxx_flag_if_supported cxx_flag) unset(CXX_FLAG_SUPPORTED CACHE) message("Checking CXX compiler flag support for: " ${cxx_flag}) check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED) - if (CXX_FLAG_SUPPORTED) + if (${CXX_FLAG_SUPPORTED}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flag}" CACHE STRING "") else() set(DRACO_FAILED_CXX_FLAGS "${DRACO_FAILED_CXX_FLAGS} ${cxx_flag}" CACHE @@ -70,12 +70,12 @@ macro (require_c_flag c_flag update_c_flags) unset(HAVE_C_FLAG CACHE) message("Checking C compiler flag support for: " ${c_flag}) check_c_compiler_flag("${c_flag}" HAVE_C_FLAG) - if (NOT HAVE_C_FLAG) + if (NOT ${HAVE_C_FLAG}) message(FATAL_ERROR "${PROJECT_NAME} requires support for C flag: ${c_flag}.") endif () - if (update_c_flags) - set(CMAKE_C_FLAGS "${c_flag} ${CMAKE_C_FLAGS}" CACHE STRING "") + if (${update_c_flags}) + set(CMAKE_C_FLAGS "${c_flag} ${CMAKE_C_FLAGS}") endif () endif () endmacro () @@ -90,12 +90,12 @@ macro (require_cxx_flag cxx_flag update_cxx_flags) unset(HAVE_CXX_FLAG CACHE) message("Checking CXX compiler flag support for: " ${cxx_flag}) check_cxx_compiler_flag("${cxx_flag}" HAVE_CXX_FLAG) - if (NOT HAVE_CXX_FLAG) + if (NOT ${HAVE_CXX_FLAG}) message(FATAL_ERROR "${PROJECT_NAME} requires support for CXX flag: ${cxx_flag}.") endif () - if (update_cxx_flags) - set(CMAKE_CXX_FLAGS "${cxx_flag} ${CMAKE_CXX_FLAGS}" CACHE STRING "") + if (${update_cxx_flags}) + set(CMAKE_CXX_FLAGS "${cxx_flag} ${CMAKE_CXX_FLAGS}") endif () endif () endmacro () @@ -138,7 +138,7 @@ macro (add_c_preproc_definition preproc_def) string(FIND "${CMAKE_C_FLAGS}" "${preproc_def}" PREPROC_DEF_FOUND) if (${PREPROC_DEF_FOUND} EQUAL -1) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D${preproc_def}" CACHE STRING "") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D${preproc_def}") endif () endmacro () @@ -149,7 +149,7 @@ macro (add_cxx_preproc_definition preproc_def) string(FIND "${CMAKE_CXX_FLAGS}" "${preproc_def}" PREPROC_DEF_FOUND) if (${PREPROC_DEF_FOUND} EQUAL -1) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D${preproc_def}" CACHE STRING "") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D${preproc_def}") endif () endmacro () @@ -166,7 +166,7 @@ macro (append_as_flag flag) string(FIND "${DRACO_AS_FLAGS}" "${flag}" AS_FLAG_FOUND) if (${AS_FLAG_FOUND} EQUAL -1) - set(DRACO_AS_FLAGS "${DRACO_AS_FLAGS} ${flag}" CACHE STRING "") + set(DRACO_AS_FLAGS "${DRACO_AS_FLAGS} ${flag}") endif () endmacro () @@ -176,7 +176,7 @@ macro (append_c_flag flag) string(FIND "${CMAKE_C_FLAGS}" "${flag}" C_FLAG_FOUND) if (${C_FLAG_FOUND} EQUAL -1) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" CACHE STRING "") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}") endif () endmacro () @@ -186,7 +186,7 @@ macro (append_cxx_flag flag) string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" CXX_FLAG_FOUND) if (${CXX_FLAG_FOUND} EQUAL -1) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" CACHE STRING "") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}") endif () endmacro () @@ -202,8 +202,7 @@ macro (append_exe_linker_flag flag) string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" LINKER_FLAG_FOUND) if (${LINKER_FLAG_FOUND} EQUAL -1) - set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}" CACHE STRING - "") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}") endif () endmacro () diff --git a/cmake/compiler_tests.cmake b/cmake/compiler_tests.cmake index bf74619..e529ba1 100644 --- a/cmake/compiler_tests.cmake +++ b/cmake/compiler_tests.cmake @@ -4,7 +4,7 @@ set(DRACO_CMAKE_COMPILER_TESTS_CMAKE_ 1) include(CheckCSourceCompiles) include(CheckCXXSourceCompiles) -# The basic main() function used in all compile tests. +# The basic main() macro used in all compile tests. set(DRACO_C_MAIN "\nint main(void) { return 0; }") set(DRACO_CXX_MAIN "\nint main() { return 0; }") @@ -14,22 +14,22 @@ set(DRACO_C_FAILED_TESTS) set(DRACO_CXX_PASSED_TESTS) set(DRACO_CXX_FAILED_TESTS) -function(draco_push_var var new_value) - set(SAVED_${var} ${var} PARENT_SCOPE) - set(${var} ${new_value} PARENT_SCOPE) -endfunction () +macro(draco_push_var var new_value) + set(SAVED_${var} ${var}) + set(${var} ${new_value}) +endmacro () -function(draco_pop_var var) - set(var ${SAVED_${var}} PARENT_SCOPE) - unset(SAVED_${var} PARENT_SCOPE) -endfunction () +macro(draco_pop_var var) + set(var ${SAVED_${var}}) + unset(SAVED_${var}) +endmacro () # Confirms $test_source compiles and stores $test_name in one of # $DRACO_C_PASSED_TESTS or $DRACO_C_FAILED_TESTS depending on out come. When the # test passes $result_var is set to 1. When it fails $result_var is unset. # The test is not run if the test name is found in either of the passed or # failed test variables. -function(draco_check_c_compiles test_name test_source result_var) +macro(draco_check_c_compiles test_name test_source result_var) unset(C_TEST_PASSED CACHE) unset(C_TEST_FAILED CACHE) string(FIND "${DRACO_C_PASSED_TESTS}" "${test_name}" C_TEST_PASSED) @@ -38,29 +38,27 @@ function(draco_check_c_compiles test_name test_source result_var) unset(C_TEST_COMPILED CACHE) message("Running C compiler test: ${test_name}") check_c_source_compiles("${test_source} ${DRACO_C_MAIN}" C_TEST_COMPILED) - set(${result_var} ${C_TEST_COMPILED} PARENT_SCOPE) + set(${result_var} ${C_TEST_COMPILED}) - if (C_TEST_COMPILED) - set(DRACO_C_PASSED_TESTS "${DRACO_C_PASSED_TESTS} ${test_name}" CACHE - STRING "" FORCE) + if (${C_TEST_COMPILED}) + set(DRACO_C_PASSED_TESTS "${DRACO_C_PASSED_TESTS} ${test_name}") else () - set(DRACO_C_FAILED_TESTS "${DRACO_C_FAILED_TESTS} ${test_name}" CACHE - STRING "" FORCE) + set(DRACO_C_FAILED_TESTS "${DRACO_C_FAILED_TESTS} ${test_name}") message("C Compiler test ${test_name} failed.") endif () elseif (NOT ${C_TEST_PASSED} EQUAL -1) - set(${result_var} 1 PARENT_SCOPE) + set(${result_var} 1) else () # ${C_TEST_FAILED} NOT EQUAL -1 - unset(${result_var} PARENT_SCOPE) + unset(${result_var}) endif () -endfunction () +endmacro () # Confirms $test_source compiles and stores $test_name in one of # $DRACO_CXX_PASSED_TESTS or $DRACO_CXX_FAILED_TESTS depending on out come. When # the test passes $result_var is set to 1. When it fails $result_var is unset. # The test is not run if the test name is found in either of the passed or # failed test variables. -function(draco_check_cxx_compiles test_name test_source result_var) +macro(draco_check_cxx_compiles test_name test_source result_var) unset(CXX_TEST_PASSED CACHE) unset(CXX_TEST_FAILED CACHE) string(FIND "${DRACO_CXX_PASSED_TESTS}" "${test_name}" CXX_TEST_PASSED) @@ -70,59 +68,57 @@ function(draco_check_cxx_compiles test_name test_source result_var) message("Running CXX compiler test: ${test_name}") check_cxx_source_compiles("${test_source} ${DRACO_CXX_MAIN}" CXX_TEST_COMPILED) - set(${result_var} ${CXX_TEST_COMPILED} PARENT_SCOPE) + set(${result_var} ${CXX_TEST_COMPILED}) - if (CXX_TEST_COMPILED) - set(DRACO_CXX_PASSED_TESTS "${DRACO_CXX_PASSED_TESTS} ${test_name}" CACHE - STRING "" FORCE) + if (${CXX_TEST_COMPILED}) + set(DRACO_CXX_PASSED_TESTS "${DRACO_CXX_PASSED_TESTS} ${test_name}") else () - set(DRACO_CXX_FAILED_TESTS "${DRACO_CXX_FAILED_TESTS} ${test_name}" CACHE - STRING "" FORCE) + set(DRACO_CXX_FAILED_TESTS "${DRACO_CXX_FAILED_TESTS} ${test_name}") message("CXX Compiler test ${test_name} failed.") endif () elseif (NOT ${CXX_TEST_PASSED} EQUAL -1) - set(${result_var} 1 PARENT_SCOPE) + set(${result_var} 1) else () # ${CXX_TEST_FAILED} NOT EQUAL -1 - unset(${result_var} PARENT_SCOPE) + unset(${result_var}) endif () -endfunction () +endmacro () -# Convenience function that confirms $test_source compiles as C and C++. +# Convenience macro that confirms $test_source compiles as C and C++. # $result_var is set to 1 when both tests are successful, and 0 when one or both # tests fail. -# Note: This function is intended to be used to write to result variables that +# Note: This macro is intended to be used to write to result variables that # are expanded via configure_file(). $result_var is set to 1 or 0 to allow # direct usage of the value in generated source files. -function(draco_check_source_compiles test_name test_source result_var) +macro(draco_check_source_compiles test_name test_source result_var) unset(C_PASSED) unset(CXX_PASSED) draco_check_c_compiles(${test_name} ${test_source} C_PASSED) draco_check_cxx_compiles(${test_name} ${test_source} CXX_PASSED) - if (C_PASSED AND CXX_PASSED) - set(${result_var} 1 PARENT_SCOPE) + if (${C_PASSED} AND ${CXX_PASSED}) + set(${result_var} 1) else () - set(${result_var} 0 PARENT_SCOPE) + set(${result_var} 0) endif () -endfunction () +endmacro () # When inline support is detected for the current compiler the supported # inlining keyword is written to $result in caller scope. -function (draco_get_inline result) +macro (draco_get_inline result) draco_check_source_compiles("inline_check_1" - "static inline void function(void) {}" + "static inline void macro(void) {}" HAVE_INLINE_1) if (HAVE_INLINE_1 EQUAL 1) - set(${result} "inline" PARENT_SCOPE) + set(${result} "inline") return() endif () # Check __inline. draco_check_source_compiles("inline_check_2" - "static __inline void function(void) {}" + "static __inline void macro(void) {}" HAVE_INLINE_2) if (HAVE_INLINE_2 EQUAL 1) - set(${result} "__inline" PARENT_SCOPE) + set(${result} "__inline") endif () -endfunction () +endmacro () endif () # DRACO_CMAKE_COMPILER_TESTS_CMAKE_