# Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. #[=======================================================================[.rst: 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. #]=======================================================================] include_guard(GLOBAL) cmake_policy(PUSH) cmake_policy(SET CMP0054 NEW) # if() quoted variables not dereferenced cmake_policy(SET CMP0057 NEW) # if() supports IN_LIST 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) if (NOT _lang IN_LIST _supported_languages) 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)