include(AndroidTestUtilities)

FILES <files>...

Zero or more files needed for testing.

FILES_DEST <device-dir>

Absolute path where the data files are expected to be.

LIBS <libs>...

Zero or more libraries needed for testing.

LIBS_DEST <device-dir>

Absolute path where the libraries are expected to be.

DEVICE_OBJECT_STORE <device-dir>

Absolute path to the on-device location where the data files are initially stored.

DEVICE_TEST_DIR <device-dir>

Absolute path to the root directory of the on-device test location.

NO_LINK_REGEX <regexes>...

A list of regular expression patterns matching file names to be copied from the object store to the test directory, instead of being symlinked.

include(AndroidTestUtilities)
android_add_test_data(


  example_setup_test


  FILES data/protobuffer.p data/file.txt


  LIBS libs/library_1 libs/library_2


  DEVICE_OBJECT_STORE "/sdcard/.ExternalData/SHA"


  DEVICE_TEST_DIR "/data/local/tests/example"
)

include(BundleUtilities)

<app>

The path to the bundle to fix. This can be an .app directory or direct path to an executable.

<libs>

A list of libraries that must be fixed up, but that cannot be automatically determined by the otool output analysis (i.e. plugins). If plugins are passed to this command as this parameter, they should be installed or copied into the bundle before calling this command.

<dirs>

A list of paths where libraries might be found. These paths are searched first when a target without any path info is given. Then standard system locations are also searched: PATH, Framework locations, /usr/lib, etc.

IGNORE_ITEM <files>...

Added in version 3.6.

