# Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. # CheckSourceCompiles # ---------------------- # # .. versionadded:: 3.19 # # Check if given source compiles and links into an executable. # # .. command:: check_source_compiles # # .. code-block:: cmake # # check_source_compiles( # [FAIL_REGEX [...]] # [SRC_EXT ]) # # Check that the source supplied in ```` can be compiled as a source # file for the requested language and linked as an executable (so it must # contain at least a ``main()`` function). The result will be stored in the # internal cache variable specified by ````, with a boolean true # value for success and boolean false for failure. If ``FAIL_REGEX`` is # provided, then failure is determined by checking if anything in the output # matches any of the specified regular expressions. # # By default, the test source file will be given a file extension that matches # the requested language. The ``SRC_EXT`` option can be used to override this # with ``.`` instead. # # The underlying check is performed by the :command:`try_compile` command. The # compile and link commands can be influenced by setting any of the following # variables prior to calling ``check_source_compiles()``: # # ``CMAKE_REQUIRED_FLAGS`` # Additional flags to pass to the compiler. Note that the contents of # :variable:`CMAKE__FLAGS _FLAGS>` and its associated # configuration-specific variable are automatically added to the compiler # command before the contents of ``CMAKE_REQUIRED_FLAGS``. # # ``CMAKE_REQUIRED_DEFINITIONS`` # A :ref:`;-list ` of compiler definitions of the form # ``-DFOO`` or ``-DFOO=bar``. A definition for the name specified by # ```` will also be added automatically. # # ``CMAKE_REQUIRED_INCLUDES`` # A :ref:`;-list ` of header search paths to pass to # the compiler. These will be the only header search paths used by # ``try_compile()``, i.e. the contents of the :prop_dir:`INCLUDE_DIRECTORIES` # directory property will be ignored. # # ``CMAKE_REQUIRED_LINK_OPTIONS`` # A :ref:`;-list ` of options to add to the link # command (see :command:`try_compile` for further details). # # ``CMAKE_REQUIRED_LIBRARIES`` # A :ref:`;-list ` of libraries to add to the link # command. These can be the name of system libraries or they can be # :ref:`Imported Targets ` (see :command:`try_compile` for # further details). # # ``CMAKE_REQUIRED_QUIET`` # If this variable evaluates to a boolean true value, all status messages # associated with the check will be suppressed. # # The check is only performed once, with the result cached in the variable # named by ````. Every subsequent CMake run will re-use this cached # value rather than performing the check again, even if the ```` changes. # In order to force the check to be re-evaluated, the variable named by # ```` must be manually removed from the cache. cmake_policy(PUSH) if(${CMAKE_VERSION} VERSION_GREATER "3.1.0") cmake_policy(SET CMP0054 NEW) # if() quoted variables not dereferenced endif() function(CHECK_SOURCE_COMPILES _lang _source _var) if(NOT DEFINED "${_var}") if(_lang STREQUAL C) set(_lang_textual "C") set(_lang_ext "c") elseif(_lang STREQUAL CXX) set(_lang_textual "C++") set(_lang_ext "cxx") elseif(_lang STREQUAL Fortran) set(_lang_textual "Fortran") set(_lang_ext "F") elseif(_lang STREQUAL OBJC) set(_lang_textual "Objective-C") set(_lang_ext "m") elseif(_lang STREQUAL OBJCXX) set(_lang_textual "Objective-C++") set(_lang_ext "mm") else() message (SEND_ERROR "check_source_compiles: ${_lang}: unknown language.") return() endif() get_property (_supported_languages GLOBAL PROPERTY ENABLED_LANGUAGES) list (FIND _supported_languages "${_lang}" _lang_index) if (${_lang_index} EQUAL -1) message (SEND_ERROR "check_source_compiles: ${_lang}: needs to be enabled before use.") return() endif() set(_FAIL_REGEX) set(_SRC_EXT) set(_key) foreach(arg ${ARGN}) if("${arg}" MATCHES "^(FAIL_REGEX|SRC_EXT)$") set(_key "${arg}") elseif(_key) list(APPEND _${_key} "${arg}") else() message(FATAL_ERROR "Unknown argument:\n ${arg}\n") endif() endforeach() if(NOT _SRC_EXT) set(_SRC_EXT ${_lang_ext}) endif() if(CMAKE_REQUIRED_LINK_OPTIONS) set(CHECK_${LANG}_SOURCE_COMPILES_ADD_LINK_OPTIONS LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS}) else() set(CHECK_${LANG}_SOURCE_COMPILES_ADD_LINK_OPTIONS) endif() if(CMAKE_REQUIRED_LIBRARIES) set(CHECK_${LANG}_SOURCE_COMPILES_ADD_LIBRARIES LINK_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES}) else() set(CHECK_${LANG}_SOURCE_COMPILES_ADD_LIBRARIES) endif() if(CMAKE_REQUIRED_INCLUDES) set(CHECK_${LANG}_SOURCE_COMPILES_ADD_INCLUDES "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}") else() set(CHECK_${LANG}_SOURCE_COMPILES_ADD_INCLUDES) endif() file(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.${_SRC_EXT}" "${_source}\n") if(NOT CMAKE_REQUIRED_QUIET) message(CHECK_START "Performing Test ${_var}") endif() try_compile(${_var} ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.${_SRC_EXT} COMPILE_DEFINITIONS -D${_var} ${CMAKE_REQUIRED_DEFINITIONS} ${CHECK_${LANG}_SOURCE_COMPILES_ADD_LINK_OPTIONS} ${CHECK_${LANG}_SOURCE_COMPILES_ADD_LIBRARIES} CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${CMAKE_REQUIRED_FLAGS} "${CHECK_${LANG}_SOURCE_COMPILES_ADD_INCLUDES}" OUTPUT_VARIABLE OUTPUT) foreach(_regex ${_FAIL_REGEX}) if("${OUTPUT}" MATCHES "${_regex}") set(${_var} 0) endif() endforeach() if(${_var}) set(${_var} 1 CACHE INTERNAL "Test ${_var}") if(NOT CMAKE_REQUIRED_QUIET) message(CHECK_PASS "Success") endif() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log "Performing ${_lang_textual} SOURCE FILE Test ${_var} succeeded with the following output:\n" "${OUTPUT}\n" "Source file was:\n${_source}\n") else() if(NOT CMAKE_REQUIRED_QUIET) message(CHECK_FAIL "Failed") endif() set(${_var} "" CACHE INTERNAL "Test ${_var}") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Performing ${_lang_textual} SOURCE FILE Test ${_var} failed with the following output:\n" "${OUTPUT}\n" "Source file was:\n${_source}\n") endif() endif() endfunction() cmake_policy(POP)