Optional list of file names to ignore (e.g. IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe").

<src>

The directory of the bundle being copied.

<dst>

The destination directory of the bundle copy.

<libs>

A list of libraries that must be fixed up, but that cannot be automatically determined by the otool output analysis (i.e. plugins). If plugins are passed to this command as this parameter, they should be installed or copied into the bundle before calling this command.

<dirs>

A list of paths where libraries might be found. These paths are searched first when a target without any path info is given. Then standard system locations are also searched: PATH, Framework locations, /usr/lib, etc.

<app>

The path to the application to verify. This can be a .app directory or a standalone executable.

IGNORE_ITEM <files>...

Added in version 3.6.

Optional list of file names to ignore (e.g. IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe").

<app>

The name of the application being processed.

<bundle-var>

Variable name in which to store the resulting path to the .app directory. In case of any error, this variable will contain an error message prefixed with string error:.

<executable-var>

Variable name in which to store the resulting main executable. In case of any error, this variable will contain an error message prefixed with string error:.

<valid-var>

Variable name in which the boolean result is stored whether this command was successful or not.

<keys-var>

Variable name holding the name of the key to be added to the list for the given item.

<context>

The path to the top level loading path used for @loader_path replacement on Apple operating systems. When resolving item, @loader_path references will be resolved relative to the directory of the given context value (presumably another library).

<item>

The item for which to add the key.

<exepath>

The path to the top level executable used for @executable_path replacement on Apple operating systems.

<dirs>

A list of paths where libraries might be found. These paths are searched first when a target without any path info is given. Then standard system locations are also searched: PATH, Framework locations, /usr/lib, etc.

<copyflag>

If set to 1 library symlink structure will be preserved.

<rpaths>

Optional run-time search paths for an executable file or library to help find files.

<app>

The path to the bundle to fix. This can be an .app directory or direct path to an executable.

<libs>

A list of libraries that must be fixed up, but that cannot be automatically determined by the otool output analysis (i.e. plugins). If plugins are passed to this command as this parameter, they should be installed or copied into the bundle before calling this command.

<dirs>

A list of paths where libraries might be found. These paths are searched first when a target without any path info is given. Then standard system locations are also searched: PATH, Framework locations, /usr/lib, etc.

<keys-var>

Variable name holding a list of keys that represent all executable and library files within the bundle.

IGNORE_ITEM <files>...

Added in version 3.6.

Optional list of file names to ignore (e.g. IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe").

BU_COPY_FULL_FRAMEWORK_CONTENTS

By default, this variable is not set. If full frameworks should be embedded in the bundles, set this variable to boolean true before calling the fixup_bundle() command. By default, this command copies the framework dylib itself plus the framework Resources directory.

<resolved-embedded-item>

The bundle item to be fixed up.

<exepath>

The path to the top level executable used for @executable_path replacement on Apple operating systems.

<dirs>

A list of paths where libraries might be found. These paths are searched first when a target without any path info is given. Then standard system locations are also searched: PATH, Framework locations, /usr/lib, etc.

BU_CHMOD_BUNDLE_ITEMS

If this variable is set to boolean true value then bundle items will be marked writable before install_name_tool tool tries to change them.

<bundle>

Name of the bundle being verified.

<result-var>

Name of the variable in which to store a boolean result of whether a verification was successful.

<info-var>

Name of the variable holding any informational messages produced by the verification.

IGNORE_ITEM <files>...

Added in version 3.6.

Optional list of file names to ignore (e.g. IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe").

<bundle>

Name of the bundle being verified.

<result-var>

Name of the variable in which to store a boolean result of whether a verification was successful.

<info-var>

Name of the variable holding any informational messages produced by the verification.

# ...
install(CODE "


  include(BundleUtilities)


  set(BU_CHMOD_BUNDLE_ITEMS TRUE)


  fixup_bundle(


    \"${fixup_exe}\"


    \"${plugins}\"


    \"${bin_dir};${library_dir};${binary_dir}\"


  )
")

include(CheckCCompilerFlag)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckCCompilerFlag)
check_c_compiler_flag(-fno-optimize-strlen HAVE_FNO_OPTIMIZE_STRLEN)
if(HAVE_FNO_OPTIMIZE_STRLEN)


  target_compile_options(


    example


    PRIVATE $<$<COMPILE_LANGUAGE:C>:-fno-optimize-strlen>


  )
endif()

include(CheckCompilerFlag)

<lang>

The language of the compiler used for the check. Supported languages are: C, CXX, CUDA, Fortran, HIP, ISPC, OBJC, and OBJCXX, and Swift.

Added in version 3.21: Support for HIP language.

Added in version 3.26: Support for Swift language.

<flag>

Compiler flag(s) to check. Multiple flags can be specified in one argument as a string using a semicolon-separated list.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckCompilerFlag)
check_compiler_flag(C -fno-optimize-strlen HAVE_FNO_OPTIMIZE_STRLEN)
if(HAVE_FNO_OPTIMIZE_STRLEN)


  target_compile_options(


    example


    PRIVATE $<$<COMPILE_LANGUAGE:C>:-fno-optimize-strlen>


  )
endif()

include(CheckCSourceCompiles)

<code>

C source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

FAIL_REGEX <regexes>...

If one or more regular expression patterns are provided, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckCSourceCompiles)
check_c_source_compiles("


  #include <emmintrin.h>


  int main(void)


  {


    __m128d a = _mm_setzero_pd();


    (void)a;


    return 0;


  }
" PROJECT_HAVE_SSE2_INTRINSICS)

include(CheckCSourceRuns)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckCSourceRuns)
check_c_source_runs("


  #include <stdlib.h>


  #include <stdnoreturn.h>


  noreturn void f(){ exit(0); }


  int main(void) { f(); return 1; }
" HAVE_NORETURN)

include(CheckCXXCompilerFlag)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(-fsycl HAVE_FSYCL_FLAG)
if(HAVE_FSYCL_FLAG)


  target_compile_options(


    example


    PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fsycl>


  )
endif()

include(CheckCXXSourceCompiles)

<code>

C++ source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

FAIL_REGEX <regexes>...

If one or more regular expression patterns are provided, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckCXXSourceCompiles)
check_cxx_source_compiles("


  int main()


  {


    auto lambda = []() { return 42; };


    return lambda();


  }
" HAVE_CXX11_LAMBDAS)

include(CheckCXXSourceRuns)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckCXXSourceRuns)
check_cxx_source_runs([[


  #include <iostream>


  #include <vector>


  int main()


  {


    std::vector<int> v = {1, 2, 3};


    if (v.size() != 3) return 1;


    std::cout << "Vector works correctly." << std::endl;


    return 0;


  }
]] HAVE_WORKING_STD_VECTOR)

include(CheckCXXSymbolExists)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckCXXSymbolExists)
# Check for macro SEEK_SET
check_cxx_symbol_exists(SEEK_SET "cstdio" HAVE_SEEK_SET)
# Check for function std::fopen
check_cxx_symbol_exists(std::fopen "cstdio" HAVE_STD_FOPEN)

include(CheckFortranCompilerFlag)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckFortranCompilerFlag)
check_fortran_compiler_flag(-fallow-argument-mismatch HAVE_FORTRAN_FLAG)
if(HAVE_FORTRAN_FLAG)


  target_compile_options(


    example


    PRIVATE $<$<COMPILE_LANGUAGE:Fortran>:-fallow-argument-mismatch>


  )
endif()

include(CheckFortranFunctionExists)

<function>

The name of the Fortran function.

<variable>

The name of the variable in which to store the check result. This variable will be created as an internal cache variable.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

include(CheckFortranFunctionExists)
include(CMakePushCheckState)
find_package(LAPACK)
if(TARGET LAPACK::LAPACK)


  cmake_push_check_state(RESET)


  set(CMAKE_REQUIRED_LIBRARIES LAPACK::LAPACK)


  check_fortran_function_exists(dgesv PROJECT_HAVE_DGESV)


  cmake_pop_check_state()
endif()

include(CheckFortranSourceCompiles)

<code>

Fortran source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

FAIL_REGEX <regexes>...

If this option is provided with one or more regular expressions, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

SRC_EXT <extension>

Added in version 3.7.

By default, the test source file used for the check will be given a .F file extension. This option can be used to override this with .<extension> instead - .F90 is a typical choice.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckFortranSourceCompiles)
check_fortran_source_compiles("


  pure subroutine foo()


  end subroutine


  program test


    call foo()


  end
" HAVE_PURE SRC_EXT "F90")

include(CheckFortranSourceRuns)

SRC_EXT <extension>

By default, the internal test source file used for the check will be given a .F90 file extension. This option can be used to change the extension to .<extension> instead.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckFortranSourceRuns)
check_fortran_source_runs([[


  program test


  real :: x[*]


  call co_sum(x)


  end program
]] HAVE_COARRAY)

include(CheckFunctionExists)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckFunctionExists)
check_function_exists(fopen HAVE_FOPEN)

include(CheckFunctionExists)
include(CheckSymbolExists)
check_symbol_exists(fdatasync "unistd.h" HAVE_FDATASYNC)
# Check if fdatasync() is available in the C library.
if(NOT HAVE_FDATASYNC)


  check_function_exists(fdatasync HAVE_FDATASYNC_WITHOUT_DECL)
endif()

#ifdef HAVE_FDATASYNC_WITHOUT_DECL


  extern int fdatasync(int);
#endif

include(CheckIncludeFileCXX)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckIncludeFileCXX)
check_include_file_cxx(stdfloat HAVE_STDFLOAT_HEADER)

include(CheckIncludeFile)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckIncludeFile)
check_include_file(unistd.h HAVE_UNISTD_H)

include(CheckIncludeFile)
include(CMakePushCheckState)
cmake_push_check_state(RESET)


  if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")


    set(CMAKE_REQUIRED_DEFINITIONS -D_XOPEN_SOURCE)


  endif()


  check_include_files(ucontext.h HAVE_UCONTEXT_H)
cmake_pop_check_state()

include(CheckIncludeFiles)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckIncludeFiles)
check_include_files(sys/socket.h HAVE_SYS_SOCKET_H)
if(HAVE_SYS_SOCKET_H)


  # The <net/if.h> header on Darwin and BSD-like systems is not self-contained


  # and also requires <sys/socket.h>


  check_include_files("sys/socket.h;net/if.h" HAVE_NET_IF_H)
else()


  check_include_files(net/if.h HAVE_NET_IF_H)
endif()

include(CheckIncludeFiles)
check_include_files("header_1.hpp;header_2.hpp" HAVE_HEADERS LANGUAGE CXX)

include(CheckIPOSupported)

RESULT <result-var>

Set <result-var> variable to YES if IPO is supported by the compiler and NO otherwise. If this option is not given then the command will issue a fatal error if IPO is not supported.

OUTPUT <output-var>

Set <output-var> variable with details about any error.

LANGUAGES <lang>...

Specify languages whose compilers to check.

The following languages are supported:

If this option is not given, the default languages are picked from the current ENABLED_LANGUAGES global property.

include(CheckIPOSupported)
check_ipo_supported() # fatal error if IPO is not supported
set_property(TARGET foo PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)

option(FOO_ENABLE_IPO "Enable IPO/LTO")
if(FOO_ENABLE_IPO)


  include(CheckIPOSupported)


  check_ipo_supported(RESULT result OUTPUT output)


  if(result)


    set_property(TARGET foo PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)


  else()


    message(WARNING "IPO is not supported: ${output}")


  endif()
endif()

include(CheckLanguage)

CMAKE_<LANG>_COMPILER

If the language can be enabled, this variable is set to the compiler that was found. If the language cannot be enabled, this variable is set to NOTFOUND.

If this variable is already set, either explicitly or cached by a previous call, the check is skipped.

CMAKE_<LANG>_HOST_COMPILER

This variable is set when <lang> is CUDA or HIP.

If the check detects an explicit host compiler that is required for compilation, this variable will be set to that compiler. If the check detects that no explicit host compiler is needed, this variable will be cleared.

If this variable is already set, its value is preserved only if CMAKE_<LANG>_COMPILER is also set. Otherwise, the check runs and overwrites CMAKE_<LANG>_HOST_COMPILER with a new result. Note that CMAKE_<LANG>_HOST_COMPILER documents it should not be set without also setting CMAKE_<LANG>_COMPILER to a NVCC compiler.

CMAKE_<LANG>_PLATFORM

This variable is set to the detected GPU platform when <lang> is HIP.

If this variable is already set, its value is always preserved. Only compatible values will be considered for CMAKE_<LANG>_COMPILER.

include(CheckLanguage)
check_language(Fortran)
if(CMAKE_Fortran_COMPILER)


  enable_language(Fortran)
else()


  message(STATUS "No Fortran support")
endif()

include(CheckLibraryExists)

<library>

The name of the library, a full path to a library file, or an Imported Target.

<function>

The name of a function that should be available in the system or user-provided library <library>.

<location>

The directory containing the library file. It is added to the link search path during the check. If this is an empty string, only the default library search paths are used.

<variable>

The name of the variable in which to store the check result. This variable will be created as an internal cache variable.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckLibraryExists)
check_library_exists(curl curl_easy_perform "" HAVE_LIBRARY_CURL)

include(CheckLibraryExists)
check_library_exists(curl curl_easy_perform "/opt/curl/lib" HAVE_LIBRARY_CURL)

find_package(CURL)
# ...
if(TARGET CURL::libcurl)


  include(CheckLibraryExists)


  check_library_exists(CURL::libcurl curl_easy_perform "" HAVE_LIBRARY_CURL)
endif()

include(CheckLinkerFlag)

<lang>

The language of the compiler used for the check. Supported languages are C, CXX, CUDA, Fortran, HIP, OBJC, OBJCXX, and Swift.

Added in version 3.19: Support for CUDA language.

Added in version 3.21: Support for HIP language.

Added in version 3.26: Support for Swift language.

<flag>

Linker flag(s) to check. Multiple flags can be specified in one argument as a string using a semicolon-separated list.

The underlying implementation uses the LINK_OPTIONS target property to test the specified flag. The LINKER: (and SHELL:) prefixes may be used, as described in the Handling Compiler Driver Differences section.

<variable>

The name of the variable to store the check result. This variable will be created as an internal cache variable.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckLinkerFlag)
check_linker_flag(C "LINKER:-z,relro" HAVE_Z_RELRO)
add_executable(example main.c)
if(HAVE_Z_RELRO)


  target_link_options(example PRIVATE "LINKER:-z,relro")
endif()

include(CheckLinkerFlag)
check_linker_flag(C "LINKER:-z,relro;LINKER:-z,now" HAVE_FLAGS)
add_executable(example main.c)
if(HAVE_FLAGS)


  target_link_options(example PRIVATE LINKER:-z,relro LINKER:-z,now)
endif()

include(CheckOBJCCompilerFlag)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckOBJCCompilerFlag)
check_objc_compiler_flag(-fobjc-arc HAVE_OBJC_ARC)
if(HAVE_OBJC_ARC)


  target_compile_options(


    example


    PRIVATE $<$<COMPILE_LANGUAGE:OBJC>:-fobjc-arc>


  )
endif()

include(CheckOBJCSourceCompiles)

<code>

Source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

FAIL_REGEX <regexes>...

If this option is provided with one or more regular expressions, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckOBJCSourceCompiles)
check_objc_source_compiles("


  #import <Foundation/Foundation.h>


  int main()


  {


    NSObject *foo;


    return 0;


  }
" HAVE_WORKING_CODE)

include(CheckOBJCSourceRuns)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckOBJCSourceRuns)
check_objc_source_runs("


  #import <Foundation/Foundation.h>


  int main()


  {


    NSObject *foo;


    return 0;


  }
" HAVE_WORKING_CODE)

include(CheckOBJCXXCompilerFlag)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckOBJCXXCompilerFlag)
check_objcxx_compiler_flag(-fobjc-arc HAVE_OBJC_ARC)
if(HAVE_OBJC_ARC)
target_compile_options(


    example


    PRIVATE $<$<COMPILE_LANGUAGE:OBJCXX>:-fobjc-arc>


  )
endif()

include(CheckOBJCXXSourceCompiles)

<code>

Objective-C++ source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

FAIL_REGEX <regexes>...

If this option is provided with one or more regular expressions, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckOBJCXXSourceCompiles)
check_objcxx_source_compiles("


  #include <vector>


  #import <Foundation/Foundation.h>


  int main()


  {


    std::vector<int> v;


    NSObject *foo;


    return 0;


  }
" HAVE_WORKING_CODE)

include(CheckOBJCXXSourceRuns)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckOBJCXXSourceRuns)
check_objcxx_source_runs("


  #include <vector>


  #import <Foundation/Foundation.h>


  int main()


  {


    std::vector<int> v;


    NSObject *foo;


    return 0;


  }
" HAVE_WORKING_CODE)

OUTPUT_VARIABLE <output>

Set <output> variable with details about any error. If the check is bypassed because it uses cached results from a previous call, the output will be empty even if errors were present in the previous call.

LANGUAGES <lang>...

Check the linkers used for each of the specified languages. If this option is not provided, the command checks all enabled languages.

C, CXX, Fortran are supported.

Added in version 3.23: OBJC, OBJCXX, CUDA, and HIP are supported.

add_executable(foo ...)
include(CheckPIESupported)
check_pie_supported()
set_property(TARGET foo PROPERTY POSITION_INDEPENDENT_CODE TRUE)

add_executable(foo ...)
include(CheckPIESupported)
check_pie_supported(OUTPUT_VARIABLE output LANGUAGES C)
set_property(TARGET foo PROPERTY POSITION_INDEPENDENT_CODE TRUE)
if(NOT CMAKE_C_LINK_PIE_SUPPORTED)


  message(WARNING "PIE is not supported at link time:\n${output}"


                  "PIE link options will not be passed to linker.")
endif()

add_executable(foo ...)
set_property(TARGET foo PROPERTY POSITION_INDEPENDENT_CODE TRUE)

include(CheckPrototypeDefinition)

<function>

The name of the function whose prototype is being checked.

<prototype>

The expected prototype of the function, provided as a string.

<return>

The return value of the function. This will be used as a return value in the function definition body of the generated test program to verify that the function's return type matches the expected type.

<headers>

A semicolon-separated list of header file names required for checking the function prototype.

<variable>

The name of the variable to store the check result. This variable will be created as an internal cache variable.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckPrototypeDefinition)
check_prototype_definition(


  getpwent_r


  "struct passwd *getpwent_r(struct passwd *src, char *buf, int buflen)"


  "NULL"


  "unistd.h;pwd.h"


  HAVE_SOLARIS_GETPWENT_R
)

include(CheckSourceCompiles)

<lang>

Language of the source code to check. Supported languages are: C, CXX, CUDA, Fortran, HIP, ISPC, OBJC, OBJCXX, and Swift.

Added in version 3.21: Support for HIP language.

Added in version 3.26: Support for Swift language.

<code>

The source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<variable>

Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

FAIL_REGEX <regexes>...

If one or more regular expression patterns are provided, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

SRC_EXT <extension>

By default, the internal test source file used for the check will be given a file extension that matches the requested language (e.g., .c for C, .cxx for C++, .F90 for Fortran, etc.). This option can be used to override this with the .<extension> instead.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_TRY_COMPILE_TARGET_TYPE

Internally, the try_compile() command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to EXECUTABLE (the default), the check compiles and links the test source code as an executable program. If set to STATIC_LIBRARY, the test source code is compiled but not linked.

include(CheckSourceCompiles)
check_source_compiles(CXX "


  int main()


  {


    auto lambda = []() { return 42; };


    return lambda();


  }
" HAVE_CXX11_LAMBDAS)

include(CheckSourceCompiles)
check_source_compiles(C [[


  #if !__has_c_attribute(noreturn)


  #  error "No noreturn attribute"


  #endif


  int main(void) { return 0; }
]] HAVE_NORETURN)

include(CheckSourceCompiles)
block()


  set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY")


  check_source_compiles(


    Fortran


    "pure subroutine foo()


    end subroutine"


    HAVE_PURE


  )
endblock()

include(CheckSourceCompiles)
include(CMakePushCheckState)
find_package(PostgreSQL)
if(TARGET PostgreSQL::PostgreSQL)


  cmake_push_check_state(RESET)


    set(CMAKE_REQUIRED_LIBRARIES PostgreSQL::PostgreSQL)


    check_source_compiles(C "


      #include <libpq-fe.h>


      int main(void)


      {


        PGVerbosity e = PQERRORS_SQLSTATE;


        (void)e;


        return 0;


      }


    " HAVE_PQERRORS_SQLSTATE)


  cmake_pop_check_state()
endif()

include(CheckSourceRuns)

<lang>

The programming language of the source <code> to check. Supported languages are: C, CXX, CUDA, Fortran, HIP, OBJC, and OBJCXX.

Added in version 3.21: Support for HIP language.

<code>

The source code to be tested. It must contain a valid source program. For example, it must contain at least a main() function (in C/C++), or a program unit (in Fortran).

<variable>

Name of the internal cache variable with the result of the check. If the code builds and runs with exit code 0, success is indicated by a boolean true value. Failure to build or run is indicated by a boolean false value, such as an empty string or an error message.

SRC_EXT <extension>

By default, the internal test source file used for the check will be given a file extension that matches the requested language (e.g., .c for C, .cxx for C++, .F90 for Fortran, etc.). This option can be used to override this with the .<extension> instead.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckSourceRuns)
check_source_runs(C "


  #include <stdlib.h>


  #include <stdnoreturn.h>


  noreturn void f(){ exit(0); }


  int main(void) { f(); return 1; }
" HAVE_NORETURN)

include(CheckSourceRuns)
check_source_runs(Fortran "


  program test


  real :: x[*]


  call co_sum(x)


  end program
" HAVE_COARRAY)

include(CheckSourceRuns)
check_source_runs(CXX [[


  #include <iostream>


  #include <vector>


  int main()


  {


    std::vector<int> v = {1, 2, 3};


    if (v.size() != 3) return 1;


    std::cout << "Vector works correctly." << std::endl;


    return 0;


  }
]] HAVE_WORKING_STD_VECTOR)

include(CheckSourceRuns)
include(CMakePushCheckState)
cmake_push_check_state(RESET)


  set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)


  if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")


    set(CMAKE_REQUIRED_LIBRARIES gnu)


  endif()


  check_source_runs(C "


    #include <sched.h>


    int main(void)


    {


      if (sched_getcpu() == -1) {


        return 1;


      }


      return 0;


    }


  " HAVE_SCHED_GETCPU)
cmake_pop_check_state()

include(CheckStructHasMember)

LANGUAGE <language>

Use the <language> compiler to perform the check. Acceptable values are C and CXX. If not specified, it defaults to C.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckStructHasMember)
check_struct_has_member(


  "struct timeval"


  tv_sec


  sys/select.h


  HAVE_TIMEVAL_TV_SEC
)

include(CheckStructHasMember)
check_struct_has_member(


  std::tm


  tm_gmtoff


  ctime


  HAVE_TM_GMTOFF


  LANGUAGE CXX
)

include(CheckStructHasMember)
include(CMakePushCheckState)
cmake_push_check_state(RESET)


  set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)


  check_struct_has_member(


    "struct utsname"


    domainname


    sys/utsname.h


    HAVE_UTSNAME_DOMAINNAME


  )
cmake_pop_check_state()

include(CheckSymbolExists)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckSymbolExists)
# Check for macro SEEK_SET
check_symbol_exists(SEEK_SET "stdio.h" HAVE_SEEK_SET)
# Check for function fopen
check_symbol_exists(fopen "stdio.h" HAVE_FOPEN)

include(CheckTypeSize)

<type>

The type or expression being checked.

<variable>

The name of the variable and a prefix used for storing the check results.

BUILTIN_TYPES_ONLY

If given, only compiler-builtin types will be supported in the check. If not given, the command checks for common headers <sys/types.h>, <stdint.h>, and <stddef.h>, and saves results in HAVE_SYS_TYPES_H, HAVE_STDINT_H, and HAVE_STDDEF_H internal cache variables. The type size check automatically includes the available headers, thus supporting checks of types defined in the headers.

LANGUAGE <language>

Uses the <language> compiler to perform the check. Acceptable values are C and CXX. If not specified, it defaults to C.

HAVE_<variable>

Internal cache variable that holds a boolean true or false value indicating whether the type or expression <type> exists.

<variable>

Internal cache variable that holds one of the following values:

<variable>_CODE

CMake variable that holds preprocessor code to define the macro <variable> to the size of the type, or to leave the macro undefined if the type does not exist.

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_INCLUDES

A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the INCLUDE_DIRECTORIES directory property will be ignored.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

CMAKE_EXTRA_INCLUDE_FILES

A semicolon-separated list of extra header files to include when performing the check.

include(CheckTypeSize)
# Check for size of long.
check_type_size(long SIZEOF_LONG)
message("HAVE_SIZEOF_LONG: ${HAVE_SIZEOF_LONG}")
message("SIZEOF_LONG: ${SIZEOF_LONG}")
message("SIZEOF_LONG_CODE: ${SIZEOF_LONG_CODE}")

HAVE_SIZEOF_LONG: TRUE
SIZEOF_LONG: 8
SIZEOF_LONG_CODE: #define SIZEOF_LONG 8

include(CheckTypeSize)
check_type_size(long SIZEOF_LONG)
message("HAVE_SIZEOF_LONG: ${HAVE_SIZEOF_LONG}")
message("SIZEOF_LONG: ${SIZEOF_LONG}")
foreach(key IN LISTS SIZE_OF_LONG_KEYS)


  message("key: ${key}")


  message("value: ${SIZE_OF_LONG-${key}}")
endforeach()
message("SIZEOF_LONG_CODE:
${SIZEOF_LONG_CODE}")

HAVE_SIZEOF_LONG: TRUE
SIZEOF_LONG: 0
key: __i386
value: 4
key: __x86_64
value: 8
SIZEOF_LONG_CODE:
#if defined(__i386)
# define SIZE_OF_LONG 4
#elif defined(__x86_64)
# define SIZE_OF_LONG 8
#else
# error SIZE_OF_LONG unknown
#endif

include(CheckVariableExists)

CMAKE_REQUIRED_FLAGS

A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of CMAKE_<LANG>_FLAGS and its associated configuration-specific CMAKE_<LANG>_FLAGS_<CONFIG> variables are automatically prepended to the compiler command before the contents of this variable.

CMAKE_REQUIRED_DEFINITIONS

A semicolon-separated list of compiler definitions, each of the form -DFOO or -DFOO=bar. A definition for the name specified by the result variable argument of the check command is also added automatically.

CMAKE_REQUIRED_LINK_OPTIONS

Added in version 3.14.

A semicolon-separated list of options to add to the link command (see try_compile() for further details).

CMAKE_REQUIRED_LIBRARIES

A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see try_compile() for further details).

CMAKE_REQUIRED_LINK_DIRECTORIES

Added in version 3.31.

A semicolon-separated list of library search paths to pass to the linker (see try_compile() for further details).

CMAKE_REQUIRED_QUIET

Added in version 3.1.

If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

include(CheckVariableExists)
check_variable_exists(tzname PROJECT_HAVE_TZNAME)

include(CheckVariableExists)
include(CMakePushCheckState)
find_library(SNMP_LIBRARY NAMES netsnmp)
if(SNMP_LIBRARY)


  cmake_push_check_state(RESET)


  set(CMAKE_REQUIRED_LIBRARIES ${SNMP_LIBRARY})


  check_variable_exists(usmHMAC192SHA256AuthProtocol SNMP_HAVE_SHA256)


  cmake_pop_check_state()
endif()

include(CMakeAddFortranSubdirectory)

PROJECT

The name of the Fortran project as defined in the top-level CMakeLists.txt located in <subdir>.

ARCHIVE_DIR

Directory where the project places .lib archive files. A relative path is interpreted as relative to CMAKE_CURRENT_BINARY_DIR.

RUNTIME_DIR

Directory where the project places .dll runtime files. A relative path is interpreted as relative to CMAKE_CURRENT_BINARY_DIR.

LIBRARIES

Names of library targets to create or import into the current project.

LINK_LIBRARIES

Specifies link interface libraries for LIBRARIES. This option expects a list of LINK_LIBS <lib> <deps>... items, where:

CMAKE_COMMAND_LINE

Additional command-line flags passed to cmake(1) command when configuring the Fortran subproject.

NO_EXTERNAL_INSTALL

Prevents installation of the external project.

NOTE:

include(CMakeAddFortranSubdirectory)
cmake_add_fortran_subdirectory(


  fortran-subdir


  PROJECT FortranHelloWorld


  ARCHIVE_DIR lib


  RUNTIME_DIR bin


  LIBRARIES hello world


  LINK_LIBRARIES


    LINK_LIBS hello world # hello library depends on the world library


  NO_EXTERNAL_INSTALL
)
# The Fortran target can be then linked to the main project target.
add_executable(main main.c)
target_link_libraries(main PRIVATE hello)

include(CMakeBackwardCompatibilityCXX)

include(CMakeBackwardCompatibilityCXX)
file(


  CONFIGURE


  OUTPUT config.h


  CONTENT [[


    #cmakedefine CMAKE_NO_ANSI_FOR_SCOPE


    #cmakedefine CMAKE_NO_ANSI_STRING_STREAM


    #cmakedefine CMAKE_NO_ANSI_STREAM_HEADERS


    #cmakedefine CMAKE_NO_STD_NAMESPACE


  ]]
)

include(CMakeDependentOption)

<variable>

The name of a variable that stores the option value.

<help>

A brief description of the option. This string is typically a short line of text and is displayed in the GUI.

<value>

Boolean value for the <variable>, when <condition> evaluates to boolean true.

<condition>

Specifies the conditions that determine whether <variable> is set and visible in the GUI.

The <condition> argument can be:

<else-value>

The value assigned to a local variable named <variable>, when <condition> evaluates to boolean false.

include(CMakeDependentOption)
cmake_dependent_option(USE_SSL_GNUTLS "Use GnuTLS for SSL" ON USE_SSL OFF)

include(CMakeDependentOption)
option(USE_SSL "Enable SSL in the project" OFF)
cmake_dependent_option(USE_SSL_GNUTLS "Use GnuTLS for SSL" ON USE_SSL OFF)
message(STATUS "USE_SSL: ${USE_SSL}")
message(STATUS "USE_SSL_GNUTLS: ${USE_SSL_GNUTLS}")

$ cmake -B build-dir
-- USE_SSL: OFF
-- USE_SSL_GNUTLS: OFF

$ cmake -B build-dir -D USE_SSL=ON
-- USE_SSL: ON
-- USE_SSL_GNUTLS: ON

$ cmake -B build-dir -D USE_SSL=OFF
-- USE_SSL: OFF
-- USE_SSL_GNUTLS: OFF

include(CMakeDependentOption)
cmake_dependent_option(USE_FOO "Use Foo" ON "USE_BAR;NOT USE_ZOT" OFF)

include(CMakeDependentOption)
cmake_dependent_option(USE_FOO "Use Foo" ON "USE_A AND (USE_B OR USE_C)" OFF)

include(CMakeDependentOption)
cmake_dependent_option(


  ENABLE_FOO


  "Enable feature Foo (this option is available when building for Windows)"


  ON


  [[CMAKE_SYSTEM_NAME STREQUAL "Windows"]]


  OFF
)

dot -Tpng -o foo.png foo.dot

• Mandatory: NO
• Default: value of CMAKE_PROJECT_NAME

• Mandatory: NO
• Default: "node [ fontsize = "12" ];"

• Mandatory: NO
• Default: "node"

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: FALSE

• Mandatory: NO
• Default: empty

• Mandatory: NO
• Default: TRUE

• Mandatory: NO
• Default: TRUE

set(FOO_INCLUDE_DIR   "@CMAKE_INSTALL_FULL_INCLUDEDIR@" )
set(FOO_DATA_DIR   "@CMAKE_INSTALL_PREFIX@/@RELATIVE_DATA_INSTALL_DIR@" )
set(FOO_ICONS_DIR   "@CMAKE_INSTALL_PREFIX@/share/icons" )
#...logic to determine installedPrefix from the own location...
set(FOO_CONFIG_DIR  "${installedPrefix}/@CONFIG_INSTALL_DIR@" )

INSTALL_DESTINATION <path>

Path to which the generated file will be installed by the caller, e.g., via install(FILES). The path may be either relative to the INSTALL_PREFIX or absolute.

INSTALL_PREFIX <path>

Path prefix to which the package will be installed by the caller. The <path> argument must be an absolute path. If this argument is not passed, the CMAKE_INSTALL_PREFIX variable will be used instead.

MACOS_INCLUDE_FILE <file>

File to include if the platform is macOS.

IOS_INCLUDE_FILE <file>

File to include if the platform is iOS.

IOS_SIMULATOR_INCLUDE_FILE <file>

File to include if the platform is iOS Simulator.

IOS_CATALYST_INCLUDE_FILE <file>

Added in version 3.31.

File to include if the platform is iOS Catalyst.

TVOS_INCLUDE_FILE <file>

File to include if the platform is tvOS.

TVOS_SIMULATOR_INCLUDE_FILE <file>

File to include if the platform is tvOS Simulator.

WATCHOS_INCLUDE_FILE <file>

File to include if the platform is watchOS.

WATCHOS_SIMULATOR_INCLUDE_FILE <file>

File to include if the platform is watchOS Simulator.

VISIONOS_INCLUDE_FILE <file>

File to include if the platform is visionOS.

VISIONOS_SIMULATOR_INCLUDE_FILE <file>

File to include if the platform is visionOS Simulator.

ERROR_VARIABLE <variable>

If the consuming project is built for an unsupported platform, set <variable> to an error message. The includer may use this information to pretend the package was not found. If this option is not given, the default behavior is to issue a fatal error.

INSTALL_DESTINATION <path>

Path to which the generated file will be installed by the caller, e.g., via install(FILES). The path may be either relative to the INSTALL_PREFIX or absolute.

INSTALL_PREFIX <path>

Path prefix to which the package will be installed by the caller. The <path> argument must be an absolute path. If this argument is not passed, the CMAKE_INSTALL_PREFIX variable will be used instead.

SINGLE_ARCHITECTURES <arch>...

Architectures provided by entries of SINGLE_ARCHITECTURE_INCLUDE_FILES.

SINGLE_ARCHITECTURE_INCLUDE_FILES <file>...

Architecture-specific files. One of them will be loaded when CMAKE_OSX_ARCHITECTURES contains a single architecture matching the corresponding entry of SINGLE_ARCHITECTURES.

UNIVERSAL_ARCHITECTURES <arch>...

Architectures provided by the UNIVERSAL_INCLUDE_FILE.

The list may include $(ARCHS_STANDARD) to support consumption using the Xcode generator, but the architectures should always be listed individually too.

UNIVERSAL_INCLUDE_FILE <file>

A file to load when CMAKE_OSX_ARCHITECTURES contains a (non-strict) subset of the UNIVERSAL_ARCHITECTURES and does not match any one of the SINGLE_ARCHITECTURES.

ERROR_VARIABLE <variable>

If the consuming project is built for an unsupported architecture, set <variable> to an error message. The includer may use this information to pretend the package was not found. If this option is not given, the default behavior is to issue a fatal error.

include(GNUInstallDirs)
set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR}/Foo


    CACHE PATH "Location of header files" )
set(SYSCONFIG_INSTALL_DIR ${CMAKE_INSTALL_SYSCONFDIR}/foo


    CACHE PATH "Location of configuration files" )
#...
include(CMakePackageConfigHelpers)
configure_package_config_file(FooConfig.cmake.in


  ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake


  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Foo


  PATH_VARS INCLUDE_INSTALL_DIR SYSCONFIG_INSTALL_DIR)
write_basic_package_version_file(


  ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake


  VERSION 1.2.3


  COMPATIBILITY SameMajorVersion )
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FooConfig.cmake


              ${CMAKE_CURRENT_BINARY_DIR}/FooConfigVersion.cmake


        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Foo )

set(FOO_VERSION x.y.z)
...
@PACKAGE_INIT@
...
set_and_check(FOO_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
set_and_check(FOO_SYSCONFIG_DIR "@PACKAGE_SYSCONFIG_INSTALL_DIR@")
check_required_components(Foo)

include(CMakePrintHelpers)

include(CMakePrintHelpers)
cmake_print_properties(


  TARGETS foo bar


  PROPERTIES LOCATION INTERFACE_INCLUDE_DIRECTORIES
)

--


 Properties for TARGET foo:


   foo.LOCATION = "/usr/lib/libfoo.so"


   foo.INTERFACE_INCLUDE_DIRECTORIES = "/usr/include;/usr/include/foo"


 Properties for TARGET bar:


   bar.LOCATION = "/usr/lib/libbar.so"


   bar.INTERFACE_INCLUDE_DIRECTORIES = "/usr/include;/usr/include/bar"

include(CMakePrintHelpers)
cmake_print_variables(CMAKE_C_COMPILER CMAKE_MAJOR_VERSION NOT_EXISTS)

-- CMAKE_C_COMPILER="/usr/bin/cc" ; CMAKE_MAJOR_VERSION="3" ; NOT_EXISTS=""

include(CMakePrintSystemInformation)

CMAKE_SYSTEM is Linux-6.11.0-17-generic Linux 6.11.0-17-generic x86_64
CMAKE_SYSTEM file is Platform/Linux
CMAKE_C_COMPILER is /usr/bin/cc
CMAKE_CXX_COMPILER is /usr/bin/c++
CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS is -shared
CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS is -shared
...

include(CMakePushCheckState)

RESET

When this option is specified, the command not only saves the current states of the listed variables but also resets them to empty, allowing them to be reconfigured from a clean state.

include(CMakePushCheckState)
# Save and reset the current state
cmake_push_check_state(RESET)
# Perform check with specific compile definitions
set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
include(CheckSymbolExists)
check_symbol_exists(memfd_create "sys/mman.h" HAVE_MEMFD_CREATE)
# Restore the original state
cmake_pop_check_state()

include(CMakePushCheckState)
# Save and reset the current state
cmake_push_check_state(RESET)
# Perform the first check with additional libraries
set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_DL_LIBS})
include(CheckSymbolExists)
check_symbol_exists(dlopen "dlfcn.h" HAVE_DLOPEN)
# Save current state
cmake_push_check_state()
# Perform the second check with libraries and additional compile definitions
set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
check_symbol_exists(dladdr "dlfcn.h" HAVE_DLADDR)
message(STATUS "${CMAKE_REQUIRED_DEFINITIONS}")
# Output: -D_GNU_SOURCE
# Restore the previous state
cmake_pop_check_state()
message(STATUS "${CMAKE_REQUIRED_DEFINITIONS}")
# Output here is empty
# Reset variables to prepare for the next check
cmake_reset_check_state()
# Perform the next check only with additional compile definitions
set(CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
check_symbol_exists(dl_iterate_phdr "link.h" HAVE_DL_ITERATE_PHDR)
# Restore the original state
cmake_pop_check_state()

cmake -Dallow_versions=8.0.50608.0 -PCMakeVerifyManifest.cmake

• sets CPACK_GENERATOR to the one currently being iterated
• includes the CPACK_PROJECT_CONFIG_FILE
• produces the package for that generator