2023-05-30-14_04_43.log

+ source ../common/common_cmake.sh
++ source /root/mugen/libs/locallibs/common_lib.sh
+++ python3 --version
+++ '[' 0 -eq 0 ']'
+++ source /root/mugen/libs/locallibs/common_lib_python.sh
+ main
++ type -t post_test
+ '[' -n function ']'
+ trap post_test EXIT INT HUP TERM
+ rpm -qa
+ grep expect
++ type -t config_params
+ '[' -n '' ']'
++ type -t pre_test
+ '[' -n function ']'
+ pre_test
+ LOG_INFO 'Start to prepare the test environment.'
+ message='Start to prepare the test environment.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level info --message 'Start to prepare the test environment.'
Tue May 30 14:04:51 2023 - INFO  - Start to prepare the test environment.
+ deploy_env
+ DNF_INSTALL 'cmake gcc-c++ ninja-build make'
+ pkgs='cmake gcc-c++ ninja-build make'
+ node=1
+ '[' -z '' ']'
+ tmpfile=
++ python3 /root/mugen/libs/locallibs/rpm_manage.py install --pkgs 'cmake gcc-c++ ninja-build make' --node 1 --tempfile ''
+ tmpfile2=/tmp/tmpqudw8loi
+ '[' -z '' ']'
+ tmpfile=/tmp/tmpqudw8loi
+ mkdir build
+ cd build
++ awk '{print$3}' /etc/openEuler-release
+ VERSION_ID=23.03
+ LOG_INFO 'Finish preparing the test environment.'
+ message='Finish preparing the test environment.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level info --message 'Finish preparing the test environment.'
Tue May 30 14:07:09 2023 - INFO  - Finish preparing the test environment.
++ type -t run_test
+ '[' -n function ']'
+ run_test
+ LOG_INFO 'Start to run test.'
+ message='Start to run test.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level info --message 'Start to run test.'
Tue May 30 14:07:10 2023 - INFO  - Start to run test.
+ ccmake3 -help
+ grep -E 'Usage|ccmake <path-to-source>'
Usage
  ccmake <path-to-source>
+ CHECK_RESULT 0
+ actual_result=0
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 0 ']'
+ '[' 0 -eq 0 ']'
+ test 0x '!=' 0x
+ return 0
+ grep 'ccmake version'
+ ccmake3 -version
ccmake version 3.24.3
+ CHECK_RESULT 0
+ actual_result=0
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 0 ']'
+ '[' 0 -eq 0 ']'
+ test 0x '!=' 0x
+ return 0
+ ccmake3 --help-full
+ grep variable
 This option may be used to remove one or more variables from the
 variable and otherwise falls back to a builtin default selection.
 ``CMAKE_GENERATOR_TOOLSET`` variable for details.
 ``CMAKE_GENERATOR_PLATFORM`` variable for details.
 ``CMAKE_TOOLCHAIN_FILE`` variable.
 ``CMAKE_INSTALL_PREFIX`` variable. Must be an absolute path.
 List non-advanced cached variables.
 List ``CACHE`` variables will run CMake and list all the variables from
 changed with ``-D`` option.  Changing some of the variables may result
 in more variables being created.  If ``A`` is specified, then it will
 display also advanced variables.  If ``H`` is specified, it will also
 display help for each variable.
 ``CMAKE_MESSAGE_LOG_LEVEL`` as a cache variable instead.
 If both the command line option and the variable are given, the command line
 ``CMAKE_MESSAGE_CONTEXT_SHOW`` as a cache variable instead.
 See also the ``CMAKE_FIND_DEBUG_MODE`` variable for debugging
 as the result variable, where ``<var>`` is an entry in the given
 Like ``--debug-find``, but limiting scope to the specified variable names.
 Like ``--trace``, but with variables expanded.
 Print a warning when an uninitialized variable is used.
 unused variables.  In CMake versions 3.3 through 3.18 the option was broken.
 Don't find variables that are declared on the command line, but not
 Find problems with variable usage in system files.
 Normally, unused and uninitialized variables are searched for only
 Ignore target property ``COMPILE_WARNING_AS_ERROR`` and variable
 generator and the build directory, and a list of variables and other
 specified by the preset (variables, generator, etc.) can all be overridden by
 a variable called ``MYVAR`` to ``1``, but the user sets it to ``2`` with a
  The ``CMAKE_BUILD_PARALLEL_LEVEL`` environment variable, if set,
  specific cache variable will be evaluated to decide, if package restoration
  ``CMAKE_VS_NUGET_PACKAGE_RESTORE`` variable to ``OFF``.
  This option can be omitted if ``VERBOSE`` environment variable or
  ``CMAKE_VERBOSE_MAKEFILE`` cached variable is set.
  This option can be omitted if ``VERBOSE`` environment variable is set.
is not modified.  If variables are defined using ``-D``, this must be
in the set of ``CMAKE_ARGV<n>`` variables passed to the
    interpreting options/environment variables and treat the next argument as
  Display the current environment variables.
``--help-variable <var> [<f>]``
 Print help for one variable and exit.
 The ``cmake-variables(7)`` manual entry for ``<var>`` is
``--help-variable-list [<f>]``
 List variables with help available and exit.
 The list contains all variables for which help may be obtained by
 using the ``--help-variable`` option followed by a variable name.
``--help-variables [<f>]``
 Print cmake-variables manual and exit.
 The ``cmake-variables(7)`` manual is printed in a
 This option can also be enabled by setting the environment variable
 ``CTEST_OUTPUT_ON_FAILURE`` environment variable
 ``CTEST_PARALLEL_LEVEL`` environment variable.
 Define a variable for script mode.
 Pass in variable values on the command line.  Use in conjunction
 with ``-S`` to pass variable values to a dashboard script.  Parsing ``-D``
 arguments as variable values is only attempted if the value
 the environment variable ``DASHBOARD_TEST_FROM_CTEST`` is set.
``--help-variable <var> [<f>]``
 Print help for one variable and exit.
 The ``cmake-variables(7)`` manual entry for ``<var>`` is
``--help-variable-list [<f>]``
 List variables with help available and exit.
 The list contains all variables for which help may be obtained by
 using the ``--help-variable`` option followed by a variable name.
``--help-variables [<f>]``
 Print cmake-variables manual and exit.
 The ``cmake-variables(7)`` manual is printed in a
The module uses variables to obtain a value for each setting
arguments or from variables set in the script.
``CTEST_CHECKOUT_COMMAND`` variable, if set, to initialize the source
  * CTest Script variable: ``CTEST_BINARY_DIRECTORY``
  * ``CTest`` module variable: ``PROJECT_BINARY_DIR``
  * CTest Script variable: ``CTEST_SOURCE_DIRECTORY``
  * ``CTest`` module variable: ``PROJECT_SOURCE_DIR``
  * CTest Script variable: ``CTEST_BZR_COMMAND``
  * ``CTest`` module variable: none
  * CTest Script variable: ``CTEST_BZR_UPDATE_OPTIONS``
  * ``CTest`` module variable: none
  * CTest Script variable: ``CTEST_CVS_COMMAND``
  * ``CTest`` module variable: ``CVSCOMMAND``
  * CTest Script variable: ``CTEST_CVS_UPDATE_OPTIONS``
  * ``CTest`` module variable: ``CVS_UPDATE_OPTIONS``
  * CTest Script variable: ``CTEST_GIT_COMMAND``
  * ``CTest`` module variable: ``GITCOMMAND``
  * CTest Script variable: ``CTEST_GIT_INIT_SUBMODULES``
  * ``CTest`` module variable: ``CTEST_GIT_INIT_SUBMODULES``
  * CTest Script variable: ``CTEST_GIT_UPDATE_CUSTOM``
  * ``CTest`` module variable: ``CTEST_GIT_UPDATE_CUSTOM``
  * CTest Script variable: ``CTEST_GIT_UPDATE_OPTIONS``
  * ``CTest`` module variable: ``GIT_UPDATE_OPTIONS``
  * CTest Script variable: ``CTEST_HG_COMMAND``
  * ``CTest`` module variable: none
  * CTest Script variable: ``CTEST_HG_UPDATE_OPTIONS``
  * ``CTest`` module variable: none
  * CTest Script variable: ``CTEST_P4_CLIENT``
  * ``CTest`` module variable: ``CTEST_P4_CLIENT``
  * CTest Script variable: ``CTEST_P4_COMMAND``
  * ``CTest`` module variable: ``P4COMMAND``
  * CTest Script variable: ``CTEST_P4_OPTIONS``
  * ``CTest`` module variable: ``CTEST_P4_OPTIONS``
  * CTest Script variable: none
  * ``CTest`` module variable: ``CTEST_P4_UPDATE_CUSTOM``
  * CTest Script variable: ``CTEST_P4_UPDATE_OPTIONS``
  * ``CTest`` module variable: ``CTEST_P4_UPDATE_OPTIONS``
  * CTest Script variable: ``CTEST_SVN_COMMAND``
  * ``CTest`` module variable: ``SVNCOMMAND``
  * CTest Script variable: ``CTEST_SVN_OPTIONS``
  * ``CTest`` module variable: ``CTEST_SVN_OPTIONS``
  * CTest Script variable: ``CTEST_SVN_UPDATE_OPTIONS``
  * ``CTest`` module variable: ``SVN_UPDATE_OPTIONS``
  * CTest Script variable: ``CTEST_UPDATE_COMMAND``
  * ``CTest`` module variable: ``<VCS>COMMAND``
  * CTest Script variable: ``CTEST_UPDATE_OPTIONS``
  * ``CTest`` module variable: ``<VCS>_UPDATE_OPTIONS``
  * CTest Script variable: none, detected from source tree
  * ``CTest`` module variable: ``UPDATE_TYPE`` if set,
  * CTest Script variable: ``CTEST_UPDATE_VERSION_ONLY``
  When this variable is set to a non-empty string, CTest will report the value
  version that is checked out. Use of this variable supersedes
  ``UpdateVersionOnly``. Like ``UpdateVersionOnly``, using this variable tells
  * CTest Script variable: ``CTEST_UPDATE_VERSION_OVERRIDE``
  * CTest Script variable: ``CTEST_NIGHTLY_START_TIME``
  * ``CTest`` module variable: ``NIGHTLY_START_TIME`` if set,
  * CTest Script variable: ``CTEST_CONFIGURE_COMMAND``
  * ``CTest`` module variable: ``CMAKE_COMMAND``
  * CTest Script variable: ``CTEST_LABELS_FOR_SUBPROJECTS``
  * ``CTest`` module variable: ``CTEST_LABELS_FOR_SUBPROJECTS``
  * CTest Script variable: ``CTEST_CONFIGURATION_TYPE``
  * ``CTest`` module variable: ``DEFAULT_CTEST_CONFIGURATION_TYPE``,
    initialized by the ``CMAKE_CONFIG_TYPE`` environment variable
  * CTest Script variable: ``CTEST_LABELS_FOR_SUBPROJECTS``
  * ``CTest`` module variable: ``CTEST_LABELS_FOR_SUBPROJECTS``
  * CTest Script variable: ``CTEST_BUILD_COMMAND``
  * ``CTest`` module variable: ``MAKECOMMAND``,
  with CTest via environment variables and files to report
  * CTest Script variable: ``CTEST_USE_LAUNCHERS``
  * ``CTest`` module variable: ``CTEST_USE_LAUNCHERS``
  * CTest Script variable: ``CTEST_RESOURCE_SPEC_FILE``
  * ``CTest`` module variable: ``CTEST_RESOURCE_SPEC_FILE``
  * CTest Script variable: ``CTEST_LABELS_FOR_SUBPROJECTS``
  * ``CTest`` module variable: ``CTEST_LABELS_FOR_SUBPROJECTS``
  * CTest Script variable: ``CTEST_TEST_LOAD``
  * ``CTest`` module variable: ``CTEST_TEST_LOAD``
  * CTest Script variable: ``CTEST_TEST_TIMEOUT``
  * ``CTest`` module variable: ``DART_TESTING_TIMEOUT``
  * CTest Script variable: ``CTEST_COVERAGE_COMMAND``
  * ``CTest`` module variable: ``COVERAGE_COMMAND``
  * CTest Script variable: ``CTEST_COVERAGE_EXTRA_FLAGS``
  * ``CTest`` module variable: ``COVERAGE_EXTRA_FLAGS``
  * CTest Script variable: ``CTEST_MEMORYCHECK_COMMAND``
  * ``CTest`` module variable: ``MEMORYCHECK_COMMAND``
  * CTest Script variable: ``CTEST_MEMORYCHECK_COMMAND_OPTIONS``
  * ``CTest`` module variable: ``MEMORYCHECK_COMMAND_OPTIONS``
  * CTest Script variable: ``CTEST_MEMORYCHECK_TYPE``
  * ``CTest`` module variable: ``MEMORYCHECK_TYPE``
  * CTest Script variable: ``CTEST_MEMORYCHECK_SANITIZER_OPTIONS``
  * ``CTest`` module variable: ``MEMORYCHECK_SANITIZER_OPTIONS``
  * CTest Script variable: ``CTEST_MEMORYCHECK_SUPPRESSIONS_FILE``
  * ``CTest`` module variable: ``MEMORYCHECK_SUPPRESSIONS_FILE``
  * CTest Script variable: none
  * ``CTest`` module variable: none
  * CTest Script variable: none
  * ``CTest`` module variable: ``PURIFYCOMMAND``
  * CTest Script variable: none
  * ``CTest`` module variable: ``VALGRIND_COMMAND``
  * CTest Script variable: none
  * ``CTest`` module variable: ``VALGRIND_COMMAND_OPTIONS``
  * CTest Script variable: none
  * ``CTest`` module variable: ``DRMEMORY_COMMAND``
  * CTest Script variable: none
  * ``CTest`` module variable: ``DRMEMORY_COMMAND_OPTIONS``
  * CTest Script variable: none
  * ``CTest`` module variable: ``CUDA_SANITIZER_COMMAND``
  * CTest Script variable: none
  * ``CTest`` module variable: ``CUDA_SANITIZER_COMMAND_OPTIONS``
  * CTest Script variable: ``CTEST_BUILD_NAME``
  * ``CTest`` module variable: ``BUILDNAME``
  * CTest Script variable: none, detected from server
  * ``CTest`` module variable: ``CTEST_CDASH_VERSION``
  * CTest Script variable: none,
  * ``CTest`` module variable: ``CTEST_SUBMIT_RETRY_COUNT``
  * CTest Script variable: none,
  * ``CTest`` module variable: ``CTEST_SUBMIT_RETRY_DELAY``
  * CTest Script variable: ``CTEST_CURL_OPTIONS``
  * ``CTest`` module variable: ``CTEST_CURL_OPTIONS``
  * CTest Script variable: ``CTEST_DROP_LOCATION``
  * ``CTest`` module variable: ``DROP_LOCATION`` if set,
  * CTest Script variable: ``CTEST_DROP_METHOD``
  * ``CTest`` module variable: ``DROP_METHOD`` if set,
  * CTest Script variable: ``CTEST_DROP_SITE``
  * ``CTest`` module variable: ``DROP_SITE`` if set,
  * CTest Script variable: ``CTEST_DROP_SITE_PASSWORD``
  * ``CTest`` module variable: ``DROP_SITE_PASSWORD`` if set,
  * CTest Script variable: ``CTEST_DROP_SITE_USER``
  * ``CTest`` module variable: ``DROP_SITE_USER`` if set,
  * CTest Script variable: ``CTEST_DROP_SITE_CDASH``
  * ``CTest`` module variable: ``CTEST_DROP_SITE_CDASH``
  * CTest Script variable: ``CTEST_SCP_COMMAND``
  * ``CTest`` module variable: ``SCPCOMMAND``
  * CTest Script variable: ``CTEST_SITE``
  * ``CTest`` module variable: ``SITE``,
  * CTest Script variable: ``CTEST_SUBMIT_URL``
  * ``CTest`` module variable: ``SUBMIT_URL`` if set,
  * CTest Script variable: ``CTEST_SUBMIT_INACTIVITY_TIMEOUT``
  * ``CTest`` module variable: ``CTEST_SUBMIT_INACTIVITY_TIMEOUT``
  * CTest Script variable: ``CTEST_TRIGGER_SITE``
  * ``CTest`` module variable: ``TRIGGER_SITE`` if set,
:ref:`environment variables <ctest-resource-environment-variables>` as
the :ref:`environment variables <ctest-resource-environment-variables>` to
:ref:`environment variables <ctest-resource-environment-variables>`)
``CTEST_RESOURCE_GROUP_COUNT`` environment variable to find out whether or not
resource allocation is activated. This variable will always (and only) be
activated, then the ``CTEST_RESOURCE_GROUP_COUNT`` variable will not exist,
  variables. See the Environment Variables section below for
information to the test executable as a series of environment variables. For
The following variables are passed to the test process:
  This variable will only be defined if ``ctest(1)`` has been given a
  this variable will not be defined.
  group for a given resource type. This variable consists of a series of
  Because some platforms have case-insensitive names for environment variables,
  variable.
to be used can be selected through the ``CPACK_GENERATOR`` variable
  the ``CPACK_GENERATOR`` variable determines the default set of
  Set a CPack variable.  This will override any value set for ``<var>`` in the
  Override/define the value of the ``CPACK_PACKAGE_NAME`` variable used
  for packaging.  Any value set for this variable in the ``CPackConfig.cmake``
  variable used for packaging.  It will override a value set in the
``--help-variable <var> [<f>]``
 Print help for one variable and exit.
 The ``cmake-variables(7)`` manual entry for ``<var>`` is
``--help-variable-list [<f>]``
 List variables with help available and exit.
 The list contains all variables for which help may be obtained by
 using the ``--help-variable`` option followed by a variable name.
``--help-variables [<f>]``
 Print cmake-variables manual and exit.
 The ``cmake-variables(7)`` manual is printed in a
``--help-variable <var> [<f>]``
 Print help for one variable and exit.
 The ``cmake-variables(7)`` manual entry for ``<var>`` is
``--help-variable-list [<f>]``
 List variables with help available and exit.
 The list contains all variables for which help may be obtained by
 using the ``--help-variable`` option followed by a variable name.
``--help-variables [<f>]``
 Print cmake-variables manual and exit.
 The ``cmake-variables(7)`` manual is printed in a
 This option may be used to remove one or more variables from the
 variable and otherwise falls back to a builtin default selection.
 ``CMAKE_GENERATOR_TOOLSET`` variable for details.
 ``CMAKE_GENERATOR_PLATFORM`` variable for details.
 ``CMAKE_TOOLCHAIN_FILE`` variable.
 ``CMAKE_INSTALL_PREFIX`` variable. Must be an absolute path.
``--help-variable <var> [<f>]``
 Print help for one variable and exit.
 The ``cmake-variables(7)`` manual entry for ``<var>`` is
``--help-variable-list [<f>]``
 List variables with help available and exit.
 The list contains all variables for which help may be obtained by
 using the ``--help-variable`` option followed by a variable name.
``--help-variables [<f>]``
 Print cmake-variables manual and exit.
 The ``cmake-variables(7)`` manual is printed in a
The ``BUILD_SHARED_LIBS`` variable may be enabled to change the
``CMAKE_INCLUDE_CURRENT_DIR`` variable can be enabled to conveniently
all targets.  The variable ``CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE``
``CMAKE_DEBUG_TARGET_PROPERTIES`` variable documentation:
requirements.  The ``CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE`` variable
``CMAKE_BUILD_TYPE`` variable. For multi-configuration generators
at configure time by the ``CMAKE_CONFIGURATION_TYPES`` variable,
just like other variables in that any string comparisons made with their
In multi-config generators, the ``CMAKE_CONFIGURATION_TYPES`` variable
``CMAKE_BUILD_TYPE`` variable at configure time and cannot be changed
defines a set of compiler and linker flag variables for the language in use.
These variables follow the convention ``CMAKE_<LANG>_FLAGS_<CONFIG>``,
a custom configuration type, make sure these variables are set appropriately,
typically as cache variables.
the scope of a cmake variable.
   cmake_host_system_information(RESULT <variable> QUERY <key> ...)
   cmake_host_system_information(RESULT <variable> QUERY WINDOWS_REGISTRY <key> ...)
 cmake_host_system_information(RESULT <variable> QUERY <key> ...)
queried.  The list of queried values is stored in ``<variable>``.
  Read :file:`/etc/os-release` file and define the given ``<variable>``
  into a list of read variables
  Get the ``<name>`` variable (see man 5 os-release) if it exists in the
into man 5 os-release variables.
.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_SCRIPTS
.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_<varname>
  ought to be assigned to CMake variables using this naming
  convention.  Example, the ``ID`` variable from the manual becomes
.. variable:: CMAKE_GET_OS_RELEASE_FALLBACK_RESULT
  ``CMAKE_GET_OS_RELEASE_FALLBACK_RESULT_<varname>`` variables in this list.
 cmake_host_system_information(RESULT <variable>
entity is stored in ``<variable>``.
  the variable specified with sub-option ``ERROR_VARIABLE``.
    ``CMAKE_SIZEOF_VOID_P`` variable. If not defined, fallback to
    rules: If ``CMAKE_SIZEOF_VOID_P`` variable is defined. Use the
    following view depending of the content of this variable:
    If ``CMAKE_SIZEOF_VOID_P`` variable is not defined, rely on
  variable holds an empty string.
``cmake_language`` does not introduce a new variable or policy scope.
  Specify a variable in which to store the identification for the
``DIRECTORY`` option is given), this stores an empty string in the variable.
canceled.  The ``deferred_message`` variable reference is not evaluated
In order to evaluate variable references immediately when scheduling a
specified by the ``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variable.
  list in their ``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variable, but
Because some methods expect certain variables to be set in the calling scope,
function.  This ensures it does not introduce a new variable scope.
  If the provider command fulfills the request, it must set the same variable
  the request.  If the provider returns without setting this variable, CMake
  for this method. When the user sets such a variable, they are explicitly
to preserve variables that may be overwritten by a call to
       # not any of the variables the FindGTest module may define.
``CMAKE_MINIMUM_REQUIRED_VERSION`` variable to ``<min>``.
  the ``CMAKE_MINIMUM_REQUIRED_VERSION`` variable won't be set
and defines a set of variables which hold the values of the
  ``ARGV#`` variables of the calling function.  The parsing starts with
``<multi_value_keywords>`` a variable composed of the given ``<prefix>``
variables will then hold the respective value from the argument list
All remaining arguments are collected in a variable
   values at all are collected in a variable
the following variables::
You can then continue and process these variables.
  Always the name of a variable.  For commands that expect a ``<path-var>``
  as input, the variable must exist and it is expected to hold a single path.
  The name of a variable into which the result of a command will be written.
in-place, or in a separate variable named after an ``OUTPUT_VARIABLE``
variable.
  takes literal strings as input, not the names of variables.
conversion is stored in the ``<out-var>`` variable.
  takes a literal string as input, not the name of a variable.
stored in the ``<out-var>`` variable.
  takes a literal string as input, not the name of a variable.
``CMAKE_POLICY_DEFAULT_CMP<NNNN>`` variable sets a default).
 cmake_policy(GET CMP<NNNN> <variable>)
The output ``<variable>`` value will be ``OLD`` or ``NEW`` if the
variable values referenced as ``@VAR@`` or ``${VAR}`` in the input
file content.  Each variable reference will be replaced with the
current value of the variable, or the empty string if the variable
line after the variable name, if any, is processed as above.
  Copy the file without replacing any variable references or other
  Restrict variable replacement to references of the form ``@VAR@``.
                 [RESULT_VARIABLE <variable>]
                 [RESULTS_VARIABLE <variable>]
                 [OUTPUT_VARIABLE <variable>]
                 [ERROR_VARIABLE <variable>]
 The variable will be set to contain the result of last child process.
``RESULTS_VARIABLE <variable>``
 The variable will be set to contain the result of all processes as a
 The variable named will be set with the contents of the standard output
 and standard error pipes, respectively.  If the same variable is named
 See the ``CMAKE_EXECUTE_PROCESS_COMMAND_ECHO`` variable for a way
  the configured variables.
  The output will be duplicated, it will be sent into the configured variables
 file(READ <filename> <variable>
``<variable>``.  Optionally start from the given ``<offset>`` and
 file(STRINGS <filename> <variable> [<options>...])
``<variable>``.  Binary data in the file are ignored.  Carriage return
 Limit the number of total bytes to store in the ``<variable>``.
stores a list in the variable ``myfile`` in which each item is a line
 file(<HASH> <filename> <variable>)
store it in a ``<variable>``.  The supported ``<HASH>`` algorithm names
 file(TIMESTAMP <filename> <variable> [<format>] [UTC])
and store it in ``<variable>``.  Should the command be unable to obtain a
timestamp variable will be set to the empty string ("").
  Name of the variable in which to store the list of resolved dependencies.
  Name of the variable in which to store the list of unresolved dependencies.
  If this variable is not specified, and there are any unresolved dependencies,
This function accepts several variables that determine which tool is used for
.. variable:: CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM
  If this variable is not specified, it is determined automatically by system
.. variable:: CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL
  If this variable is not specified, it is determined automatically by system
.. variable:: CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND
  If this variable is not specified, it is determined by the value of
variable values referenced as ``@VAR@`` or ``${VAR}`` contained therein. The
  Restrict variable replacement to references of the form ``@VAR@``.
 file(GLOB <variable>
 file(GLOB_RECURSE <variable> [FOLLOW_SYMLINKS]
store it into the ``<variable>``.  Globbing expressions are similar to
  Set ``<result>`` variable to ``0`` on success or an error message otherwise.
  If ``RESULT <result>`` is used, the result variable will be
  Set ``<result>`` variable to ``0`` on success or an error message otherwise.
  The environment variable ``CMAKE_INSTALL_MODE`` can override the
 file(SIZE <filename> <variable>)
``<variable>`` variable. Requires that ``<filename>`` is a valid path
 file(READ_SYMLINK <linkname> <variable>)
points to in the result ``<variable>``.  If ``<linkname>`` does not exist or
The ``<result>`` variable, if specified, receives the status of the operation.
  environment variables.  On Windows, the ``USERPROFILE`` environment variable
  is used, falling back to the ``HOME`` environment variable if ``USERPROFILE``
 file(RELATIVE_PATH <variable> <directory> <file>)
store it in the ``<variable>``.
 file(TO_CMAKE_PATH "<path>" <variable>)
 file(TO_NATIVE_PATH "<path>" <variable>)
``LOG <variable>``
  Store a human-readable log of the operation in a variable.
``STATUS <variable>``
  Store the resulting status of the operation in a variable.
  option is not specified, the value of the ``CMAKE_NETRC`` variable
  is not specified, the value of the ``CMAKE_NETRC_FILE`` variable will
  of the ``CMAKE_TLS_VERIFY`` variable will be used instead.
  variable will be used instead.
      [RESULT_VARIABLE <variable>]
``RESULT_VARIABLE`` option. Otherwise result will be stored in ``<variable>``
A cache entry, or a normal variable if ``NO_CACHE`` is specified,
If the full path to a file is found the result is stored in the variable
and the search will not be repeated unless the variable is cleared.
  variable.
  The result of the search will be stored in a normal variable rather than
   If the variable is already set before the call (as a normal or cache
   variable) then the search will not occur.
  with the same variable.
    ``<PackageName>_ROOT`` CMake variable and the
    ``<PackageName>_ROOT`` environment variable.
    The package root variables are maintained as a stack, so if called from
   * ``<prefix>/include/<arch>`` if ``CMAKE_LIBRARY_ARCHITECTURE`` is set, and ``<prefix>/include`` for each ``<prefix>`` in the ``<PackageName>_ROOT`` CMake variable and the ``<PackageName>_ROOT`` environment variable if called from within a find module loaded by ``find_package(<PackageName>)``
2. Search paths specified in cmake-specific cache variables.
3. Search paths specified in cmake-specific environment variables.
5. Search the standard system environment variables.
6. Search cmake variables defined in the Platform files
   The platform paths that these variables contain are locations that
``CMAKE_SYSTEM_IGNORE_PREFIX_PATH`` variables can also cause some
  Added ``CMAKE_FIND_USE_<CATEGORY>_PATH`` variables to globally disable
``CMAKE_FIND_APPBUNDLE`` variables determine the order of
The CMake variable ``CMAKE_FIND_ROOT_PATH`` specifies one or more
from this re-rooting, because that variable is always a path on the host system.
The ``CMAKE_SYSROOT`` variable can also be used to specify exactly one
effects.  See the documentation for that variable for more.
These variables are especially useful when cross-compiling to
  Do not use the ``CMAKE_FIND_ROOT_PATH`` variable.
Once one of the calls succeeds the result variable will be set
A cache entry, or a normal variable if ``NO_CACHE`` is specified,
If the library is found the result is stored in the variable
and the search will not be repeated unless the variable is cleared.
  variable.
  The result of the search will be stored in a normal variable rather than
   If the variable is already set before the call (as a normal or cache
   variable) then the search will not occur.
  with the same variable.
    ``<PackageName>_ROOT`` CMake variable and the
    ``<PackageName>_ROOT`` environment variable.
    The package root variables are maintained as a stack, so if called from
   * ``<prefix>/lib/<arch>`` if ``CMAKE_LIBRARY_ARCHITECTURE`` is set, and ``<prefix>/lib`` for each ``<prefix>`` in the ``<PackageName>_ROOT`` CMake variable and the ``<PackageName>_ROOT`` environment variable if called from within a find module loaded by ``find_package(<PackageName>)``
2. Search paths specified in cmake-specific cache variables.
3. Search paths specified in cmake-specific environment variables.
5. Search the standard system environment variables.
6. Search cmake variables defined in the Platform files
   The platform paths that these variables contain are locations that
``CMAKE_SYSTEM_IGNORE_PREFIX_PATH`` variables can also cause some
  Added ``CMAKE_FIND_USE_<CATEGORY>_PATH`` variables to globally disable
``CMAKE_FIND_APPBUNDLE`` variables determine the order of
The CMake variable ``CMAKE_FIND_ROOT_PATH`` specifies one or more
from this re-rooting, because that variable is always a path on the host system.
The ``CMAKE_SYSROOT`` variable can also be used to specify exactly one
effects.  See the documentation for that variable for more.
These variables are especially useful when cross-compiling to
  Do not use the ``CMAKE_FIND_ROOT_PATH`` variable.
Once one of the calls succeeds the result variable will be set
If the ``CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX`` variable is set all
``lib${CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX}/``.  This variable overrides
A user may set the ``CMAKE_FIND_PACKAGE_PREFER_CONFIG`` variable
Regardless of the mode used, a ``<PackageName>_FOUND`` variable will be
package-specific information may be provided through other variables and
  variable.
is stored in the cmake variable ``<PackageName>_CONFIG``.
``<PackageName>_CONSIDERED_CONFIGS`` variable, and the associated versions
in the ``<PackageName>_CONSIDERED_VERSIONS`` variable.
``CMAKE_LIBRARY_ARCHITECTURE`` variable is set. ``lib*`` includes one
  ``CMAKE_SIZEOF_VOID_P`` variable. If not defined, fall back to
  rules: If the ``CMAKE_SIZEOF_VOID_P`` variable is defined, use the
  following view depending on the content of this variable:
  If the ``CMAKE_SIZEOF_VOID_P`` variable is not defined, rely on the
variables determine the order of preference.
    variable and the ``<PackageName>_ROOT`` environment variable,
    The package root variables are maintained as a stack so if
2. Search paths specified in cmake-specific cache variables.  These
3. Search paths specified in cmake-specific environment variables.
5. Search the standard system environment variables.  This can be
   setting the variable ``CMAKE_FIND_USE_PACKAGE_REGISTRY``
   to ``FALSE`` or the deprecated variable
7. Search cmake variables defined in the Platform files for the
   The platform paths that these variables contain are locations that
   variable to ``FALSE`` or the deprecated variable
``CMAKE_SYSTEM_IGNORE_PREFIX_PATH`` variables can also cause some
   Added the ``CMAKE_FIND_USE_<CATEGORY>`` variables to globally disable
The CMake variable ``CMAKE_FIND_ROOT_PATH`` specifies one or more
from this re-rooting, because that variable is always a path on the host system.
The ``CMAKE_SYSROOT`` variable can also be used to specify exactly one
effects.  See the documentation for that variable for more.
These variables are especially useful when cross-compiling to
  Do not use the ``CMAKE_FIND_ROOT_PATH`` variable.
Once one of the calls succeeds the result variable will be set
By default the value stored in the result variable will be the path at
variable may be set to ``TRUE`` before calling ``find_package`` in order
* Setting the ``CMAKE_DISABLE_FIND_PACKAGE_<PackageName>`` variable
* Setting the ``CMAKE_REQUIRE_FIND_PACKAGE_<PackageName>`` variable
Setting both variables to ``TRUE`` simultaneously is an error.
variables have been defined:
When a version range is specified, the above version variables will hold
variables:
  included or excluded.  Currently, the only supported value for this variable
  included or excluded.  The supported values for this variable are
variable ``PACKAGE_FIND_VERSION_COMPLETE`` will be defined and will hold
sets these variables:
These variables are checked by the ``find_package`` command to determine
is acceptable the following variables are set:
one is chosen: unless the variable ``CMAKE_FIND_PACKAGE_SORT_ORDER``
the two variables ``CMAKE_FIND_PACKAGE_SORT_ORDER`` and
defines variables to provide information about the call arguments (and
When a version range is specified, the above version variables will hold
variables:
  included or excluded.  The possible values for this variable are
variable ``<PackageName>_FIND_VERSION_COMPLETE`` will be defined and will hold
request detailed by these variables; see the find module for details.
A cache entry, or a normal variable if ``NO_CACHE`` is specified,
If the file in a directory is found the result is stored in the variable
and the search will not be repeated unless the variable is cleared.
  variable.
  The result of the search will be stored in a normal variable rather than
   If the variable is already set before the call (as a normal or cache
   variable) then the search will not occur.
  with the same variable.
    ``<PackageName>_ROOT`` CMake variable and the
    ``<PackageName>_ROOT`` environment variable.
    The package root variables are maintained as a stack, so if called from
   * ``<prefix>/include/<arch>`` if ``CMAKE_LIBRARY_ARCHITECTURE`` is set, and ``<prefix>/include`` for each ``<prefix>`` in the ``<PackageName>_ROOT`` CMake variable and the ``<PackageName>_ROOT`` environment variable if called from within a find module loaded by ``find_package(<PackageName>)``
2. Search paths specified in cmake-specific cache variables.
3. Search paths specified in cmake-specific environment variables.
5. Search the standard system environment variables.
6. Search cmake variables defined in the Platform files
   The platform paths that these variables contain are locations that
``CMAKE_SYSTEM_IGNORE_PREFIX_PATH`` variables can also cause some
  Added ``CMAKE_FIND_USE_<CATEGORY>_PATH`` variables to globally disable
``CMAKE_FIND_APPBUNDLE`` variables determine the order of
The CMake variable ``CMAKE_FIND_ROOT_PATH`` specifies one or more
from this re-rooting, because that variable is always a path on the host system.
The ``CMAKE_SYSROOT`` variable can also be used to specify exactly one
effects.  See the documentation for that variable for more.
These variables are especially useful when cross-compiling to
  Do not use the ``CMAKE_FIND_ROOT_PATH`` variable.
Once one of the calls succeeds the result variable will be set
A cache entry, or a normal variable if ``NO_CACHE`` is specified,
If the program is found the result is stored in the variable
and the search will not be repeated unless the variable is cleared.
  variable.
  The result of the search will be stored in a normal variable rather than
   If the variable is already set before the call (as a normal or cache
   variable) then the search will not occur.
  with the same variable.
    ``<PackageName>_ROOT`` CMake variable and the
    ``<PackageName>_ROOT`` environment variable.
    The package root variables are maintained as a stack, so if called from
   * ``<prefix>/[s]bin`` for each ``<prefix>`` in the ``<PackageName>_ROOT`` CMake variable and the ``<PackageName>_ROOT`` environment variable if called from within a find module loaded by ``find_package(<PackageName>)``
2. Search paths specified in cmake-specific cache variables.
3. Search paths specified in cmake-specific environment variables.
5. Search the standard system environment variables.
6. Search cmake variables defined in the Platform files
   The platform paths that these variables contain are locations that
``CMAKE_SYSTEM_IGNORE_PREFIX_PATH`` variables can also cause some
  Added ``CMAKE_FIND_USE_<CATEGORY>_PATH`` variables to globally disable
``CMAKE_FIND_APPBUNDLE`` variables determine the order of
The CMake variable ``CMAKE_FIND_ROOT_PATH`` specifies one or more
from this re-rooting, because that variable is always a path on the host system.
The ``CMAKE_SYSROOT`` variable can also be used to specify exactly one
effects.  See the documentation for that variable for more.
These variables are especially useful when cross-compiling to
  Do not use the ``CMAKE_FIND_ROOT_PATH`` variable.
Once one of the calls succeeds the result variable will be set
At the beginning of each iteration the variable ``<loop_var>`` will be set
separated list of list-valued variables. The ``foreach``
separated list of list-valued variables. The ``foreach``
iteration variables as follows:
  ``loop_var_N`` variables to the current item from the
- if multiple variable names passed, their count should match
  the lists variables count;
  variable is not defined for the current iteration.
``ARGC`` variable which will be set to the number of arguments passed
the ``<property>`` is stored in the variable ``<var>``.
 get_directory_property(<variable> [DIRECTORY <dir>] <prop-name>)
Stores a property of directory scope in the named ``<variable>``.
 get_directory_property(<variable> [DIRECTORY <dir>]
Get a variable definition from a directory.  This form is useful to
get a variable definition from another directory.
If the optional ``CACHE`` argument is specified, the result variable is
optional ``CACHE`` argument is specified, the result variable is added to the
 get_property(<variable>
The first argument specifies the variable in which to store the result.
If the ``SET`` option is given the variable is set to a boolean
option is given the variable is set to a boolean value indicating
If ``BRIEF_DOCS`` or ``FULL_DOCS`` is given then the variable is set to a
 constants, it is treated as a variable or string (see Variable Expansion
``if(<variable>)``
 True if given a variable that is defined to a value that is not a false
 constant.  False otherwise, including if the variable is undefined.
 Note that macro arguments are not variables.
   happens to be a variable name that is affected by ``CMP0054``'s
 True if a variable, cache variable or environment variable
 with given ``<name>`` is defined. The value of the variable
 * Macro arguments are not variables.
   variable.  The expression ``if(DEFINED someName)`` will evaluate to true
   if either a cache or non-cache variable ``someName`` exists.  In
   evaluate to true if a cache variable ``someName`` exists.  Both expressions
   need to be tested if you need to know whether a non-cache variable exists:
  Added support for ``CACHE{<name>}`` variables.
``if(<variable|string> IN_LIST <variable>)``
  True if the given element is contained in the named list variable.
``if(<variable|string> MATCHES regex)``
 True if the given string or variable's value matches the given regular
  ``()`` groups are captured in ``CMAKE_MATCH_<n>`` variables.
``if(<variable|string> LESS <variable|string>)``
 True if the given string or variable's value is a valid number and less
``if(<variable|string> GREATER <variable|string>)``
 True if the given string or variable's value is a valid number and greater
``if(<variable|string> EQUAL <variable|string>)``
 True if the given string or variable's value is a valid number and equal
``if(<variable|string> LESS_EQUAL <variable|string>)``
  True if the given string or variable's value is a valid number and less
``if(<variable|string> GREATER_EQUAL <variable|string>)``
  True if the given string or variable's value is a valid number and greater
``if(<variable|string> STRLESS <variable|string>)``
 True if the given string or variable's value is lexicographically less
 than the string or variable on the right.
``if(<variable|string> STRGREATER <variable|string>)``
 True if the given string or variable's value is lexicographically greater
 than the string or variable on the right.
``if(<variable|string> STREQUAL <variable|string>)``
 True if the given string or variable's value is lexicographically equal
 to the string or variable on the right.
``if(<variable|string> STRLESS_EQUAL <variable|string>)``
  True if the given string or variable's value is lexicographically less
  than or equal to the string or variable on the right.
``if(<variable|string> STRGREATER_EQUAL <variable|string>)``
  True if the given string or variable's value is lexicographically greater
  than or equal to the string or variable on the right.
``if(<variable|string> VERSION_LESS <variable|string>)``
``if(<variable|string> VERSION_GREATER <variable|string>)``
``if(<variable|string> VERSION_EQUAL <variable|string>)``
``if(<variable|string> VERSION_LESS_EQUAL <variable|string>)``
``if(<variable|string> VERSION_GREATER_EQUAL <variable|string>)``
``if(<variable|string> PATH_EQUAL <variable|string>)``
the ``${}`` variable evaluation syntax, and for convenience evaluates
variables named by its arguments as shown in the above signatures.
Note that normal variable evaluation with ``${}`` applies before the if
and is evaluated according to the ``if(<variable>)`` case documented
above-documented condition syntax accepts ``<variable|string>``:
  a defined variable, if so the variable's value is used, otherwise the
  they are defined variables, if so their defined values are used otherwise
  tested to see if they are defined variables, if so their defined values are
  variables, if so their defined values are used otherwise the original value
  variable and it is dereferenced.
  such, otherwise they are assumed to be variables and are dereferenced.
  To prevent ambiguity, potential variable or keyword names can be
  A quoted or bracketed variable or keyword will be interpreted as a
condition syntax accepts ``<variable|string>``.
``RESULT_VARIABLE`` is given the variable ``<var>`` will be set to the
``CMAKE_CURRENT_LIST_FILE`` variable documentation).
If no arguments given, ``include_guard`` has the same scope as a variable,
new values for the list within the current CMake variable scope.  Similar to
the ``set()`` command, the LIST command creates new variable values in
  variables, and therefore cannot be used in LIST commands.)
 list(LENGTH <list> <output variable>)
 list(GET <list> <element index> [<element index> ...] <output variable>)
 list(JOIN <list> <glue> <output variable>)
 list(SUBLIST <list> <begin> <length> <output variable>)
 list(FIND <list> <value> <output variable>)
Appends elements to the list. If no variable named ``<list>`` exists in the
has length 0. If no variable named ``<list>`` exists in the
If no variable name is given, removes exactly one element. Otherwise,
with `N` variable names provided, assign the last `N` elements' values
to the given variables and then remove the last `N` values from
If no variable name is given, removes exactly one element. Otherwise,
with `N` variable names provided, assign the first `N` elements' values
to the given variables and then remove the first `N` values from
Insert elements to the 0th position in the list. If no variable named
                       [OUTPUT_VARIABLE <output variable>])
in-place or in the specified output variable.
are true variables in the usual CMake sense.  In a macro, they are not,
``CMAKE_CURRENT_FUNCTION_LIST_LINE`` variables are not
Since ``ARGN``, ``ARGC``, ``ARGV``, ``ARGV0`` etc. are not variables,
 if(ARGV1) # ARGV1 is not a variable
 if(DEFINED ARGV2) # ARGV2 is not a variable
 if(ARGC GREATER 2) # ARGC is not a variable
 foreach(loop_var IN LISTS ARGN) # ARGN is not a variable
third case, the proper way to check if an optional variable was
Note that if you have a variable with the same name in the scope from
existing variable instead of the arguments. For example:
If you want true CMake variables and/or better CMake scope control you
Mark cmake cached variables as advanced.
cached variables.
An advanced variable will not be displayed in any
then advanced variables are changed back to unadvanced.
then the variables are made advanced.
variable already has an advanced/non-advanced state,
 math(EXPR <variable> "<expression>" [OUTPUT_FORMAT <format>])
Evaluates a mathematical ``<expression>`` and sets ``<variable>`` to the
  CMake Deprecation Error or Warning if variable
  ``CMAKE_MESSAGE_LOG_LEVEL`` variable can be set instead.
  Note that the command line option takes precedence over the cache variable.
  by the content of the ``CMAKE_MESSAGE_INDENT`` variable (converted to
  list variable to a dot-separated string.  The message context will always
  variable to true.  See the ``CMAKE_MESSAGE_CONTEXT`` documentation for
The ``CMAKE_MESSAGE_INDENT`` variable can also be used to add
 option(<variable> "<help_text>" [value])
If ``<variable>`` is already set as a normal or cache variable,
In CMake project mode, a boolean cache variable is created with the option
value. In CMake script mode, a boolean variable is set with the option value.
 separate_arguments(<variable> <mode> [PROGRAM [SEPARATE_ARGS]] <args>)
and stores this list in semicolon-separated standard form in ``<variable>``.
  ``<variable>`` will be empty. Otherwise, ``<variable>`` is a list of 2
  arguments will be split as well and stored in ``<variable>``.
Set a normal, cache, or environment variable to a given value.
See the :ref:`cmake-language(7) variables <CMake Language Variables>`
documentation for the scopes and interaction of normal variables
a :ref:`semicolon-separated list <CMake Language Lists>` to form the actual variable
value to be set.  Zero arguments will cause normal variables to be
unset.  See the ``unset()`` command to unset variables explicitly.
 set(<variable> <value>... [PARENT_SCOPE])
Sets the given ``<variable>`` in the current function or directory scope.
If the ``PARENT_SCOPE`` option is given the variable will be set in
creates a new scope.  This command will set the value of a variable
to the case at hand). The previous state of the variable's value stays the
 set(<variable> <value>... CACHE <type> <docstring> [FORCE])
Sets the given cache ``<variable>`` (cache entry).  Since cache entries
  They may be used to store variables persistently across runs.
  The content of the cache variable will not be directly accessible if a normal
  variable of the same name already exists (see :ref:`rules of variable
  to ``OLD``, any normal variable binding in the current scope will be removed.
 set(ENV{<variable>} [<value>])
Subsequent calls of ``$ENV{<variable>}`` will return this new value.
If no argument is given after ``ENV{<variable>}`` or if ``<value>`` is
environment variable.
Set the given variable to the name of the computer.
 site_name(variable)
On UNIX-like platforms, if the variable ``HOSTNAME`` is set, its value
 string(FIND <string> <substring> <output_variable> [REVERSE])
The index stored in ``<output_variable>`` will also be counted in bytes,
        <replace_string> <output_variable>
with ``<replace_string>`` and store the result in the ``<output_variable>``.
        <output_variable> <input> [<input>...])
``<output_variable>``.
        <output_variable> <input> [<input>...])
matches in the ``<output_variable>`` as a list.
        <replacement_expression> <output_variable>
    ``if(MATCHES)``, save subgroup matches in the variables
 string(APPEND <string_variable> [<input>...])
 string(PREPEND <string_variable> [<input>...])
 string(CONCAT <output_variable> [<input>...])
the result in the named ``<output_variable>``.
 string(JOIN <glue> <output_variable> [<input>...])
string and store the result in the named ``<output_variable>``.
 string(TOLOWER <string> <output_variable>)
 string(TOUPPER <string> <output_variable>)
 string(LENGTH <string> <output_variable>)
Store in an ``<output_variable>`` a given string's length in bytes.
result stored in ``<output_variable>`` will *not* be the number of characters.
 string(SUBSTRING <string> <begin> <length> <output_variable>)
Store in an ``<output_variable>`` a substring of a given ``<string>``.  If
 string(STRIP <string> <output_variable>)
Store in an ``<output_variable>`` a substring of a given ``<string>`` with
 string(GENEX_STRIP <string> <output_variable>)
from the input ``<string>`` and store the result in the ``<output_variable>``.
 string(REPEAT <string> <count> <output_variable>)
 string(COMPARE LESS <string1> <string2> <output_variable>)
 string(COMPARE GREATER <string1> <string2> <output_variable>)
 string(COMPARE EQUAL <string1> <string2> <output_variable>)
 string(COMPARE NOTEQUAL <string1> <string2> <output_variable>)
 string(COMPARE LESS_EQUAL <string1> <string2> <output_variable>)
 string(COMPARE GREATER_EQUAL <string1> <string2> <output_variable>)
Compare the strings and store true or false in the ``<output_variable>``.
 string(<HASH> <output_variable> <input>)
 string(ASCII <number> [<number> ...] <output_variable>)
 string(HEX <string> <output_variable>)
and store the concatenated hex digits in the ``<output_variable>``. Letters in
 string(CONFIGURE <string> <output_variable>
 string(MAKE_C_IDENTIFIER <string> <output_variable>)
underscore and store the result in the ``<output_variable>``.  If the first
        [RANDOM_SEED <seed>] <output_variable>)
 string(TIMESTAMP <output_variable> [<format_string>] [UTC])
and/or time to the ``<output_variable>``.
If the command is unable to obtain a timestamp, the ``<output_variable>``
  If the ``SOURCE_DATE_EPOCH`` environment variable is set,
 string(UUID <output_variable> NAMESPACE <namespace> NAME <name>
  ``<error-variable>`` and the ``<out-var>`` will be set to
  occurs, the ``<error-variable>`` will be set to ``NOTFOUND``.
 string(JSON <out-var> [ERROR_VARIABLE <error-variable>]
 string(JSON <out-var> [ERROR_VARIABLE <error-variable>]
 string(JSON <out-var> [ERROR_VARIABLE <error-variable>]
 string(JSON <out-var> [ERROR_VARIABLE <error-variable>]
 string(JSON <out-var> [ERROR_VARIABLE <error-variable>]
Unset a variable, cache variable, or environment variable.
 unset(<variable> [CACHE | PARENT_SCOPE])
Removes a normal variable from the current scope, causing it
to become undefined.  If ``CACHE`` is present, then a cache variable
is removed instead of a normal variable.  Note that when evaluating
for a normal variable with that name.  If no such normal variable exists,
unsetting a normal variable can expose a cache variable that was previously
hidden.  To force a variable reference of the form ``${VAR}`` to return an
empty string, use ``set(<variable> "")``, which clears the normal variable
If ``PARENT_SCOPE`` is present then the variable is removed from the scope
 unset(ENV{<variable>})
Removes ``<variable>`` from the currently available
Subsequent calls of ``$ENV{<variable>}`` will return the empty string.
variable_watch
Watch the CMake variable for change.
 variable_watch(<variable> [<command>])
If the specified ``<variable>`` changes and no ``<command>`` is given,
``COMMAND(<variable> <access> <value> <current_list_file> <stack>)``
``<variable>``
 Name of the variable being accessed.
 values are only used when the variable has never been set.  Once set,
 variable is later unset.
 The value of the variable.  On a modification, this is the new
 (modified) value of the variable.  On removal, the value is empty.
Also note that an ``if(DEFINED)`` query on the variable does not
Only non-cache variables can be watched using this command.  Access to
cache variables is never watched.  However, the existence of a cache
variable ``var`` causes accesses to the non-cache variable ``var`` to
not use the ``UNKNOWN_`` prefix, even if a non-cache variable ``var``
    ``CMAKE_CROSSCOMPILING`` variable is not set to true).
 :variable:`CMAKE_CURRENT_BINARY_DIR`, and any relative paths inside the
 ``DEPFILE`` should also be relative to :variable:`CMAKE_CURRENT_BINARY_DIR`.
    ``CMAKE_CROSSCOMPILING`` variable is not set to true).
variable ``BUILD_SHARED_LIBS`` is ``ON``.  For ``SHARED`` and
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
 aux_source_directory(<dir> <variable>)
and stores the list in the ``<variable>`` provided.  This command is
 build_command(<variable>
Sets the given ``<variable>`` to a command-line string of the form::
 build_command(<cachevariable> <makecommand>)
It sets the given ``<cachevariable>`` to a command-line string as
``CMAKE_TESTDRIVER_BEFORE_TESTMAIN`` cmake variable can be set to
                  [INITIALIZE_FROM_VARIABLE <variable>])
 VARIABLE  = documents a CMake language variable
 CACHED_VARIABLE = documents a CMake cache variable
  The ``INITIALIZE_FROM_VARIABLE`` option specifies a variable from which the
  The ``<variable>`` name must end with the property name and must not begin
variables that are created by the project command.  Example languages
  If the ``CMAKE_EXPORT_NO_PACKAGE_REGISTRY`` variable
  ``CMAKE_EXPORT_PACKAGE_REGISTRY`` variable to add build directories
resulting .h and .cxx files will be added to a variable named
 get_source_file_property(<variable> <file>
stored in the specified ``<variable>``.  If the source property is not found,
will set ``variable`` to ``NOTFOUND``, whereas inherited properties will search
command and if still unable to find the property, ``variable`` will be set to
the variable ``<VAR>``.  If the target property is not found, the behavior
the variable ``VAR``.  If the test property is not found, the behavior
  The environment variable ``CMAKE_INSTALL_MODE`` can override the
  of the ``CMAKE_INSTALL_PREFIX`` variable.
  mechanism explained in the ``CMAKE_INSTALL_PREFIX`` variable
  ``CMAKE_INSTALL_DEFAULT_COMPONENT_NAME`` variable.
  installation.  Use the ``CMAKE_INSTALL_MESSAGE`` variable
appropriate variable from ``GNUInstallDirs``, or set to a built-in
default value if that variable is not defined.  The same is true for file
The following table shows the target types with their associated variables and
path that begins with the appropriate ``GNUInstallDirs`` variable.
the appropriate cache variables.  The following example shows a static library
corresponding variable from ``GNUInstallDirs``, or by using a
built-in default if that variable is not defined.  See the table below for
the supported file types and their corresponding variables and built-in
``CMAKE_INSTALL_DATAROOTDIR`` as the variable and ``share`` as the built-in
path that begins with the appropriate ``GNUInstallDirs`` variable.
the appropriate cache variables.  The following example shows how to follow
automatically by taking the corresponding variable from
``GNUInstallDirs``, or by using a built-in default if that variable
corresponding variables and built-in defaults.  Projects can provide a
``CMAKE_INSTALL_DATAROOTDIR`` as the variable and ``share`` as the built-in
path that begins with the appropriate ``GNUInstallDirs`` variable.
the appropriate cache variables.
script accepts several variables:
  Set this variable to install only a single CPack component as opposed to all
  Set this variable to change the build type if you are using a multi-config
  This is an environment variable rather than a CMake variable. It allows you
Reads the cache and store the requested entries in variables with their
Sets the name of the project, and stores it in the variable
variable ``CMAKE_PROJECT_NAME``.
Also sets the variables:
Further variables are set by the optional arguments described in the following.
If any of these arguments is not used, then the corresponding variables are
  and sets the variables
    ``CMakeLists.txt``, then the version is also stored in the variable
  Sets the variables
  then the description is also stored in the variable ``CMAKE_PROJECT_DESCRIPTION``.
    Added the ``<PROJECT-NAME>_DESCRIPTION`` variable.
  Sets the variables
  then the URL also is stored in the variable ``CMAKE_PROJECT_HOMEPAGE_URL``.
The variables set through the ``VERSION``, ``DESCRIPTION`` and ``HOMEPAGE_URL``
A number of variables can be defined by the user to specify files to include
* Set the various project-specific variables detailed in the Synopsis
  * Set the variables describing the host and target platforms.
    Language-specific variables might or might not be set at this point.
    On the first run, the only language-specific variables that might be
    language-specific variables cached from a previous run may be set.
      if set. The variable is ignored by CMake thereafter.
variables, then an error will be reported by CMake.  If the use of the feature requires
  of a ``${list}`` variable, be sure to use an explicitly quoted
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
  CMake variables describing platform settings, and those listed by the
  ``CMAKE_TRY_COMPILE_PLATFORM_VARIABLES`` variable, are propagated
variable).  The success or failure of the ``try_compile``, i.e. ``TRUE`` or
  The above example shows how values for variables
  Use after ``COPY_FILE`` to capture into variable ``<var>`` any error
  project, depending on the ``CMAKE_TRY_COMPILE_TARGET_TYPE`` variable.
  Store the output from the build process in the given variable.
  If set, the following variables are passed in to the generated
Set the ``CMAKE_TRY_COMPILE_CONFIGURATION`` variable to choose
  Set the ``CMAKE_TRY_COMPILE_TARGET_TYPE`` variable to specify
  Set the ``CMAKE_TRY_COMPILE_PLATFORM_VARIABLES`` variable to specify
  variables that must be propagated into the test project.  This variable is
  then the language standard variables are honored:
  system customization cache variables are also propagated into the test project.
  The ``CMAKE_TRY_COMPILE_NO_PLATFORM_VARIABLES`` variable may be
  set to disable passing platform variables into the test project.
  The example in ``try_compile()`` shows how values for variables
  Report the compile step build output in a given variable.
  in the given variable.  This option exists for legacy reasons.  Prefer
  Report the output from running the executable in a given variable.
Set the ``CMAKE_TRY_COMPILE_CONFIGURATION`` variable to choose
the ``CMAKE_CROSSCOMPILING`` variable to detect whether CMake is in
``CMAKE_CROSSCOMPILING_EMULATOR`` variable is set.  Instead it
will create cache variables which must be filled by the user or by
variables will have to be set manually to the output of the executable.
block checking the ``CMAKE_CROSSCOMPILING`` variable and
The ``CTEST_BUILD_COMMAND`` variable may be set to explicitly
  ``CTEST_BINARY_DIRECTORY`` variable is used.
  specified the ``CTEST_BUILD_CONFIGURATION`` variable will be checked.
  variable will be checked.
  If not specified the ``CTEST_BUILD_FLAGS`` variable will be checked.
  ``CTEST_BUILD_TARGET`` variable will be checked.  Otherwise the
  Store the number of build errors detected in the given variable.
  Store the number of build warnings detected in the given variable.
  Store the return value of the native build tool in the given variable.
  Store in the ``<result-var>`` variable -1 if there are any errors running
  ``CTEST_BINARY_DIRECTORY`` variable is used.
  ``CTEST_SOURCE_DIRECTORY`` variable is used.
  Store in the ``<result-var>`` variable the return value of the native
  Store in the ``<result-var>`` variable -1 if there are any errors running
  ``CTEST_BINARY_DIRECTORY`` variable is used.
  Store in the ``<result-var>`` variable ``0`` if coverage tools
  Store in the ``<result-var>`` variable -1 if there are any errors running
settings of the variables.  If ``NEW_PROCESS`` is specified then each
If the ``CTEST_CHECKOUT_COMMAND`` variable (or the
``CTEST_CVS_CHECKOUT`` variable) is set, its content is treated as
  to.  If not given, the ``CTEST_SUBMIT_URL`` variable is used.
  Store in the ``<result-var>`` variable the ID assigned to this build by
  Store in the ``<result-var>`` variable ``0`` for success and
  Store in the ``<result-var>`` variable -1 if there are any errors running
  ``CTEST_BINARY_DIRECTORY`` variable is used.
  specified the ``CTEST_TEST_LOAD`` variable will be checked,
  Store in the ``<result-var>`` variable ``0`` if all tests passed.
  Store in the ``<result-var>`` variable -1 if there are any errors running
``CTEST_CUSTOM_TEST_OUTPUT_TRUNCATION`` variables, along with their
  ``CTEST_SOURCE_DIRECTORY`` variable is used.
  Store in the ``<result-var>`` variable the number of files
  Store in the ``<result-var>`` variable -1 if there are any errors running
documentation for information about variables that change the behavior
  Store in the ``<result-var>`` variable -1 if there are any errors running
 build_name(variable)
Sets the specified variable to a string representing the platform and
``CMAKE_CXX_COMPILER`` variables.
variable in which to store the output.  To capture the return value of
commands that will set all the variables needed for library dependency
stored in the variable ``CMAKE_INSTALL_PREFIX``.
stored in the variable ``CMAKE_INSTALL_PREFIX``.
stored in the variable ``CMAKE_INSTALL_PREFIX``.  If
module.  If the command is successfully loaded a variable named
the variable will not be set.
Removes ``VALUE`` from the variable ``VAR``.  This is typically used to
variable_requires
Assert satisfaction of an option's required variables.
 variable_requires(TEST_VARIABLE RESULT_VARIABLE
The first argument (``TEST_VARIABLE``) is the name of the variable to be
tested, if that variable is false nothing else is done.  If
is a variable that is set to true if all the required variables are set.
The rest of the arguments are variables that must be true or not set
, and ``CMAKE_CXX_COMPILE_FEATURES`` variables contain all features
Note that there are no separate compile features properties or variables for
respectively, so the properties and variables for their corresponding base
``CMAKE_CXX_STANDARD`` variable.
available, set the ``<PackageName>_FOUND`` variable to reflect this and
provide any variables, macros and imported targets required to use the
The traditional approach is to use variables for everything, including
In either case (or even when providing both variables and imported
variables are set for the find module.  Most of these are dealt with by
``Foo_FIND_VERSION`` family of variables.  If ``Foo_FIND_QUIETLY`` is
variables starting with underscore are for temporary use only.
variables (either instead of or in addition to creating imported
targets), the following variable names should be used to keep things
consistent between Find modules.  Note that all variables start with
This prefix on the variable names ensures that they do not conflict with
variables of other Find modules.  The same pattern should also be followed
  The final set of include directories listed in one variable for use by
  this variable should not be used as the result variable of a
  (note that this also means this variable should not be used as the
  result variable of a ``find_library()`` command - see
  be appropriate to use this as the result variable of a
  variable for use by client code. This should not be a cache entry.
  variable of this form set to true for a given module.  For example, a
  might set the variable ``Barry_VERSION_3`` to true, whereas an older
  When a variable of this form is set to false, it indicates that the
  be specified by the ``YY`` part of the variable.
  For variables of this form, ``Yy`` is the name of a component for the
  If a variable of this form is set to false, it means that the ``Yy``
  variable will be set to true if the module was deemed to have been found
these variables to control the behavior of Find modules (like entering the
  single library.  It is appropriate to use this as the result variable
  this form as the result variable in a ``find_library()`` command.
  When the module provides only a single library, this variable can be used
  path).  It would be appropriate to use this as the result variable in a
  variable in a ``find_path()`` command.
and release binaries, it is common to create cache variables with a
While these are the standard variable names, you should provide
 This will define the following variables:
 The following cache variables may also be set:
* A section listing result variables provided by the module.
* Optionally a section listing cache variables used by the module, if any.
This should define some variables starting ``PC_Foo_`` that contain the
``Foo_LIBRARY`` variable instead:
contents of the first required variable to indicate where it was found.
traditional variable approach looks like
these variables (see the Standard Variable Names section for more
Most of the cache variables should be hidden in the ``ccmake`` interface unless
If this module replaces an older version, you should set compatibility variables
 # compatibility variables
cmake-env-variables(7)
This page lists environment variables that have special
For general information on environment variables, see the
The ``CMAKE_PREFIX_PATH`` environment variable may be set to a list of
This variable may hold a single prefix or a list of prefixes separated
variable convention on those platforms).
See also the ``CMAKE_PREFIX_PATH`` CMake variable.
The ``ADSP_ROOT`` environment variable specifies a default value
for the ``CMAKE_ADSP_ROOT`` variable when there is no explicit
On Apple Silicon hosts running macOS, set this environment variable to tell
The ``CMAKE_APPLE_SILICON_PROCESSOR`` normal variable, if set,
overrides this environment variable.
If this variable is defined empty the native build tool's default number is
The ``CMAKE_BUILD_TYPE`` environment variable specifies a default value
for the ``CMAKE_BUILD_TYPE`` variable when there is no explicit
Specifies a default value for the ``CMAKE_COLOR_DIAGNOSTICS`` variable
The ``CMAKE_CONFIGURATION_TYPES`` environment variable specifies a
default value for the ``CMAKE_CONFIGURATION_TYPES`` variable
is stored in the ``CMAKE_GENERATOR`` variable.
variables:
The ``CMAKE_INSTALL_MODE`` environment variable allows users to operate
source directory into a destination directory. This environment variable
For the environment variable to take effect, it must be set during the correct
  variable must be set during the configuration phase.
* In order to apply to ``install()``, the environment variable must be
Given the above, it is recommended to set the environment variable consistently
Use this environment variable with caution. The following highlights some
* The way this environment variable interacts with the install step of
by CMake to initialize the variable on the first configuration. Afterwards, it
is available through the cache setting of the variable of the same name. For
any configuration run (including the first), the environment variable will be
ignored if the ``CMAKE_<LANG>_COMPILER_LAUNCHER`` variable is defined.
only be used by CMake to initialize the variable on the first configuration.
Afterwards, it is available through the cache setting of the variable of the
variable will be ignored if the ``CMAKE_<LANG>_LINKER_LAUNCHER``
variable is defined.
The ``CMAKE_MSVCIDE_RUN_PATH`` environment variable sets the default value for
the ``CMAKE_MSVCIDE_RUN_PATH`` variable if not already explicitly set.
Disables verbose output from CMake when ``VERBOSE`` environment variable
The ``CMAKE_OSX_ARCHITECTURES`` environment variable sets the default value for
the ``CMAKE_OSX_ARCHITECTURES`` variable. See
The ``CMAKE_TOOLCHAIN_FILE`` environment variable specifies a default value
for the ``CMAKE_TOOLCHAIN_FILE`` variable when there is no explicit
See the ``CMAKE_INSTALL_PREFIX`` variable to control the
(including the first), the environment variable will be ignored if the
equivalent  ``CMAKE_<TYPE>_LINKER_FLAGS_INIT`` variable is defined.
The ``MACOSX_DEPLOYMENT_TARGET`` environment variable sets the default value for
the ``CMAKE_OSX_DEPLOYMENT_TARGET`` variable.
specified by the ``<PackageName>_ROOT`` environment variable, where
prefixes specified in the ``Foo_ROOT`` environment variable (if set).
This variable may hold a single prefix or a list of prefixes separated
variable convention on those platforms).
See also the ``<PackageName>_ROOT`` CMake variable.
``CMAKE_NO_VERBOSE`` environment variable
configuration runs, the environment variable will be ignored in favor of
run (including the first), the environment variable will be ignored, if the
``CMAKE_ASM<DIALECT>_FLAGS <CMAKE_<LANG>_FLAGS>`` variable is defined.
(including the first), the environment variable will be ignored if the
``CMAKE_C_COMPILER`` variable is defined.
(including the first), the environment variable will be ignored if the
``CMAKE_C_FLAGS`` variable is defined.
run (including the first), the environment variable will be ignored if the
``CMAKE_CSharp_FLAGS`` variable is defined.
run (including the first), the environment variable will be ignored if the
``CMAKE_CUDA_COMPILER`` variable is defined.
run (including the first), the environment variable will be ignored if
the ``CMAKE_CUDA_FLAGS`` variable is defined.
variable is preferred over ``CMAKE_CUDA_HOST_COMPILER``.
This environment variable is primarily meant for use with projects that
  module will use this variable to initialize its ``CUDA_HOST_COMPILER`` setting.
run (including the first), the environment variable will be ignored if the
``CMAKE_CXX_COMPILER`` variable is defined.
including the first), the environment variable will be ignored if
the ``CMAKE_CXX_FLAGS`` variable is defined.
configuration run (including the first), the environment variable will be
variable is defined.
run (including the first), the environment variable will be ignored if
the ``CMAKE_Fortran_FLAGS`` variable is defined.
run (including the first), the environment variable will be ignored if the
``CMAKE_HIP_COMPILER`` variable is defined.
run (including the first), the environment variable will be ignored if
the ``CMAKE_HIP_FLAGS`` variable is defined.
run (including the first), the environment variable will be ignored if the
``CMAKE_ISPC_COMPILER`` variable is defined.
run (including the first), the environment variable will be ignored if
the ``CMAKE_ISPC_FLAGS`` variable is defined.
run (including the first), the environment variable will be ignored if the
``CMAKE_OBJC_COMPILER`` variable is defined.
If ``OBJC`` is not defined, the ``CC`` environment variable will
run (including the first), the environment variable will be ignored if the
``CMAKE_OBJCXX_COMPILER`` variable is defined.
If ``OBJCXX`` is not defined, the ``CXX`` environment variable will
(including the first), the environment variable will be ignored if the
``CMAKE_RC_COMPILER`` variable is defined.
configuration run (including the first), the environment variable will be ignored
if the ``CMAKE_RC_FLAGS`` variable is defined.
(including the first), the environment variable will be ignored if the
``CMAKE_Swift_COMPILER`` variable is defined.
Environment variable that will exist and be set to ``1`` when a test executed
Boolean environment variable that controls if the output should be logged for
Boolean environment variable that affects how ``ctest``
variable is not set or has a value that evaluates to false, output is reported
environment variable if both are given.
Initializes the ``CTEST_USE_LAUNCHERS`` variable if not already defined.
Environment variable that will exist when a test executed by ``ctest(1)``
Keys are a single letter corresponding to a CMake cache variable type:
  of the ``CMAKE_BUILD_TYPE`` variable.  For multi-configuration
  ``CMAKE_CONFIGURATION_TYPES`` variable.
    or ``CMAKE_SYSROOT`` variable is defined.  The value is a
    variable is defined.  The value is a JSON object with one member:
      ``CMAKE_<LANG>_COMPILER`` variable is defined for the current
      ``CMAKE_<LANG>_COMPILER_ID`` variable is defined for the current
      ``CMAKE_<LANG>_COMPILER_VERSION`` variable is defined for the
      ``CMAKE_<LANG>_COMPILER_TARGET`` variable is defined for the
        ``CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES`` variable is
        ``CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES`` variable is
        ``CMAKE_<LANG>_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES`` variable
        ``CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES`` variable is defined
    ``CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS`` variable is defined for
Using variables to build up a more complex generator expression is also a
Again, use helper variables with well-chosen names to build up a readable
is provided by a CMake variable:
  See also the ``CMAKE_SYSTEM_NAME`` variable.
  See also the ``CMAKE_SYSTEM_NAME`` variable.
See also the ``CMAKE_<LANG>_COMPILER_VERSION`` variable, which is
See also the ``CMAKE_<LANG>_COMPILER_ID`` variable, which is closely
  .. include:: ../variable/LINK_LIBRARY_PREDEFINED_FEATURES.txt
  variables:
  The value used for each of these variables is the value as set at the end of
     ``CMAKE_<LANG>_LINK_LIBRARY_USING_<FEATURE>_SUPPORTED`` variable
     ``CMAKE_<LANG>_LINK_LIBRARY_USING_<FEATURE>`` variable.
     ``CMAKE_LINK_LIBRARY_USING_<FEATURE>_SUPPORTED`` variable must be
     ``CMAKE_LINK_LIBRARY_USING_<FEATURE>`` variable.
  .. include:: ../variable/LINK_GROUP_PREDEFINED_FEATURES.txt
  variables:
  The value used for each of these variables is the value as set at the end of
     ``CMAKE_<LANG>_LINK_GROUP_USING_<FEATURE>_SUPPORTED`` variable
     ``CMAKE_<LANG>_LINK_GROUP_USING_<FEATURE>`` variable.
     ``CMAKE_LINK_GROUP_USING_<FEATURE>_SUPPORTED`` variable must be
     ``CMAKE_LINK_GROUP_USING_<FEATURE>`` variable.
  The ``CMAKE_STRIP`` variable will contain the platform's ``strip`` utility, which
    The ``CMAKE_STRIP`` variable will contain the platform's ``strip`` utility, which
The ``Ninja Multi-Config`` generator recognizes the following variables:
  multi-config generators, this variable has a value of
  The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
  The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
  The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
  The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
  See the ``CMAKE_GENERATOR_TOOLSET`` variable for details.
The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
  See the ``CMAKE_GENERATOR_TOOLSET`` variable for details.
``CMAKE_GENERATOR_INSTANCE`` variable may be used to select one.
The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
  See the ``CMAKE_GENERATOR_TOOLSET`` variable for details.
``CMAKE_GENERATOR_INSTANCE`` variable may be used to select one.
and is provided in the ``CMAKE_VS_PLATFORM_NAME_DEFAULT`` variable.
The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
See the ``CMAKE_GENERATOR_TOOLSET`` variable for details.
``CMAKE_GENERATOR_INSTANCE`` variable may be used to select one.
and is provided in the ``CMAKE_VS_PLATFORM_NAME_DEFAULT`` variable.
The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
See the ``CMAKE_GENERATOR_TOOLSET`` variable for details.
  via the ``CMAKE_BUILD_TYPE`` variable.
The variable ``GHS_PRIMARY_TARGET`` can be used to select the target platform.
* The ``CMAKE_GENERATOR_PLATFORM`` variable may be set, perhaps
* The variable ``GHS_TARGET_PLATFORM`` may be set, perhaps via the ``cmake(1)``
* The variable ``GHS_TOOLSET_ROOT`` may be set, perhaps via the ``cmake(1)``
the ``GHS_BSP_NAME`` variable.
    The ``GHS_OS_DIR_OPTION`` variable.
variables:
is provided in the ``CMAKE_XCODE_PLATFORM_TOOLSET`` variable.
  See the ``CMAKE_XCODE_BUILD_SYSTEM`` variable for allowed values.
 The ``CMAKE_CODEBLOCKS_EXCLUDE_EXTERNAL_FILES`` variable may
 The ``CMAKE_CODELITE_USE_TARGETS`` variable may be set to ``ON``
variable.
 No \-escape sequences or ${variable} references are evaluated.
 Both \\-escape sequences and ${variable} references are evaluated.
 whitespace), and make-style variable references (``$(MAKEVAR)``).
 and do not undergo variable expansion.  They are treated as part
A *variable reference* has the form ``${<variable>}`` and is
A variable reference is replaced by the value of the specified
variable or cache entry, or if neither is set, by the empty string.
inside out, e.g. ``${outer_${inner_variable}_variable}``.
Literal variable references may consist of alphanumeric characters,
may be used to evaluate variables of any name.  See also policy
The Variables section documents the scope of variable names
An *environment variable reference* has the form ``$ENV{<variable>}``.
A *cache variable reference* has the form ``$CACHE{<variable>}``,
checking for a normal variable of the same name.  If the cache
allows for variable references in the short form ``<variable>``
instead of ``${<variable>}``.  However, environment variables
always need to be referenced as ``$ENV{<variable>}``.
set or unset a variable, but other commands have semantics
that modify variables as well.
Variables have dynamic scope.  Each variable "set" or "unset"
 in a new variable binding scope.  A variable "set" or "unset"
 Each of the Directories in a source tree has its own variable
 directory, CMake copies all variable bindings currently defined
 variables in one "directory" scope.
 A variable "set" or "unset" not inside a function call binds
 CMake stores a separate set of "cache" variables, or "cache entries",
Otherwise, the variable reference evaluates to an empty string.
The ``cmake-variables(7)`` manual documents the many variables
 Environment variables have global scope in a CMake process.
 Variable References have the form ``$ENV{<variable>}``, using the
 Initial values of the CMake environment variables are those of
 tool to display all current environment variables.
The ``cmake-env-variables(7)`` manual documents environment
variables that have special meaning to CMake.
command stores multiple values into the destination variable
* The interfaces of many CMake commands, variables, and properties accept
  ``ARGV#`` variables.
  its ``PARSE_ARGV`` signature, which uses the ``ARGV#`` variables.
  because they reference arguments using placeholders, not real variables.
can be specified in the ``CMAKE_MODULE_PATH`` variable.
files and accumulates them into a variable.
This key is used as a prefix for CMake variables so that we can
associate a set of variables with a given item based on its key.
Loop over the ``<keys_var>`` list of keys, clearing all the variables
If added, also set all the variables associated with that key.
the ``_EMBEDDED_ITEM`` keyed variable for that prerequisite.  (Most likely
Accumulate changes in a local variable and make *one* call to
If the ``BU_CHMOD_BUNDLE_ITEMS`` variable is set then bundle items will be
This command temporarily sets the ``CMAKE_REQUIRED_DEFINITIONS`` variable
module for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  in such variables may cause a false negative for this check.
This command temporarily sets the ``CMAKE_REQUIRED_DEFINITIONS`` variable
module for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  in such variables may cause a false negative for this check.
  function). The result will be stored in the internal cache variable specified
  variables prior to calling ``check_c_source_compiles()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
  successfully, the internal cache variable specified by ``<resultVar>`` will
  variables prior to calling ``check_c_source_runs()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
This command temporarily sets the ``CMAKE_REQUIRED_DEFINITIONS`` variable
module for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  in such variables may cause a false negative for this check.
  function). The result will be stored in the internal cache variable specified
  variables prior to calling ``check_cxx_source_compiles()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
  successfully, the internal cache variable specified by ``<resultVar>`` will
  variables prior to calling ``check_cxx_source_runs()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
Check if a symbol exists as a function, variable, or macro in ``C++``.
    check_cxx_symbol_exists(<symbol> <files> <variable>)
  ``<files>`` and store the result in a ``<variable>``.  Specify the list of
  as a function or variable then the symbol must also be available for
The following variables may be set before calling this macro to modify
This command temporarily sets the ``CMAKE_REQUIRED_DEFINITIONS`` variable
module for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  in such variables may cause a false negative for this check.
    variable to store the result; will be created as an internal cache variable.
The following variables may be set before calling this macro to modify
  variable ``<resultVar>``, with a boolean true value for success and boolean
  variables prior to calling ``check_fortran_source_compiles()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
  successfully, the internal cache variable specified by ``<resultVar>`` will
  variables prior to calling ``check_fortran_source_runs()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
    check_function_exists(<function> <variable>)
  the result in a ``<variable>``, which will be created as an internal
  cache variable.
The following variables may be set before calling this macro to modify the
    CHECK_INCLUDE_FILE_CXX(<include> <variable> [<flags>])
  ``<variable>``.  The optional third argument may be used to add
The following variables may be set before calling this macro to modify
    CHECK_INCLUDE_FILE(<include> <variable> [<flags>])
  ``<variable>``.  The optional third argument may be used to add
The following variables may be set before calling this macro to modify
    CHECK_INCLUDE_FILES("<includes>" <variable> [LANGUAGE <language>])
  entry named ``<variable>``.  Specify the ``<includes>`` argument
The following variables may be set before calling this macro to modify
   Set ``<result>`` variable to ``YES`` if IPO is supported by the
   Set ``<output>`` variable with details about any error.
``CMAKE_CUDA_HOST_COMPILER`` variable will be set if it was required
 VARIABLE - variable to store the result
            Will be created as an internal cache variable.
The following variables may be set before calling this macro to modify
This command temporarily sets the ``CMAKE_REQUIRED_LINK_OPTIONS`` variable
for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  like ``CMAKE_<LANG>_FLAGS``, unknown flags in such variables may
This command temporarily sets the ``CMAKE_REQUIRED_DEFINITIONS`` variable
module for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  in such variables may cause a false negative for this check.
  function). The result will be stored in the internal cache variable specified
  variables prior to calling ``check_objc_source_compiles()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
  successfully, the internal cache variable specified by ``<resultVar>`` will
  variables prior to calling ``check_objc_source_runs()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
This command temporarily sets the ``CMAKE_REQUIRED_DEFINITIONS`` variable
module for a listing of variables that can otherwise modify the build.
  Since the ``try_compile()`` command forwards flags from variables
  in such variables may cause a false negative for this check.
  function). The result will be stored in the internal cache variable specified
  variables prior to calling ``check_objcxx_source_compiles()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
  successfully, the internal cache variable specified by ``<resultVar>`` will
  variables prior to calling ``check_objcxx_source_runs()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
   Set ``<output>`` variable with details about any error. If the check is
For each language checked, two boolean cache variables are defined.
   VARIABLE - The variable to store the result.
              Will be created as an internal cache variable.
The following variables may be set before calling this function to modify
  internal cache variable specified by ``<resultVar>``, with a boolean true
  variables prior to calling ``check_source_compiles()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
  could be built and run successfully, the internal cache variable specified by
  variables prior to calling ``check_objc_source_runs()``:
    configuration-specific variable are automatically added to the compiler
    If this variable evaluates to a boolean true value, all status messages
  The check is only performed once, with the result cached in the variable
  In order to force the check to be re-evaluated, the variable named by
Check if the given struct or class has the specified member variable
    CHECK_STRUCT_HAS_MEMBER(<struct> <member> <header> <variable>
 <variable> - variable to store the result
The following variables may be set before calling this macro to modify
Provides a macro to check if a symbol exists as a function, variable,
    check_symbol_exists(<symbol> <files> <variable>)
  ``<files>`` and store the result in a ``<variable>``.  Specify the list
  ``<variable>`` will be created as an internal cache variable.
as a function or variable then the symbol must also be available for
The following variables may be set before calling this macro to modify
    check_type_size(<type> <variable> [BUILTIN_TYPES_ONLY]
  in the following variables:
  ``HAVE_<variable>``
  ``<variable>``
       In this case ``<variable>_CODE`` contains C preprocessor tests
       The list of architecture macros is stored in ``<variable>_KEYS``,
       and the value for each key is stored in ``<variable>-<key>``.
  ``<variable>_CODE``
    Holds C preprocessor code to define the macro ``<variable>`` to the size
The following variables may be set before calling this macro to modify
Check if the variable exists.
   VAR      - the name of the variable
   VARIABLE - variable to store the result
              Will be created as an internal cache variable.
 This macro is only for ``C`` variables.
The following variables may be set before calling this macro to modify
define a bunch of backwards compatibility variables
  ``<depends>`` are all true.  Otherwise, a local variable named ``<option>``
  Note that the ``<option>`` variable only has a value which satisfies the
  variable.
This module reads hints about search locations from variables::
expects that the following variables are set using -D:
``CMAKE_SOURCE_DIR``.  If found, the variables set in it are used to
.. variable:: GRAPHVIZ_GRAPH_NAME
.. variable:: GRAPHVIZ_GRAPH_HEADER
.. variable:: GRAPHVIZ_NODE_PREFIX
.. variable:: GRAPHVIZ_EXECUTABLES
.. variable:: GRAPHVIZ_STATIC_LIBS
.. variable:: GRAPHVIZ_SHARED_LIBS
.. variable:: GRAPHVIZ_MODULE_LIBS
.. variable:: GRAPHVIZ_INTERFACE_LIBS
.. variable:: GRAPHVIZ_OBJECT_LIBS
.. variable:: GRAPHVIZ_UNKNOWN_LIBS
.. variable:: GRAPHVIZ_EXTERNAL_LIBS
.. variable:: GRAPHVIZ_CUSTOM_TARGETS
.. variable:: GRAPHVIZ_IGNORE_TARGETS
.. variable:: GRAPHVIZ_GENERATE_PER_TARGET
.. variable:: GRAPHVIZ_GENERATE_DEPENDERS
The variables ``<var1>`` to ``<varN>`` given as ``PATH_VARS`` are the
variables which contain install destinations.  For each of them the macro will
create a helper variable ``PACKAGE_<var...>``.  These helper variables must be
  variable will be used instead.  The default value is good when generating a
setting directories and file locations.  Additionally to setting the variable
the ``Foo_FOUND`` variable to ``FALSE``, so that the package is considered to
variables for all requested required components.  This macro should be
If no ``VERSION`` is given, the ``PROJECT_VERSION`` variable is used.
Convenience functions for printing properties and variables, useful
 cmake_print_variables(var1 var2 ..  varN)
This function will print the name of each variable followed by its value.
 cmake_print_variables(CMAKE_C_COMPILER CMAKE_MAJOR_VERSION DOES_NOT_EXIST)
project to see various internal CMake variables.
the variables ``CMAKE_REQUIRED_FLAGS``, ``CMAKE_REQUIRED_DEFINITIONS``,
The variable contents are pushed on a stack, pushing multiple times is
``CMAKE_REQUIRED_*`` variables to empty values, same as
The ``CPACK_GENERATOR`` variable has different meanings in different
  the ``CPACK_GENERATOR`` variable set in the ``CPackConfig.cmake``
are a variety of variables that can be set to customize the resulting
installers.  The most commonly-used variables are:
.. variable:: CPACK_PACKAGE_NAME
.. variable:: CPACK_PACKAGE_VENDOR
.. variable:: CPACK_PACKAGE_DIRECTORY
  then this will default (internally) to the build dir.  This variable may
.. variable:: CPACK_PACKAGE_VERSION_MAJOR
  Package major version.  This variable will always be set, but its default
.. variable:: CPACK_PACKAGE_VERSION_MINOR
.. variable:: CPACK_PACKAGE_VERSION_PATCH
.. variable:: CPACK_PACKAGE_DESCRIPTION
  this variable is populated from the file named by
.. variable:: CPACK_PACKAGE_DESCRIPTION_FILE
.. variable:: CPACK_PACKAGE_DESCRIPTION_SUMMARY
  ``CMAKE_PROJECT_DESCRIPTION`` variable is set, it is used as the
.. variable:: CPACK_PACKAGE_HOMEPAGE_URL
  ``CMAKE_PROJECT_HOMEPAGE_URL`` variable, which is set by the top
.. variable:: CPACK_PACKAGE_FILE_NAME
.. variable:: CPACK_PACKAGE_INSTALL_DIRECTORY
.. variable:: CPACK_PACKAGE_ICON
.. variable:: CPACK_PACKAGE_CHECKSUM
.. variable:: CPACK_PROJECT_CONFIG_FILE
  ``CPACK_*`` variables at cpack time.
.. variable:: CPACK_RESOURCE_FILE_LICENSE
.. variable:: CPACK_RESOURCE_FILE_README
.. variable:: CPACK_RESOURCE_FILE_WELCOME
.. variable:: CPACK_MONOLITHIC_INSTALL
.. variable:: CPACK_GENERATOR
  variable and any ``CPACK_BINARY_<GENNAME>`` options.
.. variable:: CPACK_OUTPUT_CONFIG_FILE
.. variable:: CPACK_PACKAGE_EXECUTABLES
.. variable:: CPACK_STRIP_FILES
  ``CPACK_STRIP_FILES`` will be a boolean variable which enables
.. variable:: CPACK_VERBATIM_VARIABLES
  If set to ``TRUE``, values of variables prefixed with ``CPACK_`` will be
.. variable:: CPACK_THREADS
The following CPack variables are specific to source packages, and
.. variable:: CPACK_SOURCE_PACKAGE_FILE_NAME
.. variable:: CPACK_SOURCE_STRIP_FILES
  variable which enables stripping of all files (a list of files evaluates
.. variable:: CPACK_SOURCE_GENERATOR
.. variable:: CPACK_SOURCE_OUTPUT_CONFIG_FILE
.. variable:: CPACK_SOURCE_IGNORE_FILES
The following variables are for advanced uses of CPack:
.. variable:: CPACK_CMAKE_GENERATOR
.. variable:: CPACK_INSTALL_CMAKE_PROJECTS
.. variable:: CPACK_SYSTEM_NAME
.. variable:: CPACK_PACKAGE_VERSION
.. variable:: CPACK_TOPLEVEL_TAG
.. variable:: CPACK_INSTALL_COMMANDS
  Extra commands to install components.  The environment variable
.. variable:: CPACK_INSTALL_SCRIPTS
  For every script, the following variables will be set:
  an alternative variable for historical reasons, but its value is ignored if
.. variable:: CPACK_PRE_BUILD_SCRIPTS
.. variable:: CPACK_POST_BUILD_SCRIPTS
.. variable:: CPACK_PACKAGE_FILES
  provided as a full absolute path.  This variable is populated by CPack
  Projects should not try to set this variable themselves.
.. variable:: CPACK_INSTALLED_DIRECTORIES
.. variable:: CPACK_PACKAGE_INSTALL_REGISTRY_KEY
.. variable:: CPACK_CREATE_DESKTOP_LINKS
.. variable:: CPACK_BINARY_<GENNAME>
The following variables influence the component-specific packaging:
.. variable:: CPACK_COMPONENTS_ALL
 The default value of this variable is computed by CPack and contains all
.. variable:: CPACK_<GENNAME>_COMPONENT_INSTALL
 component.  One can change the default behavior by setting this variable to
.. variable:: CPACK_COMPONENTS_GROUPING
 on the value of this variable:
.. variable:: CPACK_COMPONENT_<compName>_DISPLAY_NAME
.. variable:: CPACK_COMPONENT_<compName>_DESCRIPTION
.. variable:: CPACK_COMPONENT_<compName>_GROUP
.. variable:: CPACK_COMPONENT_<compName>_DEPENDS
.. variable:: CPACK_COMPONENT_<compName>_HIDDEN
.. variable:: CPACK_COMPONENT_<compName>_REQUIRED
.. variable:: CPACK_COMPONENT_<compName>_DISABLED
   By default used :variable:`CPACK_PACKAGE_VERSION`.
   By default used :variable:`CPACK_PACKAGE_VERSION`.
 to a variable :variable:`CPACK_IFW_REPOSITORIES_ALL`.
 to a variable :variable:`CPACK_IFW_REPOSITORIES_ALL`.
 to a variable :variable:`CPACK_IFW_PACKAGE_RESOURCES`.
 Copies an ``<input>`` file to an ``<output>`` file and substitutes variable
 Each variable reference will be replaced with the current value of the
 variable, or the empty string if the variable is not defined.
   Name of the variable in which the list of keys is stored
   Name of the variable with the computed "base" of ``KEY``.
   Name of the variable with the result value
the ``CTEST_USE_LAUNCHERS`` variable::
   Default is the value of :variable:`CTEST_SOURCE_DIRECTORY`.
   Default is the value of :variable:`CTEST_BINARY_DIRECTORY`.
   Default is the value of :variable:`CTEST_COVERAGE_COMMAND`.
   Added support for the :variable:`CTEST_CUSTOM_COVERAGE_EXCLUDE` variable.
For convenience, you may set the ENV variable
include(CTestUseLaunchers), it will use the value of the ENV variable
to initialize a CTEST_USE_LAUNCHERS cache variable.  This cache
variable initialization only occurs if CTEST_USE_LAUNCHERS is not
     <outVar>   # Output variable
 the ``ExternalData_URL_TEMPLATES`` variable, or may be found locally
 variable.
The following variables configure behavior.  They should be set before
.. variable:: ExternalData_BINARY_ROOT
  The ``ExternalData_BINARY_ROOT`` variable may be set to the directory to
.. variable:: ExternalData_CUSTOM_SCRIPT_<key>
.. variable:: ExternalData_LINK_CONTENT
  The ``ExternalData_LINK_CONTENT`` variable may be set to the name of a
.. variable:: ExternalData_NO_SYMLINKS
  some platforms.  The ``ExternalData_NO_SYMLINKS`` variable may be set
.. variable:: ExternalData_OBJECT_STORES
  The ``ExternalData_OBJECT_STORES`` variable may be set to a list of local
.. variable:: ExternalData_SERIES_PARSE
.. variable:: ExternalData_SOURCE_ROOT
  The ``ExternalData_SOURCE_ROOT`` variable may be set to the highest source
.. variable:: ExternalData_TIMEOUT_ABSOLUTE
  The ``ExternalData_TIMEOUT_ABSOLUTE`` variable sets the download
.. variable:: ExternalData_TIMEOUT_INACTIVITY
  The ``ExternalData_TIMEOUT_INACTIVITY`` variable sets the download
.. variable:: ExternalData_URL_ALGO_<algo>_<key>
.. variable:: ExternalData_URL_TEMPLATES
  with ``ExternalData_URL_ALGO_<algo>_<key>`` variables to gain more
specified in the ``ExternalData_URL_TEMPLATES`` variable, it is
A variable corresponding to the key, ``ExternalData_CUSTOM_SCRIPT_<key>``,
the following variables:
.. variable:: ExternalData_CUSTOM_LOCATION
  When a custom fetch script is loaded, this variable is set to the
.. variable:: ExternalData_CUSTOM_FILE
  When a custom fetch script is loaded, this variable is set to the
file or set a variable:
.. variable:: ExternalData_CUSTOM_ERROR
  it must set this variable to a short one-line message describing
   interpreted with respect to :variable:`CMAKE_CURRENT_BINARY_DIR` at the
       determined by the :variable:`CMAKE_TLS_VERIFY` variable (see
       :variable:`CMAKE_TLS_CAINFO` variable will be used instead (see
       :variable:`CMAKE_NETRC` variable will be used instead
       is not specified, the value of the :variable:`CMAKE_NETRC_FILE` variable
       The variable ``CMAKE_EP_GIT_REMOTE_UPDATE_STRATEGY`` can be set to
       override the default strategy.  This variable should not be set by a
     a cache variable under the developer's control rather than hard-coding
     project also provides a cache variable or some other convenient method
     :variable:`CMAKE_GENERATOR_PLATFORM`). It is an error to provide this
     :variable:`CMAKE_GENERATOR_TOOLSET`). It is an error to provide this
     :variable:`CMAKE_GENERATOR_INSTANCE`). It is an error to provide this
     This is an alternate way of specifying cache variables where command line
     as initial defaults only and will not override any variables already set
       customization cache variables are propagated into the external project.
     If the :envvar:`CMAKE_INSTALL_MODE` environment variable is set when the
     :envvar:`CMAKE_INSTALL_MODE` environment variable changes from one run
     This can be useful where list variables may be given in commands where
  The function stores property values in variables of the same name. Property
.. variable:: FeatureSummary_PKG_TYPES
.. variable:: FeatureSummary_REQUIRED_PKG_TYPES
.. variable:: FeatureSummary_DEFAULT_PKG_TYPE
.. variable:: FeatureSummary_<TYPE>_DESCRIPTION
                    [VAR <variable_name>]
 :variable:`FeatureSummary_PKG_TYPES` global property, the following
 information is "printed" into the specified variable.  If ``FILENAME`` is
 :variable:`FeatureSummary_REQUIRED_PKG_TYPES` global property has not been
 The default value for the :variable:`FeatureSummary_REQUIRED_PKG_TYPES` global
 The :variable:`FeatureSummary_DEFAULT_PKG_TYPE` global property can be
   variable.
 Example 2, print the enabled features into the variable
   :variable:`FeatureSummary_PKG_TYPES` global property.
 variable or a list of conditions.
   # Set custom variables, policies, etc.
    ``CMAKE_NETRC`` and ``CMAKE_NETRC_FILE`` variables now
    they do for ``ExternalProject_Add()``. Previously, these variables
      ``CMAKE_FIND_PACKAGE_TARGETS_GLOBAL`` variable is set to true
      The value of the ``FETCHCONTENT_TRY_FIND_PACKAGE_MODE`` variable
      If the ``CMAKE_FIND_PACKAGE_TARGETS_GLOBAL`` variable is set to
      ``find_package()``, even if that variable was false when the
    ``<lowercaseName>_BINARY_DIR`` variables in the same way as a call to
      variable points to is cleared at the start of every CMake run.
      variables that their normal (installed) package config file would
      or set any variables and therefore have no need to do this).
  ``CMAKE_VERIFY_INTERFACE_HEADER_SETS`` variable provides that
  intuitive behavior.  You can use variables like
  like variable or directory scope.  Therefore, it doesn't matter where in the
  ``FetchContent_Populate()`` will set three variables in the scope of the
  ``<lowercaseName>_BINARY_DIR`` variables is to call
  The values of the three variables can also be retrieved from anywhere in the
    ``FETCHCONTENT_UPDATES_DISCONNECTED`` cache variables are ignored.
  variables are still returned to the caller, but since these locations are
  hierarchy.  No ``<lowercaseName>_POPULATED`` variable is set in the caller's
    cache variable has no effect on ``FetchContent_Populate()`` calls where the
  ``CMAKE_MAKE_PROGRAM`` variables will need to be set appropriately
  which is the name of the variable in which to store that property.  Most of
  set the same variables as a call to
  which ensures that the relevant variables will always be defined regardless
      # Set custom variables, policies, etc.
A number of cache variables can influence the behavior where details from a
  All of these variables are intended for the developer to customize behavior.
.. variable:: FETCHCONTENT_BASE_DIR
  cache variable controls the point under which all content population
.. variable:: FETCHCONTENT_QUIET
.. variable:: FETCHCONTENT_FULLY_DISCONNECTED
.. variable:: FETCHCONTENT_UPDATES_DISCONNECTED
.. variable:: FETCHCONTENT_TRY_FIND_PACKAGE_MODE
  This variable modifies the details that ``FetchContent_Declare()``
  of ``FetchContent_MakeAvailable()``, it is the variable's value when
  difference what the variable is set to when
  ``FetchContent_MakeAvailable()`` is called.  Since the variable should
  ``find_package()`` to satisfy a dependency.  The variable can be set
  variable has a non-empty value for a dependency, it is assumed that the
In addition to the above, the following variables are also defined for each
.. variable:: FETCHCONTENT_SOURCE_DIR_<uppercaseName>
  content and the ``<lowercaseName>_SOURCE_DIR`` variable returned to the
.. variable:: FETCHCONTENT_UPDATES_DISCONNECTED_<uppercaseName>
``FETCHCONTENT_TRY_FIND_PACKAGE_MODE`` variable to ``ALWAYS``.
CMake provides a FindGTest module which defines some variables that older
it also sets a variable which is meaningful to the subproject before pulling
directory.  The ``CMAKE_TOOLCHAIN_FILE`` variable is not used until
  ``<PackageName>_FOUND`` variable.  The package is considered found if all
  variables listed contain valid results, e.g. valid filepaths.
  The ``<PackageName>_FOUND`` variable will be set to ``TRUE`` if all
  the variables ``<required-var>...`` are valid and any optional
    ``<PACKAGENAME>_FOUND`` as the result variable.  This exists only
    Result variables of both names are always set for compatibility.
    Specify the variables which are required for this package.
    user to set the missing variable values.  Therefore these should
    variables like ``FOO_LIBRARIES``.
    Specify the name of a variable that holds the version of the package
    and the ``<PackageName>_FOUND`` variable will be set to ``FALSE``
  ``FPHSA_NAME_MISMATCHED`` variable may be set to bypass the warning if using
  usage, the variable's value will be used if defined when the
    Specify a variable to get back a message describing the result of the check.
This module also provides the following variables to specify
new possible manglings.  Set the variables::
           [CUSTOM_CONTENT_FROM_VARIABLE <variable>]
and the convenience variables
They will be followed by content taken from the variable specified by
 ADD_COMPILER_EXPORT_FLAGS( [<output_variable>] )
in the variable named <prerequisites_var> should be empty on first
is the name of a CMake variable to contain the results.
  The variable GET_PREREQUISITES_VERBOSE can be set to true to enable verbose
Append <value> to the list variable <list_var> only if the value is
describing type of prerequisite is returned in variable named
describing type of prerequisite is returned in variable named
Provides install directory variables as defined by the
Inclusion of this module defines the following variables:
  ``CMAKE_INSTALL_PREFIX`` variable.  However, there are some
    run-time variable data (``LOCALSTATEDIR/run``)
 Set the given variable ``absvar`` to the absolute path contained
 within the variable ``var``.  This is to allow the computation of an
 ``CMAKE_INSTALL_FULL_<dir>`` variables, it is exposed publicly to
 allow users who create additional path variables to also compute
   this value through the variable ``${dir}``.
   The variable named by ``outVar`` will be populated in the calling scope
 script via the ``<target>_TESTS`` variable.
   Make the list of tests available in the variable ``var``, rather than the
   Note that this variable is only available in CTest.
   ``CMAKE_GTEST_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not
libraries and add install rules for them.  Some optional variables
    One may set a ``CMAKE_WINDOWS_KITS_10_DIR`` *environment variable*
Sets the variable named ${var} to the number of physical cores
good values for the variables
  Stores in variable ``<var>`` either 1 or 0 indicating whether the
Check if the compiler restricts the scope of variables declared in a
This module defines variables and macros required to build eCos application.
It contains the following variables: ECOS_DEFINITIONS
eCos configuration file has a different name, adjust this variable for
   :variable:`CMAKE_CURRENT_BINARY_DIR` is used as the output directory.
 Some variables can be set to customize the behavior of ``add_jar()`` as well
   If the target is a JNI library, sets this boolean variable to ``TRUE`` to
 returns generated files through variable specified by the ``GENERATED_FILES``
   :variable:`CMAKE_CURRENT_BINARY_DIR` is used as the output directory.
 variable and the search will not repeated unless the variable is
 the same variable.
   The ``ENV`` var sub-option reads paths from a system environment variable.
   relative to :variable:`CMAKE_CURRENT_SOURCE_DIR`.
   :variable:`CMAKE_CURRENT_SOURCE_DIR` directory is used.
   ``SWIG_MODULE_<name>_REAL_NAME`` variable.
   current value of the :variable:`BUILD_SHARED_LIBS` variable is ``ON``. If
   option). If not given, the ``CMAKE_SWIG_OUTDIR`` variable will be used.
   ``UseSWIG_MODULE_VERSION`` variable as follows:
     the :variable:`CMAKE_CURRENT_BINARY_DIR` directory.
   variable will be used. If neither is specified, ``OUTPUT_DIR`` or
     This behavior can be overridden by specifying the variable
   ``OUTPUT_DIR`` option or the ``CMAKE_SWIG_OUTDIR`` variable are specified.
   If variable ``UseSWIG_TARGET_NAME_PREFERENCE`` is set to ``STANDARD``, this
Some variables can be set to customize the behavior of ``swig_add_library``
  itself. This variable is only meaningful for
  initialized with the value of this variable.
This module defines the following variables:
Cache variables
The following cache variables may also be set:
This module sets the following variables:
This module defines the following variables:
The following cache variables are also available to set or use:
The module defines the following variables:
The macro defines the following variables:
The following variables may be set to influence this module's behavior:
This module defines the following variables:
The above environment scripts set the ``MKLROOT`` environment variable
runtime libraries to the dynamic library loader environment variable for
This module defines the following variables:
    In previous CMake versions, this variable used the raw version string
  The ``Boost_VERSION_<PART>`` variables.
Cache variables
  Per-configuration variables ``Boost_LIBRARY_DIR_RELEASE`` and
This module reads hints about search locations from variables:
  specified by these hint variables. Default is ``OFF``.
result variables.  Note that some hint names start in upper-case
``BOOST``.  One may specify these as environment variables if they are
not specified as CMake variables or cache entries.
hint variables (excluding ``BOOST_LIBRARYDIR``) and saves the result in
tree (excluding environment variables) this module discards previous
than variables created by this module: multiple calls to
setting variables:
Other variables one may set to control this module are:
 This module defines the following variables
 This module accepts the following variables
This module defines the following variables:
Cache variables
The following cache variables may also be set:
variables:
This module defines the following variables
2. If the ``CUDAToolkit_ROOT`` cmake configuration variable (e.g.,
   ``-DCUDAToolkit_ROOT=/some/path``) *or* environment variable is defined, it
   will be searched.  If both an environment variable **and** a
   configuration variable are specified, the *configuration* variable takes
3. If the CUDA_PATH environment variable is defined, it will be searched
Result variables
    features of the Toolkit.  This variable is set for the convenience of
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
This module defines the following variables:
This module defines the following variables:
The following variable are provided for backward compatibility:
The module defines the following variables:
 this variable controlled if the Python test
The module defines the following variables::
* Step 2:  If step 1 failed, rely on *FindDCMTK.cmake* to set `DCMTK_*` variables details below.
  This is set to TRUE if all the above variables were set.
The following variables are defined by this module:
.. variable:: DOXYGEN_FOUND
.. variable:: DOXYGEN_VERSION
  old-style (and now deprecated) variables like ``DOXYGEN_EXECUTABLE``. The
 :variable:`CMAKE_CURRENT_SOURCE_DIR`). This can be overridden with the
 variables before calling ``doxygen_add_docs()``. Any variable with a name of
 unless the variable already has a value before ``doxygen_add_docs()`` is
 .. variable:: DOXYGEN_HAVE_DOT
 .. variable:: DOXYGEN_DOT_MULTI_TARGETS
 .. variable:: DOXYGEN_GENERATE_LATEX
 .. variable:: DOXYGEN_WARN_FORMAT
 .. variable:: DOXYGEN_PROJECT_NAME
   :variable:`PROJECT_NAME`).
 .. variable:: DOXYGEN_PROJECT_NUMBER
   :variable:`PROJECT_VERSION`).
 .. variable:: DOXYGEN_PROJECT_BRIEF
   :variable:`PROJECT_DESCRIPTION`).
 .. variable:: DOXYGEN_INPUT
   Projects should not set this variable. It will be populated with the set of
   :command:`add_custom_target`. If a variable named ``DOXYGEN_INPUT`` is set
 .. variable:: DOXYGEN_RECURSIVE
 .. variable:: DOXYGEN_EXCLUDE_PATTERNS
   If the set of inputs includes directories, this variable will specify
 .. variable:: DOXYGEN_OUTPUT_DIRECTORY
   Set to :variable:`CMAKE_CURRENT_BINARY_DIR` by this module. Note that if
set relevant variables before calling ``doxygen_add_docs()``. For example:
them to be separated by whitespace. CMake variables hold lists as a string with
options and will convert their associated CMake variable's contents into the
required form if set. CMake variables are named ``DOXYGEN_<name>`` for the
  variable can be used to specify a list of Doxygen variables (including the
  responsible for ensuring that those variables' values make sense when placed
  directly in the Doxygen input file.  In the case of list variables, list items
For compatibility with previous versions of CMake, the following variables
.. variable:: DOXYGEN_EXECUTABLE
.. variable:: DOXYGEN_DOT_FOUND
.. variable:: DOXYGEN_DOT_EXECUTABLE
.. variable:: DOXYGEN_DOT_PATH
.. variable:: DOXYGEN_SKIP_DOT
  This variable has no effect for the component form of ``find_package``.
This module will set the following variables in your project:
The following cache variable will be set:
  :ref:`semicolon-separated list <CMake Language Lists>` variable.
  CMake :ref:`semicolon-separated list <CMake Language Lists>` variable.
This module will set the following variables in your project:
The module defines the following variables:
The macro defines the following variables:
add them to the ``FLTK_LIBRARIES`` variable.  You can limit the components
The following variables will be defined:
The following cache variables are also available to set or use:
  variables.
This will define the following variables in your project:
This module will set the following variables in your project:
  concatenation of the variables:
The user may set the environment variable ``FREETYPE_DIR`` to the root
This module will define the following variables:
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
The following variables may be set to modify the search strategy:
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
``GIF_DIR`` is an environment variable that would correspond to the
The module defines the following variables:
The following variables may be set to influence this module's behavior:
This module defines the following variables:
This module defines the following variables:
This module may set the following variables depending on platform.
These variables may optionally be set to help this module find the
The following variables may also be provided, for backwards compatibility:
  also a result variable.  Prefer to use ``GLUT_INCLUDE_DIRS`` instead
This module will set the following variables in your project::
This module may set the following variables depending on platform and type
of GSL installation discovered.  These variables may optionally be set to
Result variables
This module will set the following variables in your project:
The library variables below are set as normal variables.  These
Cache variables
The following cache variables may also be set:
  set as an environment variable)
  If compiling with MSVC, this variable can be set to ``MT`` or
The following variables will be defined for your use
Optional variables you can define prior to calling this module:
This module will read the variable
variable is set before the call to find_package.
behavior can be reversed by setting the variable ``HDF5_PREFER_PARALLEL`` to
This module will set the following variables in your project:
variable, and potentially ``HDF5_${LANG}_DEFINITIONS``, will be defined.
also be defined.  With all components enabled, the following variables will be defined:
The following variables can be set to guide the search for HDF5 libraries and includes:
The module defines the following variables:
at a given location.  This macro defines the following variables:
  Imported targets for components and most ``EXECUTABLE`` variables.
several variables.  General variables::
The environment variable ``ICE_HOME`` may also be used; the
Ice_HOME variable takes precedence.
The following cache variables may also be set::
  In most cases none of the above variables will require setting,
  searched).  All the other variables are defaulted using Ice_HOME,
Other variables one may set to control this module are::
The following variables are provided to indicate iconv support:
.. variable:: Iconv_FOUND
.. variable:: Iconv_INCLUDE_DIRS
.. variable:: Iconv_LIBRARIES
.. variable:: Iconv_VERSION
.. variable:: Iconv_VERSION_MAJOR
.. variable:: Iconv_VERSION_MINOR
.. variable:: Iconv_IS_BUILT_IN
  A variable indicating whether iconv support is stemming from the
.. variable:: Iconv::Iconv
The following cache variables may also be set:
.. variable:: Iconv_INCLUDE_DIR
.. variable:: Iconv_LIBRARY
  variables ``Iconv_INCLUDE_DIR`` and ``Iconv_LIBRARY`` might be empty.
  In this case the variables ``Iconv_VERSION*`` will be empty.
several variables.  General variables::
The environment variable ``ICU_ROOT`` may also be used; the
ICU_ROOT variable takes precedence.
The following cache variables may also be set::
  In most cases none of the above variables will require setting,
Other variables one may set to control this module are::
the following variables:
For these components the following variables are set:
installation in several variables.
.. variable:: Intl_FOUND
.. variable:: Intl_INCLUDE_DIRS
.. variable:: Intl_LIBRARIES
.. variable:: Intl_VERSION
.. variable:: Intl_VERSION_MAJOR
.. variable:: Intl_VERSION_MINOR
.. variable:: Intl_VERSION_PATCH
The following cache variables may also be set:
.. variable:: Intl_INCLUDE_DIR
.. variable:: Intl_LIBRARY
.. variable:: Intl_IS_BUILT_IN
  In this case the variables ``Intl_VERSION*`` will be empty.
This module defines the following variables:
Cache variables
The following cache variables may also be set:
include files and libraries are.  The caller may set variable ``JAVA_HOME``
This module sets the following result variables:
  variables.
For these components the following variables are set:
the library is.  The caller may set variable ``JAVA_HOME`` to specify a
This module sets the following result variables:
The following cache variables are also available to set or use:
  The variable is defined only if ``jni.h`` depends on one of these headers. In
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
Obsolete variables
This module defines the following variables:
always the variable which contains the list of source files for your
Find KDE4 and provide all necessary variables and macros to compile
The following variables may be set to influence this module's behavior:
This module defines the following variables:
This module sets the following result variables::
The module defines the following variables:
This will define the following variables in your project:
Result variables
This module will set the following variables in your project:
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
Result variables
This module will set the following variables in your project:
Additionally, the following two variables are set (but not required
Result variables
The variable ``Matlab_ROOT_DIR`` may be specified in order to give
defining pairs (name, version).  The variable
Users or projects may set the following variables to configure the module
Result variables
  otherwise. All variable below are defined if Matlab is found.
Cached variables
  is changed by the user, the result variables are recomputed.
.. variable:: Matlab_ROOT_DIR
.. variable:: MATLAB_FIND_DEBUG
.. variable:: MATLAB_ADDITIONAL_VERSIONS
  The variable should be a list of strings, organized by pairs of release
   the variable name in which the suffix will be returned.
   variables).
  Major overhaul of the module: many new variables, per-language components,
Depending on the enabled components the following variables will be set:
  were detected. Note that the ``MPICXX`` component does not affect this variable.
This module will set the following variables per language in your
The following variables indicating which bindings are present will be defined:
Note that there's no variable for the C bindings being accessible through ``mpi.h``, since the MPI standards
For running MPI programs, the module sets the following variables
For controlling the ``MPIEXEC_EXECUTABLE`` step, the following variables may be set:
  Environment variable to specify the base directory of the MPI installation.
  Environment variable to specify the base directory of the MPI installation.
For controlling the compiler wrapper step, the following variables may be set:
  support linking debug or tracing libraries if a specific flag is passed and this variable
In order to control the guessing step, the following variable may be set:
Each of the search steps may be skipped with the following control variables:
Additionally, the following control variable is available to change search behavior:
If the find procedure fails for a variable ``MPI_<lang>_WORKS``, then the settings detected by or passed to
Any other variable may be set in addition to these two. The module will then validate the MPI settings and store the
Cache variables for MPI
The variable ``MPI_<lang>_INCLUDE_DIRS`` will be assembled from the following variables.
For all languages the following variables are additionally considered:
  Path variables for include folders referred to by ``<include_name>``.
The variable ``MPI_<lang>_LIBRARIES`` will be assembled from the following variables:
Advanced variables for using MPI
If the following variables are set to true, the respective search will be performed:
variables are set:
Additionally, the following variables are deprecated:
.. variable:: ODBC_CONFIG
.. variable:: ODBC::ODBC
Result variables
.. variable:: ODBC_FOUND
.. variable:: ODBC_INCLUDE_DIRS
  Paths to include directories listed in one variable for use by ODBC client.
.. variable:: ODBC_LIBRARIES
.. variable:: ODBC_CONFIG
Cache variables
reads hints about search locations from the following variables:
.. variable:: ODBC_INCLUDE_DIR
.. variable:: ODBC_LIBRARY
These variables should not be used directly by project code.
OpenACC support are returned in variables for the different languages.
This module will set the following variables per language in your
The module will also try to provide the OpenACC version variables:
Environment variable ``$OPENALDIR`` can be used to set the prefix of OpenAL
   changed via setting the ``CMAKE_FIND_FRAMEWORK`` variable.
2. Environment variable ``$OPENALDIR``.
This module defines the following variables:
This module defines the following variables::
The module will also define two cache variables::
This module sets the following variables:
Cache variables
The following cache variables may also be set:
Projects may use the ``OpenGL::GL`` target (or ``OPENGL_LIBRARIES`` variable)
variable will use the corresponding libraries).  Thus, for non-EGL-based
A ``OpenGL_GL_PREFERENCE`` variable may be set to specify the preferred way
OpenMP support are returned in variables for the different languages.
The variables may be empty if the compiler does not need a special
Depending on the enabled components the following variables will be set:
This module will set the following variables per language in your
variables are provided:
Specifically for Fortran, the module sets the following variables:
The module will also try to provide the OpenMP version variables:
provided directly by setting the ``OpenMP_<lang>_INCLUDE_DIR`` cache variable.
Note that this variable is an _input_ control to the module.  Project code
should use the ``OpenMP_<lang>_INCLUDE_DIRS`` _output_ variable if it needs
This module accepts the following variables (note mixed case)
 OpenSceneGraph_MARK_AS_ADVANCED - Mark cache variables as advanced
The following environment variables are also respected for finding the
[CMake 2.8.10]: The CMake variable ``OSG_DIR`` can now be used as well to
variable.
This module defines the following output variables:
This module will set the following variables in your project:
  variable shall always be undefined if found openssl version is less than
$OPENTHREADS_DIR is an environment variable that would correspond to
[CMake 2.8.10]: The CMake variables OPENTHREADS_DIR or OSG_DIR can now
an environment variable.
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
``$OSGDIR`` is an environment variable that would correspond to::
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
$OSGDIR is an environment variable that would correspond to the
The module defines the following variables:
the library is.  This code sets the following variables:
 The following variables are also available if needed
the library is.  This code sets the following variables:
$PHYSFSDIR is an environment variable that would correspond to the
the library is.  This code sets the following variables:
Finds the ``pkg-config`` executable and adds the ``pkg_get_variable()``,
following variables will also be set:
for how these variables are initialized.
  Checks for all the given modules, setting a variety of result variables in
    and environment variables will be added to the ``pkg-config`` search path.
    disable this behavior for the cache variables and environment variables
    The ``PKG_CONFIG_USE_CMAKE_PREFIX_PATH`` variable set to ``FALSE``
  The following variables may be set upon return.  Two sets of values exist:
  associated variable returned from ``pkg-config`` has multiple values.
    ``<XXX>_INCLUDE_DIRS`` variable.  Previous versions of CMake left them
  There are some special variables whose prefix depends on the number of
  Looks for any version of glib2.  If found, the output variable
  Looks for at least version 2.10 of glib2.  If found, the output variable
  The ``FOO_glib-2.0_VERSION`` and ``FOO_gtk+-2.0_VERSION`` variables will be
  Requires any version of ``xrender``.  Example output variables set by a
    If a module is found, the ``<prefix>_MODULE_NAME`` variable will contain the
    name of the matching module. This variable can be used if you need to run
    ``pkg_get_variable()``.
.. command:: pkg_get_variable
  Retrieves the value of a pkg-config variable ``varName`` and stores it in the
  result variable ``resultVar`` in the calling scope.
    pkg_get_variable(<resultVar> <moduleName> <varName>)
  If ``pkg-config`` returns multiple values for the specified variable,
    pkg_get_variable(GI_GIRDIR gobject-introspection-1.0 girdir)
.. variable:: PKG_CONFIG_EXECUTABLE
  This cache variable can be set to the path of the pkg-config executable.
  variable.
    The ``PKG_CONFIG`` environment variable can be used as a hint if
    If the ``PKG_CONFIG`` environment variable is set, only the first
.. variable:: PKG_CONFIG_ARGN
  This cache variable can be set to a list of arguments to additionally pass
  ``PKG_CONFIG`` environment variable, if set. The first argument in that
  environment variable is assumed to be the pkg-config program, while all
  If no such environment variable is defined, ``PKG_CONFIG_ARGN`` is
  initialized to an empty string. The module does not update the variable once
.. variable:: PKG_CONFIG_USE_CMAKE_PREFIX_PATH
  ``CMAKE_APPBUNDLE_PATH`` cache and environment variables to the
  If this variable is not set, this behavior is enabled by default if
Result variables
This module will set the following variables in your project:
Obsolete variables
The following variables may also be set, for backwards compatibility:
This module will set the following variables in your project:
$PRODUCER_DIR is an environment variable that would correspond to the
  All input and output variables use the ``Protobuf_`` prefix.
The following variables can be set and are optional:
  When compiling with MSVC, if this cache variable is set
Defines the following variables:
The following cache variables are also available to set or use:
This module will set the following variables in your project
  This variable defines which ABIs, as defined in
 The ``Python_FIND_ABI`` variable is a 3-tuple specifying, in that order,
  This variable defines how lookup will be done.
  The ``Python_FIND_STRATEGY`` variable can be set to one of the following:
  On Windows the ``Python_FIND_REGISTRY`` variable determine the order
  of preference between registry and environment variables.
  the ``Python_FIND_REGISTRY`` variable can be set to one of the following:
  * ``FIRST``: Try to use registry before environment variables.
  * ``LAST``: Try to use registry after environment variables.
  On macOS the ``Python_FIND_FRAMEWORK`` variable determine the order of
  This variable can take same values as ``CMAKE_FIND_FRAMEWORK``
  variable.
 If ``Python_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK`
 variable will be used, if any.
  This variable defines the handling of virtual environments managed by
  variables.  The ``Python_FIND_VIRTUALENV`` variable can be set to one of the
    interpreter but environment variable ``PATH`` is always considered.
    In this case, variable ``Python_FIND_REGISTRY`` (Windows) or
  This variable defines, in an ordered list, the different implementations
  which will be searched. The ``Python_FIND_IMPLEMENTATIONS`` variable can
   through the ``PATH`` variable.
  This variable defines how the generic names will be searched. Currently, it
  The ``Python_FIND_UNVERSIONED_NAMES`` variable can be set to one of the
setting the following variables:
  variables ``Python_LIBRARIES``, ``Python_LIBRARY_DIRS`` and
  compute the variable ``Python_INCLUDE_DIRS``.
  compute the variable ``Python_NumPy_INCLUDE_DIRS``.
can be controlled with the following variable:
  Selects the behavior of the module. This is a boolean variable:
    specification variables so that users can edit them interactively.
This module will set the following variables in your project
  This variable defines how lookup will be done.
  The ``Python2_FIND_STRATEGY`` variable can be set to one of the following:
  On Windows the ``Python2_FIND_REGISTRY`` variable determine the order
  of preference between registry and environment variables.
  the ``Python2_FIND_REGISTRY`` variable can be set to one of the following:
  * ``FIRST``: Try to use registry before environment variables.
  * ``LAST``: Try to use registry after environment variables.
  On macOS the ``Python2_FIND_FRAMEWORK`` variable determine the order of
  This variable can take same values as ``CMAKE_FIND_FRAMEWORK``
  variable.
 If ``Python2_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK`
 variable will be used, if any.
  This variable defines the handling of virtual environments managed by
  variables.  The ``Python2_FIND_VIRTUALENV`` variable can be set to one of the
    interpreter but environment variable ``PATH`` is always considered.
    In this case, variable ``Python2_FIND_REGISTRY`` (Windows) or
  This variable defines, in an ordered list, the different implementations
  which will be searched. The ``Python2_FIND_IMPLEMENTATIONS`` variable can
   through the ``PATH`` variable.
  This variable defines how the generic names will be searched. Currently, it
  The ``Python2_FIND_UNVERSIONED_NAMES`` variable can be set to one of the
setting the following variables:
  variables ``Python2_LIBRARIES``, ``Python2_LIBRARY_DIRS`` and
  compute the variable ``Python2_INCLUDE_DIRS``.
  compute the variable ``Python2_NumPy_INCLUDE_DIRS``.
can be controlled with the following variable:
  Selects the behavior of the module. This is a boolean variable:
    specification variables so that users can edit them interactively.
This module will set the following variables in your project
  This variable defines which ABIs, as defined in
 The ``Python3_FIND_ABI`` variable is a 3-tuple specifying, in that order,
  This variable defines how lookup will be done.
  The ``Python3_FIND_STRATEGY`` variable can be set to one of the following:
  On Windows the ``Python3_FIND_REGISTRY`` variable determine the order
  of preference between registry and environment variables.
  The ``Python3_FIND_REGISTRY`` variable can be set to one of the following:
  * ``FIRST``: Try to use registry before environment variables.
  * ``LAST``: Try to use registry after environment variables.
  On macOS the ``Python3_FIND_FRAMEWORK`` variable determine the order of
  This variable can take same values as ``CMAKE_FIND_FRAMEWORK``
  variable.
 If ``Python3_FIND_FRAMEWORK`` is not defined, :variable:`CMAKE_FIND_FRAMEWORK`
 variable will be used, if any.
  This variable defines the handling of virtual environments managed by
  variables.  The ``Python3_FIND_VIRTUALENV`` variable can be set to one of the
    interpreter but environment variable ``PATH`` is always considered.
    In this case, variable ``Python3_FIND_REGISTRY`` (Windows) or
  This variable defines, in an ordered list, the different implementations
  which will be searched. The ``Python3_FIND_IMPLEMENTATIONS`` variable can
   through the ``PATH`` variable.
  This variable defines how the generic names will be searched. Currently, it
  The ``Python3_FIND_UNVERSIONED_NAMES`` variable can be set to one of the
setting the following variables:
  variables ``Python3_LIBRARIES``, ``Python3_LIBRARY_DIRS`` and
  compute the variable ``Python3_INCLUDE_DIRS``.
  compute the variable ``Python3_NumPy_INCLUDE_DIRS``.
can be controlled with the following variable:
  Selects the behavior of the module. This is a boolean variable:
    specification variables so that users can edit them interactively.
number of ``IMPORTED`` targets, macros and variables.
 ``QT4_NO_LINK_QTMAIN`` variable before finding Qt4. To disable that
  Below is a detailed list of variables that FindQt4.cmake sets.
 If false, don't try to use Qt. This variable is for compatibility only.
 If false, don't try to use Qt 4. This variable is for compatibility only.
$QUICKTIME_DIR is an environment variable that would correspond to the
This code sets the following variables:
This module will set the following variables in your project:
  Previous versions of CMake used the ``RUBY_`` prefix for all variables.
  The following variables are provided for compatibility reasons,
  This variable defines the handling of virtual environments managed by
  ``MY_RUBY_HOME`` environment variable is set).
  The ``Ruby_FIND_VIRTUALENV`` variable can be set to empty or
Result variables
This module will set the following variables in your project:
  variables.
Cache variables
These variables may optionally be set to help this module find the correct files:
    as part of the returned SDL_LIBRARY variable.
Obsolete variables
These variables are obsolete and provided for backwards compatibility:
SDL_LIBRARY variable, but when these values are unset, SDL_LIBRARY
$SDLDIR is an environment variable that would correspond to the
For backward compatibility the following variables are also set:
$SDLDIR is an environment variable that would correspond to the
For backward compatibility the following variables are also set:
$SDLDIR is an environment variable that would correspond to the
For backward compatibility the following variables are also set:
$SDLDIR is an environment variable that would correspond to the
 SDL_SOUND_EXTRAS, this is an optional variable for you to add your own
Typically, you should not use these variables directly, and you should
Responds to the $SDLDIR and $SDLSOUNDDIR environmental variable that
For backward compatibility the following variables are also set:
$SDLDIR is an environment variable that would correspond to the
Result variables
This module will set the following variables if found:
The module defines the following variables:
given location.  This macro defines the following variables if running
  ``IGNORE_SVN_FAILURE`` option, which causes these variables to remain
subversion working copy at a given location.  This macro defines the variable:
The module defines the following variables:
library is.  This code sets the following variables:
variables were moved or removed.  Changes compared to CMake 2.4 are:
 => this ended up being only a Win32 variable, and there is a lot of
library is.  This code sets the following variables:
This code sets the following variables:
variables were moved or removed.  Changes compared to CMake 2.4 are:
The following variables are set:
.. variable:: THREADS_PREFER_PTHREAD_FLAG
  the caller can set this variable to TRUE. The compiler flag can only be
  This variable has no effect if the system libraries provide the
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
``mv``, ``rm``, and ``tar`` and stores the result in the variables
This module defines the following variables:
The module will also defines these cache variables:
The ``VULKAN_SDK`` environment variable optionally specifies the
library is.  This code sets the following variables:
windows, the following variables are searched for and set to defaults
desired (i.e., these are the only variables you should change to
the following variables:
There is also a wxWidgets_CONFIG_OPTIONS variable for all other
to use the base toolkit found in the /usr/local path, set the variable
  The following environment variables can be used as hints: ``WX_CONFIG``,
and also the following more fine grained variables and targets:
  Added the ``X11_Xext_INCLUDE_PATH`` variable.
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
The following variables are set by including this module:
.. variable:: XCTest_FOUND
.. variable:: XCTest_EXECUTABLE
.. variable:: XCTest_INCLUDE_DIRS
.. variable:: XCTest_LIBRARIES
Result variables
This module will set the following variables in your project:
Cache variables
The following cache variables may also be set:
This module defines the following variables:
The following variable are provided for backward compatibility
``CMAKE_<LANG>_COMPILER_VERSION`` variable that contains
Function DetermineVSServicePack sets the given variable to one of the
by setting the ``CMAKE_TRY_COMPILE_TARGET_TYPE`` variable in the
the given compiler and the cmake internal variable
the given compiler and the cmake internal variable
the given compiler and the cmake internal variable
 CHECK_CXX_ACCEPTS_FLAG(<flags> <variable>)
``<variable>``
 variable to store the result
found or the specified software package doesn't exist, the variable
variable is used if no explicit version is specified.
``CMAKE_<LANG>_COMPILER_ID`` variable.
target, and the ``CMAKE_CXX_STANDARD`` variable may be set to
a different installed version of the toolkit set the environment variable
The following variables affect the behavior of the macros in the
  ``CUDA_NVCC_FLAGS_<CONFIG>`` variables.  For Visual Studio targets,
    If the ``CUDAHOSTCXX`` environment variable is set it will
    Contents of these variables may use
 cuda_select_nvcc_arch_flags(<out_variable> [<target_CUDA_architecture> ...])
Returns list of flags to be added to ``CUDA_NVCC_FLAGS`` in ``<out_variable>``.
Additionally, sets ``<out_variable>_readable`` to the resulting numeric list.
The script defines the following variables:
  variables.  There are also examples of how to use the ``CUDA_SDK_ROOT_DIR``
where the executables are.  This code sets the following variables:
The Python_ADDITIONAL_VERSIONS variable can be used to specify a list
for Python.  You need to set this variable before calling
the library is.  This code sets the following variables:
The Python_ADDITIONAL_VERSIONS variable can be used to specify a list
for Python.  You need to set this variable before calling
modify the following cache variables:
the name of the library is.  This code sets the following variables:
a set of variables corresponding to build-relevant information.
By setting the ``CMAKE_DISABLE_FIND_PACKAGE_<PackageName>`` variable to
a package is to set the ``CMAKE_PREFIX_PATH`` cache variable.
A set of variables which provide package status information are also set
variable is set to true or false, depending on whether the package was
found.  The ``<PackageName>_DIR`` cache variable is set to the location of the
variable is not automatically set by the ``find_package()`` command.  It
the author of the Find-module.  Similarly there is no ``<PackageName>_DIR`` variable,
provide a separate cache variable.
with content defining ``IMPORTED`` targets, or defining variables, such
following variables:
The version file must use these variables to check whether it is compatible or
an exact match for the requested version and set the following variables with
Version files are loaded in a nested scope so they are free to set any variables
variables. When the version file claims to be an acceptable match for the
requested version the find_package command sets the following variables for
The variables report the version of the package that was actually found.
version-specific variables ``<PackageName>_VERSION``, ``<PackageName>_VERSION_MAJOR``,
they are listed in the ``<PackageName>_FIND_COMPONENTS`` variable. If a particular
variable can be set for any case where the ``_FOUND`` variable is set to ``False``,
The referenced variables may contain the absolute paths to libraries
allows one to disable them using the following variables:
  ``CMAKE_EXPORT_PACKAGE_REGISTRY`` variable explicitly enables it.
  the ``CMAKE_EXPORT_NO_PACKAGE_REGISTRY`` variable explicitly
  to ``TRUE``. This variable is ignored when
``CMAKE_POLICY_DEFAULT_CMP<NNNN>`` variable.
The ``CMAKE_MINIMUM_REQUIRED_VERSION`` variable may also be used
variables for the current environment and toolchain settings.
However, some projects may modify these flag variables to add
for these variables.  This policy provides compatibility for projects
for this policy is to use the values of those variables as
``try_compile()`` passes platform variables in project mode.
Files>` signature propagates CMake variables containing platform settings,
variable, into the generated test project.  This helps the test project drive
propagate platform variables automatically.  CMake 3.24 and above prefer to
propagate platform variables in the :ref:`whole-project <Try Compiling Whole
The ``OLD`` behavior for this policy is to not pass any additional variables to
The ``NEW`` behavior for this policy is to pass the same variables that the
``CMAKE_TRY_COMPILE_NO_PLATFORM_VARIABLES`` variable may be set
to suppress passing the platform variables through either signature.
``CMAKE_<LANG>_FLAGS_<CONFIG>`` variables with knowledge of the
variable and ``WATCOM_RUNTIME_LIBRARY`` target property may be set to
``CMAKE_SIZEOF_VOID_P`` variable value.
variable to control the warning.
CMake 3.23 and below will set environment variables like ``CC``,
and the environment variables are only defined at configure time, not build
time. On subsequent CMake runs, these environment variables are not set,
environment variables when a language is enabled, even on the first run in
The ``OLD`` behavior for this policy sets the relevant environment variable
policy does not set any such environment variables.
``CMAKE_<LANG>_COMPILER_ID`` variable to ``LCC`` instead
variable after language ``<LANG>`` is enabled by the ``project()``
variable to control the warning.
variable to control the warning.
remove any normal variable of the same name from the current scope.
The ``OLD`` behavior removes any normal variable of the same name from the
* No cache variable of that name existed previously.
* A cache variable of that name existed previously, but it had no type.
  This can occur when the variable was set on the command line using a form
  variable.
command always sets the cache variable if it did not exist previously,
will *not* set the cache variable if a non-cache variable of the same name
within a project.  Use the :variable:`CMAKE_POLICY_DEFAULT_CMP0126
<CMAKE_POLICY_DEFAULT_CMP\<NNNN\>>` variable to set the policy for
variable to control the warning.
``find_program()`` commands cache their result in the variable specified
by their first argument.  Prior to CMake 3.21, if a cache variable of that
name already existed before the call but the cache variable had no type, any
non-cache variable of the same name would be discarded and the cache variable
behavior).  This contradicts the convention that a non-cache variable should
take precedence over a cache variable of the same name.  Such a situation can
arise if a user sets a cache variable on the command line without specifying
Related to the above, if a cache variable of the specified name already exists
* If a non-cache variable of the specified name exists when the ``find_...()``
  variable of the same name already exists or not.  A cache variable will not
  be created in this case if no such cache variable existed before.
  If a cache variable of the specified name did already exist, the cache will
  be updated to match the non-cache variable.
  the result variable, except where a relative path provided by a cache or
  non-cache variable cannot be resolved to an existing path.
When this policy is set to ``NEW``, the scope of loop variables defined by the
The ``OLD`` behavior for this policy still clears the loop variables at the end
variable and an undocumented ``CMAKE_SYSTEM_ARCH`` to compile and link options
projects to set either variable or it raises a fatal error.  However, the
a link option ``--cpu=`` based on those variables.  The ``NEW`` behavior
the ``CMAKE_CXX_FLAGS`` variable with knowledge
variable without any path resolution. This meant that if
internal file, and passes this internal file to Ninja's ``depfile`` variable.
variable to control the warning.
variable to control the warning.
with (now old) VTK patterns for cache variables and required packages, the
cache variables and find VTK documentation dependent packages. The ``NEW``
In CMake 3.16 and below, if a variable was not defined at all or just defined
would end up deleting the local variable in the process (due to the way the
The ``NEW`` behavior of this policy is to ignore variables which do not
documentation of the :variable:`CMAKE_POLICY_WARNING_CMP0102
<CMAKE_POLICY_WARNING_CMP<NNNN>>` variable to control the warning.
``PROJECT_VERSION`` variable and stores individual integer version components
in ``PROJECT_VERSION_{MAJOR,MINOR,PATCH,TWEAK}`` variables (see policy
CMake's variable syntax. In order to not be substituted (usually to an empty
and ``FindPython`` set value ``LOCATION`` for, respectively, variables
The ``OLD`` behavior for this policy set value ``VERSION`` for variables
value is still reported in the ``Boost_VERSION_MACRO`` variable.
``CMAKE_<LANG>_FLAGS`` variables with knowledge of the
``CMAKE_<LANG>_FLAGS_<CONFIG>`` variables with knowledge of the
variable and ``MSVC_RUNTIME_LIBRARY`` target property may be set to
nothing unless an explicit ``CMAKE_EXPORT_PACKAGE_REGISTRY`` variable
``CMAKE_<LANG>_COMPILER_ID`` variable to ``XLClang`` instead
variable after language ``<LANG>`` is enabled by the ``project()``
variable to control the warning.
variable to control the warning.
``UseSWIG_TARGET_NAME_PREFERENCE`` variable that can be used to specify an
``option()`` honors normal variables.
normal (non-cached) variable of the same name as the option may be
command *removes* a normal (non-cached) variable of the same name when:
removes any normal (non-cached) variable of the same name.  In the
``option()`` command changes nothing and any normal variable of
do nothing when a normal variable of the given name already exists.
It does not create or update a cache entry or remove the normal variable.
When the ``option()`` command sees a normal variable of the given
  variable of the same name exists.  If the cache entry does not already
  normal variable is removed.
  variable of the same name exists.  The normal variable is not removed.
explicitly within a project.  Use the :variable:`CMAKE_POLICY_DEFAULT_CMP0077
<CMAKE_POLICY_DEFAULT_CMP\<NNNN\>>` variable to set the policy for
``CMAKE_REQUIRED_LIBRARIES`` variable.  This policy provides compatibility
``find_package()`` uses ``<PackageName>_ROOT`` variables.
variable and the ``<PackageName>_ROOT`` environment variable.
updated to avoid using ``<PackageName>_ROOT`` variables for other purposes.
variables.  The ``NEW`` behavior for this policy is to use
``<PackageName>_ROOT`` variables.
``OPENGL_LIBRARIES`` variable for projects to use for legacy GL interfaces.
variable that can be used to specify an explicit preference.  When no such
variable in an environment known to support IPO even if the project does
* ``CMAKE_SKIP_RPATH`` variable
* ``CMAKE_SKIP_INSTALL_RPATH`` variable
for ``C``, ``CXX`` (C++), and ``CUDA`` using the values of the variables:
setting variables when generating the ``try_compile`` test project.
setting variables.
variable to control the warning.
of the ``CMAKE_<LANG>_FLAGS`` variable in the test project so that the
``CMAKE_<LANG>_FLAGS_DEBUG`` variable.  CMake 3.7 and above prefer to
variables like ``CMAKE_<LANG>_FLAGS_DEBUG`` and only use CMake's
variable to control the warning.
variable to control the warning.
variable listing library files.  However, this makes the link line
variable to control the warning.
``CMAKE_<LANG>_FLAGS`` variable to that in the calling project.
The value of the ``CMAKE_EXE_LINKER_FLAGS`` variable may be
``CMAKE_EXE_LINKER_FLAGS`` variable in the generated test
the ``CMAKE_EXE_LINKER_FLAGS`` variable in the test project
variable in the cache.
variable to control the warning.
Only interpret ``if()`` arguments as variables or keywords when unquoted.
CMake 3.1 and above no longer implicitly dereference variables or
The ``OLD`` behavior for this policy is to dereference variables and
The ``NEW`` behavior is to not dereference variables or interpret keywords
After explicit expansion of variables this gives:
Simplify variable reference and escape sequence evaluation.
  implementation of ``CMP0053`` and its use as a literal variable
  so improper variable reference syntax is always an error.
* More characters are allowed to be escaped in variable names.
variable references and escape sequences.  The ``NEW`` behavior is to
use the simpler variable expansion and escape sequence evaluation rules.
Do not expand variables in target source entries.
CMake 2.8.12 and lower performed an extra layer of variable expansion
The ``OLD`` behavior for this policy is to expand such variables when processing
if such variables need to be expanded.
The ``project()`` command manages ``VERSION`` variables.
``PROJECT_VERSION`` and related variables consistent with variable
``PROJECT_NAME`` it is necessary to set the ``VERSION`` variables
variables themselves since ``project()`` may now clear them.
The ``OLD`` behavior for this policy is to leave ``VERSION`` variables untouched.
``CMAKE_<LANG>_COMPILER_ID`` variable to ``QCC`` instead
report in the ``CMAKE_<LANG>_COMPILER_ID`` variable after
variable to control the warning.
result variable is set to a ``-NOTFOUND`` value.
variable to a ``-NOTFOUND`` value.  The ``NEW`` behavior
variables is redundant, and causes a maintenance burden.  Population of the
variables.
and ``CMAKE_<LANG>_COMPILER`` variables.
The ``variable_requires()`` command should not be called.
``CMAKE_<LANG>_COMPILER_ID`` variable to ``AppleClang`` instead
report in the ``CMAKE_<LANG>_COMPILER_ID`` variable after
variable to control the warning.
Do not re-expand variables in include and link information.
expand any leftover variable references at the end of the
CMake versions because all variable references are now normally
Ignore ``CMAKE_SHARED_LIBRARY_<Lang>_FLAGS`` variable.
platform variable.  The variable contained platform-specific flags
undocumented platform variables to select flags while ignoring
dereferenced arguments corresponding to variables, even those named
used as variable names.
variables named like numbers and boolean constants.  The ``NEW`` behavior
dereferencing variables with such names.
Bad variable reference syntax is an error.
In CMake 2.6.2 and below, incorrect variable reference syntax such as
variable reference is an error.  The ``OLD`` behavior for this policy is
In CMake 2.4 and below the variable ``CMAKE_BACKWARDS_COMPATIBILITY`` was
  An optional map of cache variables. The key is the variable name (which
  of ``BOOL``), a string representing the value of the variable (which
    An optional string representing the type of the variable.
    A required string or boolean representing the value of the variable.
  Cache variables are inherited through the ``inherits`` field, and the
  preset's variables will be the union of its own ``cacheVariables`` and
  union define the same variable, the standard rules of ``inherits`` are
  applied. Setting a variable to ``null`` causes it to not be set, even if
  An optional map of environment variables. The key is the variable name
  a string representing the value of the variable. Each variable is set
  variables in this map may reference each other, and may be listed in any
  Environment variables are inherited through the ``inherits`` field, and
  union define the same variable, the standard rules of ``inherits`` are
  applied. Setting a variable to ``null`` causes it to not be set, even if
  An optional map of environment variables. The key is the variable name
  a string representing the value of the variable. Each variable is set
  variables in this map may reference each other, and may be listed in any
  Environment variables are inherited through the ``inherits`` field, and
  this union define the same variable, the standard rules of ``inherits``
  are applied. Setting a variable to ``null`` causes it to not be set,
 having environment variables needed in the ExternalProject, use a build
 will not have the environment variables set in the configuration preset.
 preset environment variables ``CC`` and ``CXX`` and use a build preset
  variables from the associated configure preset are inherited after all
  inherited build preset environments, but before environment variables
 and this setting is not specified, an environment-specific cache variable
 ``CMAKE_VS_NUGET_PACKAGE_RESTORE`` variable to ``OFF``. This can also be
  An optional map of environment variables. The key is the variable name
  a string representing the value of the variable. Each variable is set
  variables in this map may reference each other, and may be listed in any
  Environment variables are inherited through the ``inherits`` field, and
  this union define the same variable, the standard rules of ``inherits``
  are applied. Setting a variable to ``null`` causes it to not be set,
  variables from the associated configure preset are inherited after all
  inherited test preset environments, but before environment variables
preset sets variable ``PRESET_NAME`` to ``${presetName}``, and the
``$env{<variable-name>}``
  Environment variable with name ``<variable-name>``. The variable name may
  not be an empty string. If the variable is defined in the ``environment``
  If the environment variable is not defined, this evaluates as an empty
  Note that while Windows environment variable names are case-insensitive,
  variable names within a preset are still case-sensitive. This may lead to
  the casing of environment variable names consistent.
``$penv{<variable-name>}``
  Similar to ``$env{<variable-name>}``, except that the value only comes from
  allows you to prepend or append values to existing environment variables.
  prepend ``/path/to/ninja/bin`` to the ``PATH`` environment variable. This
  is needed because ``$env{<variable-name>}`` does not allow circular
be listed in the ``CMAKE_C_COMPILE_FEATURES`` variable.
be listed in the ``CMAKE_CUDA_COMPILE_FEATURES`` variable.
be listed in the ``CMAKE_CXX_COMPILE_FEATURES`` variable.
  Thread-local variables, as defined in N2659_.
``cxx_variable_templates``
determined using the ``<NAME>_FOUND`` variables.  Packages which are
determined using the ``<NAME>_FOUND`` variables.  Packages which are
See also the ``CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX`` variable.
See also the ``CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX`` variable.
See also the ``CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX`` variable.
variable.
package has been found is determined using the <NAME>_FOUND variables.
package has been found is determined using the <NAME>_FOUND variables.
report any properties or variables that were accessed but not defined
  variables instead.
  variables instead.
generator emits the ``EFFECTIVE_PLATFORM_NAME`` variable:
  ``EFFECTIVE_PLATFORM_NAME`` variable will leak into
List of cache variables available in the current directory.
This read-only property specifies the list of CMake cache variables
The ``CMAKE_DIRECTORY_LABELS`` variable can be used to initialize this
  variables instead.
  variables instead.
List of variables defined in the current directory.
This read-only property specifies the list of CMake variables
the ``CMAKE_AIX_EXPORT_ALL_SYMBOLS`` variable if it is set
``CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS`` variable if it is
initialized by the value of the ``CMAKE_ANDROID_API`` variable if
the value of the ``CMAKE_ANDROID_API_MIN`` variable if it is set
``CMAKE_ANDROID_ARCH`` variable if it is set
``CMAKE_ANDROID_ASSETS_DIRECTORIES`` variable if it is set when
by the value of the ``CMAKE_ANDROID_GUI`` variable if it is set
variable if it is set when a target is created.
``CMAKE_ANDROID_JAR_DIRECTORIES`` variable if it is set when
``CMAKE_ANDROID_JAVA_SOURCE_DIR`` variable if it is set
``CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES`` variable if it is set
``CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES`` variable if it is set when a
``CMAKE_ANDROID_PROCESS_MAX`` variable if it is set
``CMAKE_ANDROID_PROGUARD`` variable if it is set
``CMAKE_ANDROID_PROGUARD_CONFIG_PATH`` variable if it is set
``CMAKE_ANDROID_SECURE_PROPS_PATH`` variable
``CMAKE_ANDROID_SKIP_ANT_STEP`` variable if it is set when a target is created.
``CMAKE_ANDROID_STL_TYPE`` variable if it is set when a target is
``CMAKE_ARCHIVE_OUTPUT_DIRECTORY`` variable if it is set when a target is created.
``CMAKE_ARCHIVE_OUTPUT_DIRECTORY_<CONFIG>`` variable if
variable if it is set when a target is created.
- ``Qt6Core_VERSION_MAJOR`` and ``Qt6Core_VERSION_MINOR`` variables
- ``Qt5Core_VERSION_MAJOR`` and ``Qt5Core_VERSION_MINOR`` variables
- ``QT_VERSION_MAJOR`` and ``QT_VERSION_MINOR``  variables
variables.  If the call is in a different context than the
then the version variables might not be available to the ``AUTOMOC``
In that case the version variables can be forwarded from the
will be generated when this variable is ``ON``.
From Qt 5.15.0 on this variable is ignored as moc is able to output the correct
``CMAKE_AUTOMOC_MOC_OPTIONS`` variable if it is set when a target
``AUTOMOC_PATH_PREFIX`` is initialized from the variable
variable if it is set when a target is created.
in the project will be generated when this variable is ``ON``.
``CMAKE_AUTORCC_OPTIONS`` variable if it is set when a target is
variable if it is set when a target is created.
will be generated when this variable is ``ON``.
``CMAKE_AUTOUIC_OPTIONS`` variable if it is set when a target is
``CMAKE_AUTOUIC_SEARCH_PATHS`` variable if it is set
``CMAKE_CURRENT_BINARY_DIR`` variable in the directory in which
This property is initialized by the value of the variable
This property is initialized by the value of the variable
variable is set. The runtime path set through the
This property is initialized by the value of the variable
``CMAKE_BUILD_WITH_INSTALL_RPATH`` variable if it is set when a target
the ``CMAKE_C_EXTENSIONS`` variable if set when a target is created and
the ``CMAKE_C_STANDARD`` variable if it is set when a target
the ``CMAKE_C_STANDARD_REQUIRED`` variable if it is set when a
``CMAKE_CXX_COMPILE_FEATURES`` variables.
variables, but before those propagated from dependencies by the
value of the ``CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY`` variable
``CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY_<CONFIG>`` variable
This property is initialized by the value of the variable
targets, this property is initialized by the value of the variable
``CMAKE_CROSSCOMPILING_EMULATOR`` variable if it is set when a target
variable if it is set when a target is created.
the ``CMAKE_CUDA_EXTENSIONS`` variable if set when a target is created
``CMAKE_CUDA_SEPARABLE_COMPILATION`` variable if it is set when a
the ``CMAKE_CUDA_STANDARD`` variable if it is set when a target
the ``CMAKE_CUDA_STANDARD_REQUIRED`` variable if it is set when a
the ``CMAKE_CXX_EXTENSIONS`` variable if set when a target is created
the ``CMAKE_CXX_STANDARD`` variable if it is set when a target
the ``CMAKE_CXX_STANDARD_REQUIRED`` variable if it is set when a
``CMAKE_DOTNET_SDK`` variable.
Can be initialized for all targets using the variable
To initialize this variable for all targets set
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
variable ``CMAKE_Fortran_FORMAT`` is set when a target is created its
corresponding to the target's source directory.  If the variable
file needs to be preprocessed. If the variable
value of the ``CMAKE_FRAMEWORK`` variable if it is set when a target is
``CMAKE_FRAMEWORK_MULTI_CONFIG_POSTFIX_<CONFIG>`` variable if it
If the variable ``CMAKE_GNUtoMS`` is set when a target is created its
value is used to initialize this property.  The variable must be set
or ``enable_language()``.  CMake provides the variable as an option to the
variable if it is set when a target is created.
the ``CMAKE_HIP_EXTENSIONS`` variable if set when a target is created
the ``CMAKE_HIP_STANDARD`` variable if it is set when a target
the ``CMAKE_HIP_STANDARD_REQUIRED`` variable if it is set when a
This is controlled by the ``CMAKE_OSX_ARCHITECTURES`` variable.
SDKs.  With the ``Xcode`` generator, Xcode variables of the form
variables and embeds them unchanged in the Xcode project file.
The following shows one example of how these two variables can be used to
as well.  The ``$(CONFIGURATION)`` Xcode variable is often used for this and
When any Xcode variable is used, CMake is not able to fully evaluate the
should be handled by the ``$(CONFIGURATION)`` Xcode variable.
variables like ``$(CURRENT_ARCH)`` or ``$(EFFECTIVE_PLATFORM_NAME)`` in
This property is initialized by the value of the variable
by the value of the variable ``CMAKE_INSTALL_RPATH`` if it is set when
This property is initialized by the value of the variable
``CMAKE_INTERPROCEDURAL_OPTIMIZATION`` variable if it is set when a
``CMAKE_INTERPROCEDURAL_OPTIMIZATION_<CONFIG>`` variable if it is set
headers will be placed a generator defined build directory. If the variable
variable if it is set when a target  is created.
variable if it is set when a target is created.
the ``CMAKE_<LANG>_CLANG_TIDY`` variable if it is set
the ``CMAKE_<LANG>_COMPILER_LAUNCHER`` variable if it is set
``CMAKE_<LANG>_CPPCHECK`` variable if it is set when a target is
``CMAKE_<LANG>_CPPLINT`` variable if it is set when a target is
``CMAKE_<LANG>_EXTENSIONS`` variable if it is set when a target is
the ``CMAKE_<LANG>_INCLUDE_WHAT_YOU_USE`` variable if it is set
``CMAKE_<LANG>_LINKER_LAUNCHER`` variable if it is set when a target is
``CMAKE_<LANG>_STANDARD`` variable if it is set when a target is
``CMAKE_<LANG>_STANDARD_REQUIRED`` variable if it is set when a target
``CMAKE_<LANG>_VISIBILITY_PRESET`` variable if it is set when a
``CMAKE_LIBRARY_OUTPUT_DIRECTORY`` variable if it is set when a target is created.
``CMAKE_LIBRARY_OUTPUT_DIRECTORY_<CONFIG>`` variable if
``CMAKE_LINK_DEPENDS_NO_SHARED`` variable if it is set when a
value of the ``CMAKE_LINK_INTERFACE_LIBRARIES`` variable if it is
``CMAKE_LINK_LIBRARIES_ONLY_TARGETS`` variable when a non-imported
``CMAKE_LINK_LIBRARY_USING_<FEATURE>`` variables.
``CMAKE_LINK_LIBRARY_USING_<FEATURE>`` variables.
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
This property is initialized by the value of the variable
This property is initialized by the value of the variable
contents of variable ``CMAKE_LINK_WHAT_YOU_USE_CHECK`` on the target
after it is linked. In addition, the linker flag specified by variable
the ``CMAKE_LINK_WHAT_YOU_USE`` variable if it is set
``CMAKE_<LANG>_LINKER_PREFERENCE`` variables.
This property is initialized by the value of the variable
CMake variables of the same name may be set to affect all targets in a
CMake variables of the same name may be set to affect all targets in a
This property is initialized by the value of the variable
``CMAKE_MAP_IMPORTED_CONFIG_<CONFIG>`` variable if it is set when a
``CMAKE_NO_SYSTEM_FROM_IMPORTED`` variable if it is set when a target
the ``CMAKE_OBJC_EXTENSIONS`` variable if set when a target is created
the ``CMAKE_OBJC_STANDARD`` variable if it is set when a target
the ``CMAKE_OBJC_STANDARD_REQUIRED`` variable if it is set when a
the ``CMAKE_OBJCXX_EXTENSIONS`` variable if set when a target is
the ``CMAKE_OBJCXX_STANDARD`` variable if it is set when a target
the ``CMAKE_OBJCXX_STANDARD_REQUIRED`` variable if it is set when a
``CMAKE_OPTIMIZE_DEPENDENCIES`` variable when the target is created.
variable ``CMAKE_OSX_ARCHITECTURES`` if it is set when a target is
``CMAKE_PCH_WARN_INVALID`` variable if it is set when a target is
created.  If that variable is not set, the property defaults to ``ON``.
``CMAKE_PCH_INSTANTIATE_TEMPLATES`` variable if it is set when a target
is created.  If that variable is not set, the property defaults to ``ON``.
``CMAKE_PDB_OUTPUT_DIRECTORY`` variable if it is
``CMAKE_PDB_OUTPUT_DIRECTORY_<CONFIG>`` variable if it is
of the ``CMAKE_POSITION_INDEPENDENT_CODE`` variable  if it is set
  variables instead.
  variables instead.
``CMAKE_RUNTIME_OUTPUT_DIRECTORY`` variable if it is set when a target is created.
``CMAKE_RUNTIME_OUTPUT_DIRECTORY_<CONFIG>`` variable if
This property is initialized by the value of the variable
``CMAKE_CURRENT_SOURCE_DIR`` variable in the directory in which
If the variable ``CMAKE_Swift_MODULE_DIRECTORY`` is set when a target is
variable when a target is created.
  associated ``CMAKE_UNITY_BUILD`` variable to true.  Depending
  variable on the ``cmake(1)`` command line or some other equivalent
``CMAKE_UNITY_BUILD_BATCH_SIZE`` variable when the target is created.
If that variable has not been set, the initial value will be 8.
variables in an anonymous namespace in a limited scope.
they are used to ensure that certain variables and declarations
build file, those variables in different files are combined in
   // variables in other anonymous namespaces
``CMAKE_VERIFY_INTERFACE_HEADER_SETS`` variable if it is set when
the value of the ``CMAKE_VISIBILITY_INLINES_HIDDEN`` variable if it
``CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION`` variable.
VS_GLOBAL_<variable>
Visual Studio project-specific global variable.
Tell the Visual Studio generator to set the global variable
'<variable>' to a given value in the generated Visual Studio project.
``CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION`` variable.
variable if it is set when a target is created.
``CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION`` variable.
variable if it is set when a target is created.
This shows setting the variable for the target foo.
This shows setting the variable for the Release configuration only.
See the ``CMAKE_MFC_FLAG`` variable documentation to
``CMAKE_WIN32_EXECUTABLE`` variable if it is set when
the ``CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS`` variable if it is set
See the ``CMAKE_XCODE_ATTRIBUTE_<an-attribute>`` variable
This property is initialized by the value of the variable
Each of those is initialized by the respective ``CMAKE_`` variable
``CMAKE_XCODE_LINK_BUILD_PHASE_MODE`` variable if it is set when a
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
Specify environment variables that should be added to the Arguments
If set to a list of environment variables and values of the form
``MYVAR=value`` those environment variables will be added to the
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
This property is initialized by the value of the variable
the ``CMAKE_XCODE_XCCONFIG`` variable.
Specify environment variables that should be defined for running a test.
of environment variables and values of the form ``MYVAR=value``.
Those environment variables will be defined while running the test.
Specify environment variables that should be modified for running a test. Note
environment variables and values of the form ``MYVAR=OP:VALUE``,
where ``MYVAR`` is the case-sensitive name of an environment variable
    ``MYVAR`` prior to this entry. Note that this will reset the variable to
the :ref:`environment variables <ctest-resource-environment-variables>` to
When CTest sets the :ref:`environment variables
<ctest-resource-environment-variables>` for a test, it assigns a group number
variable if either of these are set.  Because the test's start time is
Set name of variable in header file containing object code of a ``.hlsl``
following targets by setting the ``CMAKE_AUTOMOC`` variable.  The
variable may be populated to pre-set the options for all following targets.
targets by setting the ``CMAKE_AUTOUIC`` variable.  The
to pass to ``uic``.  The ``CMAKE_AUTOUIC_OPTIONS`` variable may be
depender target.  The ``CMAKE_DEBUG_TARGET_PROPERTIES`` variable may
by setting the ``CMAKE_AUTORCC`` variable.  The
to pass to ``rcc``.  The ``CMAKE_AUTORCC_OPTIONS`` variable may be
built-in variables, such as
Several variables relate to the language components of a toolchain which are
The ``CMAKE_<LANG>_FLAGS`` variables and the configuration-specific
The ``CMAKE_CROSSCOMPILING`` variable is set to true when CMake is
variables inside a toolchain file is typically undesirable.  The toolchain
file is used in contexts where these variables have different values when used
appropriate variable to use would be ``CMAKE_CURRENT_LIST_DIR``, since
The ``CMAKE_<LANG>_COMPILER`` variables may be set to full paths, or to
the ``CMAKE_TRY_COMPILE_TARGET_TYPE`` variable to ``STATIC_LIBRARY``
the ``CMAKE_FIND_ROOT_PATH_MODE_*`` variables.
variables and will configure a project to use the compiler wrappers from the
enabled by setting the ``CRAYPE_LINK_TYPE`` environment variable to
``CMAKE_<LANG>_COMPILER_EXTERNAL_TOOLCHAIN`` variable can be set in a
Windows Phone.  Specify the ``CMAKE_SYSTEM_VERSION`` variable
by setting the ``CMAKE_SYSTEM_NAME`` variable to ``ADSP``
and the ``CMAKE_SYSTEM_PROCESSOR`` variable
Custom install paths can be set via the ``CMAKE_ADSP_ROOT`` variable
or the ``ADSP_ROOT`` environment variable.
``CMAKE_SYSTEM_NAME`` variable to ``Android``.  Further configuration
* If the ``CMAKE_ANDROID_NDK`` variable is set, the NDK at the
* Else, if the ``CMAKE_ANDROID_STANDALONE_TOOLCHAIN`` variable
* Else, if the ``CMAKE_SYSROOT`` variable is set to a directory
* Else, if the ``CMAKE_SYSROOT`` variable is set to a directory of the
* Else, if a cmake variable ``ANDROID_NDK`` is set it will be used
* Else, if a cmake variable ``ANDROID_STANDALONE_TOOLCHAIN`` is set, it will be
* Else, if an environment variable ``ANDROID_NDK_ROOT`` or
* Else, if an environment variable ``ANDROID_STANDALONE_TOOLCHAIN`` is
  in the ``CMAKE_ANDROID_NDK_VERSION`` variable.
Configure use of an Android NDK with the following variables:
  * If the ``CMAKE_ANDROID_API`` variable is set, its value
  * If the ``CMAKE_SYSROOT`` variable is set, the API level is
  variable will default to the first supported ABI in the list of
  The ``CMAKE_ANDROID_ARCH`` variable will be computed
  ``CMAKE_ANDROID_ARM_NEON`` variables.
  If not specified, a default for this variable will be chosen
  On NDK r19 or above, this variable must be unset or set to ``clang``.
  a default will be selected as described in the variable documentation.
The following variables will be computed and provided automatically:
Configure use of an Android standalone toolchain with the following variables:
  If not specified, a default for this variable will be chosen
  See variable documentation for details.
  to target ARM NEON devices.  See variable documentation for details.
The following variables will be computed and provided automatically:
``CMAKE_SYSTEM_NAME`` variable to a value from the table below.
``CMAKE_OSX_SYSROOT`` variable, although this should rarely be
specified via the ``CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM`` CMake variable.
cmake-variables(7)
This page documents variables that are provided by CMake
For general information on variables, see the
variable to the number of command line arguments.  See also
variable to the first command line argument.  It then also sets ``CMAKE_ARGV1``,
When run in -P script mode, CMake sets the variables
This variable exists only for backwards compatibility.
Use that variable instead.
This variable is used internally by CMake, and may not be set during
same value as ``CMAKE_BINARY_DIR``.  Use that variable instead.
the value is a reference to a build-time variable specifying the name
variable is suitable only for use in command lines that will be
This variable is read-only.  Setting it is undefined behavior.  In
multi-configuration build systems the value of this variable is passed
This variable will be set to true by CMake if the ``CMAKE_SYSTEM_NAME``
variable has been set manually (i.e. in a toolchain file or as a cache entry
This variable is only used when ``CMAKE_CROSSCOMPILING`` is on. It
  If this variable contains a :ref:`semicolon-separated list <CMake Language
processed this variable will be set.  For in-source builds this is the
When run in -P script mode, CMake sets the variables
When executing code inside a ``function()``, this variable
When executing code inside a ``function()``, this variable
such as templates to be copied in after substituting CMake variables.
eliminates the need for the extra variable which would otherwise be visible
When executing code inside a ``function()``, this variable
When executing code inside a ``function()``, this variable
As CMake processes the listfiles in your project this variable will
it sets this variable to the directory where this file is located.
previous value.  Therefore the value of the variable inside a macro or
As CMake processes the listfiles in your project this variable will
it sets this variable to the location of the file.  When CMake
value.  Therefore the value of the variable inside a macro or function
the ``cmake_language(DEFER)`` command, this variable
When run in -P script mode, CMake sets the variables
This variable can be populated with a list of properties to generate
This variable is used to initialize the ``DOTNET_SDK``
This variable is used to initialize the
This variable is only evaluated for :ref:`Visual Studio Generators`
This variable is used to initialize the
variable. See that variable or the associated target property
This variable is only evaluated for :ref:`Visual Studio Generators`
Enabling this variable is equivalent to using ``cmake`` ``--debug-find``
This read-only variable specifies a directory that the ``find_package()``
The primary purpose of this variable is to facilitate integration between
this variable has no effect.
``CMAKE_FIND_PACKAGE_SORT_DIRECTION`` variable
The value of this variable should never be modified by project code.
environment variable.
``CMAKE_GENERATOR_INSTANCE`` environment variable), or after a default
available in this variable.
The value of this variable should never be modified by project code.
variable may initialize ``CMAKE_GENERATOR_INSTANCE`` as a cache entry.
for this variable, changing the value has undefined behavior.
Visual Studio 2017 and above.  The ``CMAKE_GENERATOR_INSTANCE`` variable
to locate VS instances, chooses one, and sets the variable as a cache entry
to hold the value persistently.  If an environment variable of the form
option or via the ``CMAKE_GENERATOR_PLATFORM`` environment variable)
the value will be available in this variable.
The value of this variable should never be modified by project code.
variable may initialize ``CMAKE_GENERATOR_PLATFORM``.  Once a given
variable, changing the value has undefined behavior.
is provided in the ``CMAKE_VS_PLATFORM_NAME`` variable.
the ``CMAKE_GENERATOR_TOOLSET`` environment variable) the value
will be available in this variable.
The value of this variable should never be modified by project code.
variable may initialize ``CMAKE_GENERATOR_TOOLSET``.  Once a given
variable, changing the value has undefined behavior.
is provided in the ``CMAKE_VS_PLATFORM_TOOLSET`` variable.
  ``CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR`` variables.
  variable.
  See the ``CMAKE_VS_PLATFORM_TOOLSET_VERSION`` variable.
This variable is used to initialize the ``JOB_POOL_COMPILE``
This variable is used to initialize the ``JOB_POOL_LINK``
This variable is used to initialize the ``JOB_POOL_PRECOMPILE_HEADER``
of this variable is used in its place.  See ``JOB_POOLS``
variable to what would have been the ``CMAKE_<LANG>_COMPILER_ID`` for
  In other words, this variable describes what command line options
This variable is used to initialize the target property
This variable is used to initialize the target property
variable.
  (See also variables
  variable, changing the value has undefined behavior.
The ``CMAKE_MAKE_PROGRAM`` variable is set for use by project code.
``CMAKE_MATCH_<n>`` variables with the match contents.
The ``CMAKE_MATCH_COUNT`` variable holds the number of match
variables with the match contents.  The ``CMAKE_MATCH_COUNT``
variable holds the number of match expressions when these are filled.
variable scope or any parent variable scope.
variable.
This variable is used to initialize the ``NETRC`` option for the
This variable is also used by the ``ExternalProject`` and
The local option takes precedence over this variable.
This variable is used to initialize the ``NETRC_FILE`` option for the
This variable is also used by the ``ExternalProject`` and
The local option takes precedence over this variable.
``find_package()`` this variable contains the full path to the file
variable.
This variable holds the description of the project as specified in the top
variable.
This variable holds the homepage URL of the project as specified in the top
variable.
This variable holds the name of the project as specified in the top
variable.
This variable holds the version of the project as specified in the top
variable.
This variable holds the major version of the project as specified in the top
This variable holds the minor version of the project as specified in the top
This variable holds the patch version of the project as specified in the top
This variable holds the tweak version of the project as specified in the top
When run in ``cmake(1)`` ``-P`` script mode, CMake sets this variable to
file, this variable is not set.
will it generate ``cmake_install.cmake`` files. This variable is ``FALSE`` by
When run in ``-P`` script mode, CMake sets the variables
This variable is used to initialize the ``Swift_MODULE_DIRECTORY``
This variable controls the number of parallel jobs that the swift driver creates
This variable is specified on the command line when cross-compiling with CMake.
variable if it is set when a new build tree is first created.
See the ``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variable for setting
  In CMake versions 2.8.2 through 2.8.12, this variable holds
  ``CMAKE_VERSION`` variable.
This variable is a cache entry initialized (to ``FALSE``) by
Individual component values are also available in variables:
  The ``CMAKE_VERSION`` variable is defined by CMake 2.6.3 and higher.
  Earlier versions defined only the individual component variables.
variable to the ``devenv.com`` command installed with the corresponding
Visual Studio version.  Note that this variable may be empty on
This variable is not defined by other generators even if ``devenv.com``
See also the ``CMAKE_MAKE_PROGRAM`` variable.
variable to the ``MSBuild.exe`` command installed with the corresponding
This variable is not defined by other generators even if ``MSBuild.exe``
See also the ``CMAKE_MAKE_PROGRAM`` variable.
``CMAKE_SYSTEM_NAME`` variable set to ``Android``,
this variable contains the version number of the
When using a Visual Studio generator, this cache variable controls
will take precedence over the cache variable.
CMake provides the name of the chosen platform in this variable.
See the ``CMAKE_GENERATOR_PLATFORM`` variable for details.
See also the ``CMAKE_VS_PLATFORM_NAME_DEFAULT`` variable.
variable.  For :ref:`Visual Studio Generators` for VS 2017 and below this is
See also the ``CMAKE_VS_PLATFORM_NAME`` variable.
variable.
See the ``CMAKE_GENERATOR_TOOLSET`` variable for details.
CMake provides the selected CUDA toolset version in this variable.
variable (``x86``, ``x64``, ``ARM64`` or empty).
CMake provides the chosen value in this variable.
See the ``CMAKE_DOTNET_TARGET_FRAMEWORK_VERSION`` variable
CMake provides the chosen value in this variable.
CMake provides the chosen value in this variable.
The ``CMAKE_SYSTEM_VERSION`` variable may be set to specify a
One may set a ``CMAKE_WINDOWS_KITS_10_DIR`` *environment variable*
The ``CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM`` variable may
The ``Xcode`` generator defines this variable to indicate which
The ``CMAKE_XCODE_BUILD_SYSTEM`` variable is informational and should not
variable, if any is explicitly selected (e.g.  via the ``cmake(1)``
A variable is created with the name used in the ``project()`` command,
A boolean variable indicating whether the named project was called in a top
``PROJECT_IS_TOP_LEVEL`` variable.
The variable value will be true in:
The variable value will be false in:
A variable is created with the name used in the ``project()`` command,
See also the component-wise version variables
variable as set by the ``project()`` command.
variable as set by the ``project()`` command.
variable as set by the ``project()`` command.
variable as set by the ``project()`` command.
variable.
variable.
A boolean variable indicating whether the most recently called
tree, and this variable can be used to conditionally execute such code. For
The variable value will be true in:
The variable value will be false in:
the top level project, see the ``CMAKE_PROJECT_NAME`` variable.
See also the component-wise version variables
variable as set by the ``project()`` command.
variable as set by the ``project()`` command.
variable as set by the ``project()`` command.
variable as set by the ``project()`` command.
variable is often added to projects as an ``option()`` so that each user
This variable is defined by CMake-generated ``cmake_install.cmake``
This variable is initialized by the first ``project()`` or
variable is set, its value is used.  Otherwise, a toolchain-specific
Depending on the situation, the value of this variable may be treated
When cross compiling for windows with clang-cl, this variable can be an
``CMAKE_<LANG>_COMPILER_ID``.  If this variable is left empty,
If this variable evaluates to ``ON`` the generator excludes from
If this variable evaluates to ``ON`` at the end of the top-level
This variable uses three states: ``ON``, ``OFF`` and not defined.
  variable to ``ON``.  It controls color buildsystem messages.
If the ``CMAKE_COLOR_DIAGNOSTICS`` environment variable is set, its
This variable is initialized by the first ``project()`` or
environment variable is set, its value is used.  Otherwise, the default
Depending on the situation, the values in this variable may be treated
disabled by setting the variable
variables which have been stored in the cache will still be there.  In
that case it is recommended to remove the cache variables for this
See also the ``CMAKE_REQUIRE_FIND_PACKAGE_<PackageName>`` variable.
This cache variable is used by the Eclipse project generator.  See
This can be disabled by setting this variable to FALSE.
This cache variable is used by the Eclipse project generator.  See
If this variable is set to TRUE, the Eclipse project generator will generate
This cache variable is used by the Eclipse project generator.  See
This variable holds arguments which are used when Eclipse invokes the make
This cache variable tells the ``Eclipse CDT4`` project generator
This cache variable is used by the Eclipse project generator.  See
If this variable is not set, CMake behaves as if it were set to ``FALSE``.
file takes place.  This variable is used by CMake-generated
``cmake_install.cmake`` scripts.  If one sets this variable to ``ON`` while
If this variable is set to ``STDERR``, ``STDOUT`` or ``NONE`` then commands
variable, and initializes the ``EXPORT_COMPILE_COMMANDS`` target
  ``CMAKE_UNITY_BUILD`` variable.
``CMAKE_EXPORT_PACKAGE_REGISTRY`` variable may be set to enable it.
If ``CMP0090`` is *not* set to ``NEW`` this variable does nothing, and
the ``CMAKE_EXPORT_NO_PACKAGE_REGISTRY`` variable controls the behavior
If the ``CMAKE_EXPORT_NO_PACKAGE_REGISTRY`` variable is enabled,
If ``CMP0090`` is set to ``NEW`` this variable does nothing, and the
``CMAKE_EXPORT_PACKAGE_REGISTRY`` variable controls the behavior
This variable affects how ``find_*`` commands choose between
``CMAKE_FIND_APPBUNDLE`` variable can be set to empty or
This variable affects how ``find_*`` commands choose between
``CMAKE_FIND_FRAMEWORK`` variable can be set to empty or
``CMAKE_STAGING_PREFIX`` variables from
user may set the variable as a cache entry on the command line to achieve this.
By default this variable is not set. If neither
variable is ``TRUE``, all the ``find_package()`` commands will skip
By default this variable is not set. If neither
``CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY`` variable is
This variable may be useful when a developer has compiled a custom version of
variable is set to ``TRUE``, it would prevent a dependent project's call
Once this variable is set, it is the responsibility of the exported
``<pkg>Config.cmake`` files to provide the same result variables as the
This variable has no effect if ``CMAKE_FIND_PACKAGE_PREFER_CONFIG`` is
This variable is most useful when cross-compiling. CMake uses the paths in
This variable controls whether the ``CMAKE_FIND_ROOT_PATH`` and
This variable controls whether the ``CMAKE_FIND_ROOT_PATH`` and
This variable controls whether the ``CMAKE_FIND_ROOT_PATH`` and
This variable controls whether the ``CMAKE_FIND_ROOT_PATH`` and
search paths provided by cmake-specific environment variables:
By default this variable is not set, which is equivalent to it having
take precedence over this variable.
and ``CMAKE_FIND_USE_PACKAGE_ROOT_PATH`` variables.
``CMAKE_STAGING_PREFIX`` variables.
the behavior of the find command change based on if this variable exists.
By default this variable is not defined. Explicit options given to the above
commands take precedence over this variable.
and ``CMAKE_FIND_USE_PACKAGE_ROOT_PATH`` variables.
search paths provided by cmake-specific cache variables:
By default this variable is not set, which is equivalent to it having
take precedence over this variable.
and ``CMAKE_FIND_USE_PACKAGE_ROOT_PATH`` variables.
search paths provided by platform-specific cmake variables:
By default this variable is not set, which is equivalent to it having
take precedence over this variable.
and ``CMAKE_FIND_USE_PACKAGE_ROOT_PATH`` variables.
By default this variable is not set and the behavior will fall back
``CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY`` variable.  If that is
This variable takes precedence over
variable is ``FALSE``, all the ``find_package()`` commands will skip
and ``CMAKE_FIND_USE_PACKAGE_ROOT_PATH`` variables.
search paths provided by ``<PackageName>_ROOT`` variables:
By default this variable is not set, which is equivalent to it having
take precedence over this variable.
and ``CMAKE_FIND_USE_PACKAGE_REGISTRY`` variables.
search paths provided by standard system environment variables:
By default this variable is not set, which is equivalent to it having
take precedence over this variable.
and ``CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY`` variables.
By default this variable is not set and the behavior will fall back
``CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY`` variable.
This variable takes precedence over
variable is ``FALSE``, all the ``find_package()`` commands will skip
and ``CMAKE_FIND_USE_PACKAGE_ROOT_PATH`` variables.
See also the following variables:
See also the following variables:
This variable affects the default behavior of the ``include_directories()``
command.  Setting this variable to ``ON`` is equivalent to using the ``BEFORE``
This variable affects the order of include directories generated in compiler
default install component will be taken from this variable.  It
variable or platform specific default permissions if the variable is not set.
variable is a list of permissions that can be used by ``install()`` command
The ``CMAKE_INSTALL_MESSAGE`` variable may be set to control
If this variable is not set, the default behavior is ``ALWAYS``.
prepended onto all install directories.  This variable defaults to
variable for more information.
CMake sets this variable to a ``TRUE`` value when the
This variable affects the default behavior of the ``link_directories()``
command.  Setting this variable to ``ON`` is equivalent to using the ``BEFORE``
Set this variable to initialize the ``LINK_LIBRARIES_ONLY_TARGETS``
that set this variable should provide the user with a way to override it. For
* Reading or writing variables that are being watched by a
  ``variable_watch()``
option or the ``CMAKE_MESSAGE_CONTEXT_SHOW`` variable, the
Setting this variable to true enables showing a context with each line
This variable is an alternative to providing the ``--log-context`` option
``CMAKE_MESSAGE_CONTEXT_SHOW`` to true as a cache variable will ensure that
When set, this variable specifies the logging level used by the
If this variable is set and the ``--log-level`` command line option is
The main advantage to using this variable is to make a log level persist
between CMake runs.  Setting it as a cache variable will ensure that
Projects should not set this variable, it is intended for users so that
This variable should not be set by a project in CMake code as a way to
variable is meant to externally set policies for which a project has
* Users running CMake may set this variable in the cache
* Projects may set this variable before a call to ``add_subdirectory()``
This variable should not be set by a project in CMake code.  Project
developers running CMake may set this variable in their cache to
``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variables.
``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variables.
and ``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variables.
and ``CMAKE_PROJECT_TOP_LEVEL_INCLUDES`` variables.
(if one is specified) and platform variables have been set, but before any
languages have been enabled. Therefore, language-specific variables,
This variable is intended for specifying files that perform one-time setup
By default, this variable is empty.  It is intended to be set by the user.
``CMAKE_PROJECT_<PROJECT-NAME>_INCLUDE_BEFORE`` variables.
turned into ``REQUIRED`` by setting the variable
See also the ``CMAKE_DISABLE_FIND_PACKAGE_<PackageName>`` variable.
This variable may be set to a path to install to when cross-compiling. This can
``CMAKE_FIND_NO_INSTALL_PREFIX`` variable.
This variable contains a list of env vars as a list of tokens with the
In case of malformed variables CMake will fail:
If this variable evaluates to ``ON`` at the end of the top-level
If this variable evaluates to ``ON`` at the end of the top-level
This variable may only be set in a toolchain file specified by
the ``CMAKE_TOOLCHAIN_FILE`` variable.
``CMAKE_SYSROOT_LINK`` variables.
This variable may only be set in a toolchain file specified by
the ``CMAKE_TOOLCHAIN_FILE`` variable.
This variable may only be set in a toolchain file specified by
the ``CMAKE_TOOLCHAIN_FILE`` variable.
The project or end user should not modify this variable, they should use
See also the following variables:
The project or end user should not modify this variable, they should use
See also the following variables:
the ``CMAKE_FIND_NO_INSTALL_PREFIX`` variable before the
environment variables. The environment variables and search locations that
evolve. The following provides an indicative list of environment variables
This variable is also used by the ``ExternalProject`` and
This variable is also used by the ``ExternalProject`` and
may set platform information variables to override CMake's defaults.
version of this variable.
variables that must be set before CMake builds its first test project
``CMAKE_C_FLAGS_INIT`` variable
``CMAKE_C_FLAGS`` variable
that could be set after languages are enabled, such as variables like
If this variable is not set, CMake behaves as if it were set to ``TRUE``.
This variable is used by CMake-generated ``cmake_install.cmake`` scripts.
If one sets this variable to ``ON`` while running the script, it may get
This variable initializes the
This variable is used to initialize the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
Specify environment variables that should be added to the Arguments
If set to a list of environment variables and values of the form
``MYVAR=value`` those environment variables will be added to the
This variable initializes the ``XCODE_SCHEME_ENVIRONMENT``
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
This variable initializes the
specified by the ``<PackageName>_ROOT`` CMake variable, where
prefixes specified in the ``Foo_ROOT`` CMake variable (if set).
This variable may hold a single prefix or a
See also the ``<PackageName>_ROOT`` environment variable.
Android NDK version 11 or higher, this variable is provided by
This variable is the composite of ``CMAKE_HOST_SYSTEM_NAME`` and
``CMAKE_HOST_SYSTEM_VERSION`` is not set, then this variable is
On systems that have the uname command, this variable is set to the
On Windows, this variable is set to the value of the environment variable
On systems that support ``uname``, this variable is set to the output of:
  * The ``CMAKE_APPLE_SILICON_PROCESSOR`` variable or
    the ``CMAKE_APPLE_SILICON_PROCESSOR`` environment variable
``uname``, this variable is set to the output of ``uname -r``. On other
limit.  This variable may be set to specify the limit explicitly.  The
This variable is the composite of ``CMAKE_SYSTEM_NAME`` and
``CMAKE_SYSTEM_VERSION`` is not set, then this variable is
See the ``CMAKE_SYSTEM_VERSION`` variable for the OS version.
``CMAKE_HOST_SYSTEM_NAME`` variable so that the build
In this case the ``CMAKE_SYSTEM_VERSION`` variable must also be
When not cross-compiling, this variable has the same value as the
``CMAKE_HOST_SYSTEM_PROCESSOR`` variable.  In many cases,
the ``CMAKE_SYSTEM_PROCESSOR`` variable to match target architecture
See the ``CMAKE_SYSTEM_NAME`` variable for the OS name.
When the ``CMAKE_SYSTEM_NAME`` variable takes its default value
``CMAKE_HOST_SYSTEM_VERSION`` variable so that the build targets
When the ``CMAKE_SYSTEM_NAME`` variable is set explicitly to
See also the ``MSVC_VERSION`` variable.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
Discouraged.  Use the ``MSVC_VERSION`` variable instead.
  This variable is only available after compiler detection has been performed,
If MSVC-like is being used, this variable is set based on the version
of the compiler as given by the ``MSVC_VERSION`` variable.
See also the ``MSVC_VERSION`` variable.
If a compiler simulating Visual C++ is being used, this variable is set
``MSVC_TOOLSET_VERSION`` variable.
``CMAKE_SYSTEM_NAME`` variable should be queried if
True when the ``CMAKE_SYSTEM_NAME`` variable is set
True when the ``CMAKE_SYSTEM_NAME`` variable is set
True when the ``CMAKE_SYSTEM_NAME`` variable is set
this variable holds the absolute path to the latest CCES or VDSP++ install.
See also the ``ADSP_ROOT`` environment variable.
This variable is used to initialize the property on each target as it is
Edition`, this variable may be set to specify the default value for the
Otherwise, when :ref:`Cross Compiling for Android`, this variable provides
the ``CMAKE_SYSTEM_VERSION`` variable for ``Android`` platforms.
Edition`, this variable may be set to specify the default value for the
Otherwise, when :ref:`Cross Compiling for Android`, this variable provides
``CMAKE_ANDROID_ARCH_ABI`` variable.  The architecture name
When :ref:`Cross Compiling for Android`, this variable specifies the
``CMAKE_ANDROID_ARM_NEON`` variables.
When :ref:`Cross Compiling for Android with the NDK`, this variable may be set
When :ref:`Cross Compiling for Android with the NDK`, this variable holds
When :ref:`Cross Compiling for Android with the NDK`, this variable
When :ref:`Cross Compiling for Android with the NDK`, this variable
When :ref:`Cross Compiling for Android with the NDK`, this variable
On NDK r19 or above, this variable must be unset or set to ``clang``.
On NDK r18 or below, this variable must be set to one of these forms:
match the ABI named in the ``CMAKE_ANDROID_ARCH_ABI`` variable.
When :ref:`Cross Compiling for Android with the NDK`, this variable may be set
variable holds the absolute path to the root directory of the toolchain.
Edition`, this variable may be set to specify the default value for the
When :ref:`Cross Compiling for Android with the NDK`, this variable may be
On Apple Silicon hosts running macOS, set this variable to tell
The value of this variable should never be modified by project code.
See also the ``CMAKE_APPLE_SILICON_PROCESSOR`` environment variable.
This variable is used to initialize the ``ARCHIVE_OUTPUT_DIRECTORY``
This variable is used to initialize the
This variable is used to initialize the ``AUTOGEN_ORIGIN_DEPENDS``
This variable is used to initialize the ``AUTOGEN_PARALLEL`` property
as setting the ``VERBOSE`` environment variable during
This variable is used to initialize the ``AUTOMOC`` property on all the
This variable is used to initialize the ``AUTOMOC_COMPILER_PREDEFINES``
This variable is used to initialize the ``AUTOMOC_DEPEND_FILTERS``
This variable is used to initialize the ``AUTOMOC_MACRO_NAMES``
This variable is used to initialize the ``AUTOMOC_MOC_OPTIONS`` property
This variable is used to initialize the ``AUTOMOC_PATH_PREFIX``
This variable is used to initialize the ``AUTORCC`` property on all
This variable is used to initialize the ``AUTORCC_OPTIONS`` property on
This variable is used to initialize the ``AUTOUIC`` property on all
This variable is used to initialize the ``AUTOUIC_OPTIONS`` property on
This variable is used to initialize the ``AUTOUIC_SEARCH_PATHS``
tree.  See also the ``CMAKE_INSTALL_RPATH`` variable.
This variable is used to initialize the ``BUILD_WITH_INSTALL_NAME_DIR``
install ``RPATH``.  If this variable is set to true then the software is
This variable is used to initialize the
This variable is used to initialize the
This variable is used to initialize the
target property is initialized with the value of this variable if it is set.
``Ninja Multi-Config`` generator.  This variable activates
cross-config mode. Targets from each config specified in this variable can be
The value of this variable must be a subset of
property. This variable is used to initialize the property on each target as
This variable is used to initialize the ``CUDA_RUNTIME_LIBRARY``
If this variable is not set then the ``CUDA_RUNTIME_LIBRARY`` target
This variable is used to initialize the property on each target as it is
See variable ``CMAKE_<CONFIG>_POSTFIX``.
This variable is a special case of the more-general
``CMAKE_<CONFIG>_POSTFIX`` variable for the `DEBUG` configuration.
``Ninja Multi-Config`` generator. If this variable is specified,
custom commands are executed with this configuration. If the variable is not
The value of this variable must be one of the items from
The value of this variable must be a subset of ``CMAKE_CROSS_CONFIGS``
variable with value ``FALSE``, you can restore the legacy behavior (i.e. using
This variable is used to initialize the ``ENABLE_EXPORTS`` target
This variable is meant to be set by a :variable:`toolchain file
This variable is meant to be set by a :variable:`toolchain file
See also the configuration-specific variable
This variable is used to initialize the ``FOLDER`` property on all the
This variable is used to initialize the ``FRAMEWORK`` property on
target property is initialized with the value of this variable if it is set.
This variable is used to initialize the ``Fortran_FORMAT`` property on
This variable is used to initialize the ``Fortran_MODULE_DIRECTORY``
This variable is used to initialize the ``Fortran_PREPROCESS``
This variable is used to initialize the ``GNUtoMS`` property on
If this variable is enabled, CMake automatically adds
If this variable is enabled, CMake automatically adds for each shared
This variable is used to initialize the target property
This variable is used to initialize the ``INTERPROCEDURAL_OPTIMIZATION``
This variable is used to initialize the ``INTERPROCEDURAL_OPTIMIZATION_<CONFIG>``
This variable is used to initialize the ``IOS_INSTALL_COMBINED``
This variable is used to initialize the property on each target as it is
This variable is used to initialize the property on each target as it is
This variable is initialized to the ``CMAKE_<LANG>_COMPILER_LAUNCHER``
environment variable if it is set.
Default value for ``<LANG>_CPPCHECK`` target property. This variable
Default value for ``<LANG>_CPPLINT`` target property. This variable
This variable is used to initialize the property on each target as it is
This variable defines how to link a library or framework for the specified
For this variable to have any effect, the associated
``CMAKE_<LANG>_LINK_LIBRARY_USING_<FEATURE>_SUPPORTED`` variable
The ``CMAKE_LINK_LIBRARY_USING_<FEATURE>`` variable should be defined
For all three elements of this variable (``<PREFIX>``, ``<LIBRARY_EXPRESSION>``,
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
Set to ``TRUE`` if the ``<FEATURE>``, as defined by variable
  This variable is evaluated before the more generic variable
variable is used to initialize the property on each target as it is created.
This variable is initialized to the ``CMAKE_<LANG>_LINKER_LAUNCHER``
environment variable if it is set.
This variable defines how to link a group of libraries for the specified
For this variable to have any effect, the associated
``CMAKE_<LANG>_LINK_GROUP_USING_<FEATURE>_SUPPORTED`` variable
The ``CMAKE_LINK_GROUP_USING_<FEATURE>`` variable should be defined
For the elements of this variable, the ``LINKER:`` prefix can be used.
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
This variable specifies whether the ``<FEATURE>`` is supported for the link
language ``<LANG>``.  If this variable is true, then the ``<FEATURE>`` must
``CMAKE_LINK_GROUP_USING_<FEATURE>`` variables are not used.
set, then the ``CMAKE_LINK_GROUP_USING_<FEATURE>_SUPPORTED`` variable
See also variable ``CMAKE_LINK_WHAT_YOU_USE_CHECK``.
This variable is used to initialize the ``LIBRARY_OUTPUT_DIRECTORY``
This variable is used to initialize the
This variable initializes the ``LINK_DEPENDS_NO_SHARED`` property on
This variable defines how to link a group of libraries for the specified
Both of the following conditions must be met for this variable to have any
  variable must be set to true.
The ``CMAKE_<LANG>_LINK_GROUP_USING_<FEATURE>`` variable should be
For the elements of this variable, the ``LINKER:`` prefix can be used.
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
This variable specifies whether the ``<FEATURE>`` is supported regardless of
the link language.  If this variable is true, then the ``<FEATURE>`` must
Note that this variable has no effect if
This variable is used to initialize the ``LINK_INTERFACE_LIBRARIES``
This variable defines how to link a library or framework for the specified
Both of the following conditions must be met for this variable to have any
  variable must be set to true.
For all three elements of this variable (``<PREFIX>``, ``<LIBRARY_EXPRESSION>``,
``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variables.
Set to ``TRUE`` if the ``<FEATURE>``, as defined by variable
  This variable is evaluated if, and only if, the variable
This variable is used to initialize the property on each target as it is
See also ``CMAKE_<LANG>_LINK_WHAT_YOU_USE_FLAG`` variables.
This variable is used to initialize the ``MACOSX_BUNDLE`` property on
This variable is set to ``ON`` by default if ``CMAKE_SYSTEM_NAME``
This variable is used to initialize the ``MACOSX_RPATH`` property on
This variable is used to initialize the
This variable is meant to be set by a :variable:`toolchain file
This variable is meant to be set by a :variable:`toolchain file
See also the configuration-specific variable
environment variable, if set, and otherwise left empty.
This variable is used to initialize the ``MSVC_RUNTIME_LIBRARY``
If this variable is not set then the ``MSVC_RUNTIME_LIBRARY`` target
  This variable has effect only when policy ``CMP0091`` is set to ``NEW``
prefixed by the contents of this variable (a trailing slash is
If this variable is set to true then CMake will relink the binary before
  This variable also applies to XCOFF binaries' LIBPATH.  Prior to the
  addition of the XCOFF editor in CMake 3.20, this variable applied only
This variable is used to initialize the ``NO_SYSTEM_FROM_IMPORTED``
This variable is used to initialize the ``OSX_ARCHITECTURES``
The value of this variable should be set prior to the first
This variable should be set as a ``CACHE`` entry (or else CMake may
Despite the ``OSX`` part in the variable name(s) they apply also to
This variable is ignored on platforms other than Apple.
variable value for the ``-mmacosx-version-min`` flag or their respective
multiple macOS SDKs this variable also helps to choose the SDK in case
``MACOSX_DEPLOYMENT_TARGET`` environment variable, if set,
The value of this variable should be set prior to the first
This variable should be set as a ``CACHE`` entry (or else CMake may
Despite the ``OSX`` part in the variable name(s) they apply also to
This variable is ignored on platforms other than Apple.
environment variable, if set, and otherwise computed based on the
The value of this variable should be set prior to the first
This variable should be set as a ``CACHE`` entry (or else CMake may
Despite the ``OSX`` part in the variable name(s) they apply also to
This variable is ignored on platforms other than Apple.
This variable is used to initialize the ``PCH_WARN_INVALID``
This variable is used to initialize the ``PCH_INSTANTIATE_TEMPLATES``
This variable is used to initialize the ``PDB_OUTPUT_DIRECTORY``
This variable is used to initialize the
This variable is used to globally control whether the
By default this variable is set only on platforms where
This variable is used to initialize the
This variable is used to initialize the ``RUNTIME_OUTPUT_DIRECTORY``
This variable is used to initialize the
This variable is meant to be set by a :variable:`toolchain file
This variable is meant to be set by a :variable:`toolchain file
See also the configuration-specific variable
install RPATH.  If this variable is set to true then the software is
install RPATH.  If this variable is set to true then the software is
  variable is kept for compatibility.
  variable is kept for compatibility.
This variable is meant to be set by a :variable:`toolchain file
This variable is meant to be set by a :variable:`toolchain file
See also the configuration-specific variable
to propagate any platform variables into the test project.
The ``try_compile()`` command normally passes some CMake variables
See policy ``CMP0137``.  This variable may be set to disable
List of variables that the ``try_compile()`` command source file signature
This variable should not be set by project code.  It is meant to be set by
variable may be set to pass custom variables meaningful to a toolchain file.
  Listed variables are propagated to the ``try_compile()``
  The ``CMAKE_TRY_COMPILE_NO_PLATFORM_VARIABLES`` variable may be
  set to disable passing platform variables into the test project.
This variable is used to initialize the ``UNITY_BUILD``
Projects should not set this variable, it is intended as a developer
By default, this variable is not set, which will result in unity builds
  the ``CMAKE_EXPORT_COMPILE_COMMANDS`` variable.
This variable is used to initialize the ``UNITY_BUILD_BATCH_SIZE``
This variable is used to initialize the ``UNITY_BUILD_UNIQUE_ID``
This variable has no effect.  The partially implemented effect it
This variable is used to initialize the
Projects should not normally set this variable, it is intended as a developer
By default, this variable is not set, which will result in header set
``VS_GLOBAL_<variable>`` with ``variable=Key`` and value ``Value``.
This variable is meant to be set by a
of the default build. Setting this variable will enable the ``INSTALL`` target
of the default build. Setting this variable will enable the ``PACKAGE`` target
This variable is used to initialize the ``VS_JUST_MY_CODE_DEBUGGING``
This variable is used to initialize the ``VS_NO_COMPILE_BATCHING``
This shows setting the property for the target ``foo`` using the variable.
This variable allows to override Visual Studio default Exclude Directories.
This variable allows to override Visual Studio default Executable Directories.
This variable allows to override Visual Studio default Include Directories.
This variable allows to override Visual Studio default Library Directories.
This variable allows to override Visual Studio default Library WinRT
This variable allows to override Visual Studio default Reference Directories.
This variable allows to override Visual Studio default Source Directories.
This variable is meant to be set by a
This variable is used to initialize the ``WATCOM_RUNTIME_LIBRARY``
If this variable is not set then the ``WATCOM_RUNTIME_LIBRARY`` target
  This variable has effect only when policy ``CMP0136`` is set to ``NEW``
This variable is used to initialize the ``WIN32_EXECUTABLE`` property
This variable is used to initialize the property on each target as it is
Old executable location variable.
variable for a target if it is set.  Executable targets are otherwise placed in
Old library location variable.
supersede this variable for a target if they are set.  Library targets are
This variable is deprecated.  Use
This variable is deprecated.  Use
This variable is deprecated.  Use
Initialized by the ``CUDAARCHS`` environment variable if set.
This variable is used to initialize the ``CUDA_ARCHITECTURES`` property
The ``CMAKE_CUDA_HOST_COMPILER`` variable may be set explicitly before CUDA is
the ``CUDAHOSTCXX`` environment variable to provide a default value.
Once the CUDA language is enabled, the ``CMAKE_CUDA_HOST_COMPILER`` variable
This variable is used to initialize the ``HIP_ARCHITECTURES`` property
This variable is used to initialize the ``ISPC_HEADER_DIRECTORY``
This variable is used to initialize the ``ISPC_HEADER_SUFFIX``
This variable is used to initialize the ``ISPC_INSTRUCTION_SETS`` property
When :ref:`Cross Compiling for Android` this variable contains the
When :ref:`Cross Compiling for Android` this variable contains the absolute
When :ref:`Cross Compiling for Android` this variable contains the
Rule variable to append to a static archive.
This is a rule variable that tells CMake how to append to a static
Rule variable to create a new static archive.
This is a rule variable that tells CMake how to create a static
Rule variable to finish an existing static archive.
This is a rule variable that tells CMake how to finish a static
set, you can not change this variable.
This variable can be set by the user during the first time a build tree is configured.
The variable could be set in a user supplied toolchain file or via `-D` on the command line.
This variable may only be set in a toolchain file specified by
the ``CMAKE_TOOLCHAIN_FILE`` variable.
This variable is not guaranteed to be defined for all compilers or
``enable_language()`` this variable is defined to ``1``.
This variable may only be set in a toolchain file specified by
the ``CMAKE_TOOLCHAIN_FILE`` variable.
variable is not guaranteed to be defined for all compilers or
Rule variable to compile a single object file.
This is a rule variable that tells CMake how to compile a single
Rule variable to create a shared library.
This is a rule variable that tells CMake how to create a shared
library for the language ``<LANG>``.  This rule variable is a ``;`` delimited
Rule variable to create a shared module.
This is a rule variable that tells CMake how to create a shared
library for the language ``<LANG>``.  This rule variable is a ``;`` delimited
Rule variable to create a static library.
This is a rule variable that tells CMake how to create a static
This variable is read-only.  Modifying it is undefined behavior.
This is initialized for each language from environment variables:
  Initialized by the ``CFLAGS`` environment variable.
  Initialized by the ``CXXFLAGS`` environment variable.
  Initialized by the ``CUDAFLAGS`` environment variable.
  Initialized by the ``FFLAGS`` environment variable.
The flags in this variable will be passed to the compiler before those
The flags in this variable will be passed to the compiler after those
in the ``CMAKE_<LANG>_FLAGS`` variable, but before flags added
This variable is meant to be set by a :variable:`toolchain file
This variable is the ``Debug`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>`` variable.
This variable is the ``Debug`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>_INIT`` variable.
This variable is meant to be set by a :variable:`toolchain file
the contents of a ``xxxFLAGS`` environment variable will be prepended,
``CMAKE_<LANG>_FLAGS_<CONFIG>_INIT`` variable.
This variable is the ``MinSizeRel`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>`` variable.
This variable is the ``MinSizeRel`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>_INIT`` variable.
This variable is the ``Release`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>`` variable.
This variable is the ``Release`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>_INIT`` variable.
This variable is the ``RelWithDebInfo`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>`` variable.
This variable is the ``RelWithDebInfo`` variant of the
``CMAKE_<LANG>_FLAGS_<CONFIG>_INIT`` variable.
directories and reports the results in this variable.
from this variable for each language used in the static library (except
``CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES`` variable may instead be provided
may set the variable to a value known for the specified toolchain.  It will
Some toolchains read implicit directories from an environment variable such as
``LIBRARY_PATH``.  If using such an environment variable, keep its value
See also the ``CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES`` variable.
for each language and reports the results in this variable.
the results in this variable.
flags from this variable for each language used in the static library (except
``CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES`` variable may instead be provided
may set the variable to a value known for the specified toolchain.  It will
See also the ``CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES`` variable.
variable contains the ``<arch>`` name if/as detected by CMake.
Rule variable to link an executable.
Rule variable to link an executable for the given language.
This variable holds a :ref:`semicolon-separated list <CMake Language Lists>` of tokens.
The ``CMAKE_<LANG>_LINKER_WRAPPER_FLAG_SEP`` variable can be specified
This variable is used with ``CMAKE_<LANG>_LINKER_WRAPPER_FLAG``
variable to format ``LINKER:`` prefix in the link options
variable to what would have been the ``CMAKE_<LANG>_COMPILER_ID`` for
  In other words, this variable describes the ABI compatibility
variable to what would have been the ``CMAKE_<LANG>_COMPILER_VERSION``
This variable should not be set by project code.  It is meant to be set by
This variable should not be set by project code.  It is meant to be set by
then this variable is populated accordingly.
set the ``CTEST_COVERAGE_COMMAND`` variable to point to a file which will
``CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE`` variables.
environment variable to executed command. CTests adds
Note that this variable must always be set for a nightly build in a
value of this variable from the build is used.
This variable is a Read-Only variable which is set internally by CPack
CPack variables (set via e.g. ``cpack -D``, ``CPackConfig.cmake`` or
pairs in the ``CPACK_CUSTOM_INSTALL_VARIABLES`` variable.  At install time,
each list item will result in a variable of the specified name (``varName``)
internally.  This variable triggers the definition
Each CPack generator has a built-in default value for this variable.
setting this variable.
There is a similar variable
This variable serves the same purpose during packaging as the
``CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS`` variable
If `include(CPack)` is used then by default this variable is set to the content
This variable triggers the definition of
Operator to read cache variables.
See the :ref:`cmake-language(7) variables <CMake Language Variables>`
normal variables and cache entries.
CMake first searches for a normal variable with that name, and if not
ignore any existing normal variable.
write or remove cache variables.
Operator to read environment variables.
Use the syntax ``$ENV{VAR}`` to read environment variable ``VAR``.
To test whether an environment variable is defined, use the signature
For general information on environment variables, see the
CMake has many internal variables.  Most of them are undocumented.
variables, and therefore may be encountered in legacy code. They
be used in project code.  The variable ``CMAKE_SOURCE_DIR``
An internal variable subject to change.
An internal variable subject to change.
An internal variable subject to change.
An internal variable subject to change.
An internal variable subject to change.
also the ``CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES`` variable.
An internal variable subject to change.
considered if this variable is true.
An internal variable subject to change.
.. variable:: CPACK_ARCHIVE_FILE_NAME
  Note that ``<component>`` is all uppercase in the variable name.
    Per-component ``CPACK_ARCHIVE_<component>_FILE_NAME`` variables.
.. variable:: CPACK_ARCHIVE_COMPONENT_INSTALL
These variables are used by the Archive generator, but are also available to
.. variable:: CPACK_ARCHIVE_THREADS
  See also the ``CPACK_THREADS`` variable.
aforementioned DragNDrop (``CPACK_DMG_xxx``) variables, plus the following
.. variable:: CPACK_BUNDLE_NAME
.. variable:: CPACK_BUNDLE_PLIST
.. variable:: CPACK_BUNDLE_ICON
.. variable:: CPACK_BUNDLE_STARTUP_COMMAND
.. variable:: CPACK_BUNDLE_APPLE_CERT_APP
 ``3rd Party Mac Developer Application: [Name]``. If this variable is not set
.. variable:: CPACK_BUNDLE_APPLE_ENTITLEMENTS
.. variable:: CPACK_BUNDLE_APPLE_CODESIGN_FILES
.. variable:: CPACK_BUNDLE_APPLE_CODESIGN_PARAMETER
.. variable:: CPACK_COMMAND_CODESIGN
 Apple cert. This variable can be used to override the automatically
following variable is specific to installers build on and/or for
.. variable:: CPACK_CYGWIN_PATCH_NUMBER
.. variable:: CPACK_CYGWIN_PATCH_FILE
.. variable:: CPACK_CYGWIN_BUILD_SCRIPT
``CPACK_XXX`` variables used by ``CPack``.
specifics ``CPACK_DEBIAN_XXX`` variables.
``CPACK_DEBIAN_<COMPONENT>_XXXX`` variables may be used in order to have
List of CPack DEB generator specific variables:
.. variable:: CPACK_DEB_COMPONENT_INSTALL
.. variable:: CPACK_DEBIAN_PACKAGE_NAME
 Set Package control field (variable is automatically transformed to lower
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_NAME`` variables.
.. variable:: CPACK_DEBIAN_FILE_NAME
   Preferred setting of this variable is ``DEB-DEFAULT`` but for backward
   get overwritten and it is up to the packager to set the variables in a
.. variable:: CPACK_DEBIAN_PACKAGE_EPOCH
.. variable:: CPACK_DEBIAN_PACKAGE_VERSION
 This variable may contain only alphanumerics (A-Za-z0-9) and the characters
 variable's content is not a hard error when both
 :variable:`CPACK_DEBIAN_PACKAGE_RELEASE` and
 :variable:`CPACK_DEBIAN_PACKAGE_EPOCH` variables are not set. An author
.. variable:: CPACK_DEBIAN_PACKAGE_RELEASE
.. variable:: CPACK_DEBIAN_PACKAGE_ARCHITECTURE
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_ARCHITECTURE`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_DEPENDS
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_DEPENDS`` variables.
   If :variable:`CPACK_DEBIAN_PACKAGE_SHLIBDEPS` or
   more specifically :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_SHLIBDEPS`
   to :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_DEPENDS` instead of
   :variable:`CPACK_DEBIAN_PACKAGE_DEPENDS`. If
   :variable:`CPACK_DEBIAN_<COMPONENT>_PACKAGE_DEPENDS` is an empty string,
.. variable:: CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS
 ``CPACK_COMPONENT_<compName>_DEPENDS`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_MAINTAINER
.. variable:: CPACK_DEBIAN_PACKAGE_DESCRIPTION
  Per-component ``CPACK_COMPONENT_<compName>_DESCRIPTION`` variables.
  Per-component ``CPACK_DEBIAN_<COMPONENT>_DESCRIPTION`` variables.
  The ``CPACK_PACKAGE_DESCRIPTION_FILE`` variable.
.. variable:: CPACK_DEBIAN_PACKAGE_SECTION
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_SECTION`` variables.
.. variable:: CPACK_DEBIAN_ARCHIVE_TYPE
 This variable previously defaulted to the ``paxr`` value, but ``dpkg``
.. variable:: CPACK_DEBIAN_COMPRESSION_TYPE
.. variable:: CPACK_DEBIAN_PACKAGE_PRIORITY
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_PRIORITY`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_HOMEPAGE
  The ``CMAKE_PROJECT_HOMEPAGE_URL`` variable.
.. variable:: CPACK_DEBIAN_PACKAGE_SHLIBDEPS
   You may need set :variable:`CMAKE_INSTALL_RPATH` to an appropriate value
   You can also set :variable:`CPACK_DEBIAN_PACKAGE_SHLIBDEPS_PRIVATE_DIRS`
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_SHLIBDEPS`` variables.
  Correct handling of ``$ORIGIN`` in :variable:`CMAKE_INSTALL_RPATH`.
.. variable:: CPACK_DEBIAN_PACKAGE_SHLIBDEPS_PRIVATE_DIRS
 You should prefer to set :variable:`CMAKE_INSTALL_RPATH` to an appropriate
.. variable:: CPACK_DEBIAN_PACKAGE_DEBUG
.. variable:: CPACK_DEBIAN_PACKAGE_PREDEPENDS
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_PREDEPENDS`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_ENHANCES
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_ENHANCES`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_BREAKS
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_BREAKS`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_CONFLICTS
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_CONFLICTS`` variables.
 :variable:`Breaks <CPACK_DEBIAN_PACKAGE_BREAKS>`, which prevents the
.. variable:: CPACK_DEBIAN_PACKAGE_PROVIDES
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_PROVIDES`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_REPLACES
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_REPLACES`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_RECOMMENDS
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_RECOMMENDS`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_SUGGESTS
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_SUGGESTS`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS
 ``CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS_POLICY`` variable value.
.. variable:: CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS_POLICY
.. variable:: CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
 This variable allow advanced user to add custom script to the
  Per-component ``CPACK_DEBIAN_<COMPONENT>_PACKAGE_CONTROL_EXTRA`` variables.
.. variable:: CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION
 This variable indicates if the Debian policy on control files should be
  package unless this variable is set to ``TRUE``.
.. variable:: CPACK_DEBIAN_PACKAGE_SOURCE
Dbgsym packaging has its own set of variables:
.. variable:: CPACK_DEBIAN_DEBUGINFO_PACKAGE
 or ``RelWithDebInfo`` for ``CMAKE_BUILD_TYPE`` variable value.
The environment variable ``SOURCE_DATE_EPOCH`` may be set to a UNIX
The following variables are specific to the DragNDrop installers built
.. variable:: CPACK_DMG_VOLUME_NAME
.. variable:: CPACK_DMG_FORMAT
.. variable:: CPACK_DMG_DS_STORE
.. variable:: CPACK_DMG_DS_STORE_SETUP_SCRIPT
.. variable:: CPACK_DMG_BACKGROUND_IMAGE
.. variable:: CPACK_DMG_DISABLE_APPLICATIONS_SYMLINK
.. variable:: CPACK_DMG_SLA_USE_RESOURCE_FILE_LICENSE
 CPack 3.22 and below always use :variable:`CPACK_RESOURCE_FILE_LICENSE`,
.. variable:: CPACK_DMG_SLA_DIR
  language defined in ``CPACK_DMG_SLA_LANGUAGES``.  If both this variable and
.. variable:: CPACK_DMG_SLA_LANGUAGES
  specified by the ``CPACK_DMG_SLA_DIR`` variable.
.. variable:: CPACK_DMG_<component>_FILE_NAME
.. variable:: CPACK_DMG_FILESYSTEM
.. variable:: CPACK_COMMAND_HDIUTIL
 macOS. This variable can be used to override the automatically detected
.. variable:: CPACK_COMMAND_SETFILE
 directories on macOS. This variable can be used to override the
.. variable:: CPACK_COMMAND_REZ
 variable can be used to override the automatically detected command (or
``CPACK_EXTERNAL_ENABLE_STAGING`` variable.
.. variable:: CPACK_EXTERNAL_REQUESTED_VERSIONS
  This variable is used to request a specific version of the CPack External
  If this variable is set to a non-empty value, the CPack External generator
  If this variable is not set, or is empty, the CPack External generator will
.. variable:: CPACK_EXTERNAL_ENABLE_STAGING
  This variable can be set to true to enable optional installation
.. variable:: CPACK_EXTERNAL_PACKAGE_SCRIPT
  This variable can optionally specify the full path to
  the variables defined by the CPack config file.
.. variable:: CPACK_EXTERNAL_BUILT_PACKAGES
  The ``CPACK_EXTERNAL_PACKAGE_SCRIPT`` script may set this list variable to the
``CPACK_XXX`` variables used by ``CPack``. It tries to re-use packaging
``CPACK_FREEBSD_XXX`` variables. The CPack FreeBSD generator, unlike the
All of the variables can be set specifically for FreeBSD packaging in
variables when those make sense (e.g. the homepage of an upstream project
.. variable:: CPACK_FREEBSD_PACKAGE_NAME
.. variable:: CPACK_FREEBSD_PACKAGE_COMMENT
.. variable:: CPACK_FREEBSD_PACKAGE_DESCRIPTION
.. variable:: CPACK_FREEBSD_PACKAGE_WWW
    The ``CMAKE_PROJECT_HOMEPAGE_URL`` variable.
.. variable:: CPACK_FREEBSD_PACKAGE_LICENSE
.. variable:: CPACK_FREEBSD_PACKAGE_LICENSE_LOGIC
  This variable is only of importance if there is more than one license.
.. variable:: CPACK_FREEBSD_PACKAGE_MAINTAINER
.. variable:: CPACK_FREEBSD_PACKAGE_ORIGIN
.. variable:: CPACK_FREEBSD_PACKAGE_CATEGORIES
.. variable:: CPACK_FREEBSD_PACKAGE_DEPS
You can use the following variables to change the behavior of the CPack ``IFW``
.. variable:: CPACK_IFW_VERBOSE
.. variable:: CPACK_IFW_PACKAGE_TITLE
.. variable:: CPACK_IFW_PACKAGE_PUBLISHER
.. variable:: CPACK_IFW_PRODUCT_URL
.. variable:: CPACK_IFW_PACKAGE_ICON
.. variable:: CPACK_IFW_PACKAGE_WINDOW_ICON
.. variable:: CPACK_IFW_PACKAGE_LOGO
.. variable:: CPACK_IFW_PACKAGE_WATERMARK
.. variable:: CPACK_IFW_PACKAGE_BANNER
.. variable:: CPACK_IFW_PACKAGE_BACKGROUND
.. variable:: CPACK_IFW_PACKAGE_WIZARD_STYLE
.. variable:: CPACK_IFW_PACKAGE_WIZARD_DEFAULT_WIDTH
.. variable:: CPACK_IFW_PACKAGE_WIZARD_DEFAULT_HEIGHT
.. variable:: CPACK_IFW_PACKAGE_WIZARD_SHOW_PAGE_LIST
.. variable:: CPACK_IFW_PACKAGE_TITLE_COLOR
.. variable:: CPACK_IFW_PACKAGE_STYLE_SHEET
.. variable:: CPACK_IFW_TARGET_DIRECTORY
 ``@ApplicationsDir@/${CPACK_PACKAGE_INSTALL_DIRECTORY}``. If that variable
 Predefined variables of the form ``@...@`` are expanded by the
.. variable:: CPACK_IFW_ADMIN_TARGET_DIRECTORY
 You can use predefined variables.
.. variable:: CPACK_IFW_PACKAGE_REMOVE_TARGET_DIR
.. variable:: CPACK_IFW_PACKAGE_GROUP
.. variable:: CPACK_IFW_PACKAGE_NAME
.. variable:: CPACK_IFW_PACKAGE_START_MENU_DIRECTORY
.. variable:: CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME
.. variable:: CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE
.. variable:: CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS
.. variable:: CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH
.. variable:: CPACK_IFW_PACKAGE_DISABLE_COMMAND_LINE_INTERFACE
.. variable:: CPACK_IFW_PACKAGE_CONTROL_SCRIPT
.. variable:: CPACK_IFW_PACKAGE_RESOURCES
.. variable:: CPACK_IFW_PACKAGE_FILE_EXTENSION
.. variable:: CPACK_IFW_REPOSITORIES_ALL
 The default value of this variable is computed by CPack and contains
.. variable:: CPACK_IFW_DOWNLOAD_ALL
.. variable:: CPACK_IFW_PACKAGE_PRODUCT_IMAGES
.. variable:: CPACK_IFW_PACKAGE_RUN_PROGRAM
 This typically means the path should begin with the QtIFW predefined variable
.. variable:: CPACK_IFW_PACKAGE_RUN_PROGRAM_ARGUMENTS
.. variable:: CPACK_IFW_PACKAGE_RUN_PROGRAM_DESCRIPTION
.. variable:: CPACK_IFW_PACKAGE_SIGNING_IDENTITY
.. variable:: CPACK_IFW_ARCHIVE_FORMAT
.. variable:: CPACK_IFW_ARCHIVE_COMPRESSION
 If this variable is not set, QtIFW will use a default compression level,
.. variable:: CPACK_IFW_RESOLVE_DUPLICATE_NAMES
.. variable:: CPACK_IFW_PACKAGES_DIRECTORIES
.. variable:: CPACK_IFW_REPOSITORIES_DIRECTORIES
.. variable:: CPACK_IFW_FRAMEWORK_VERSION
 The version of the QtIFW tools that will be used. This variable is set
The following variables provide the locations of the QtIFW
These variables are cached, and may be configured if needed.
.. variable:: CPACK_IFW_ARCHIVEGEN_EXECUTABLE
.. variable:: CPACK_IFW_BINARYCREATOR_EXECUTABLE
.. variable:: CPACK_IFW_REPOGEN_EXECUTABLE
.. variable:: CPACK_IFW_INSTALLERBASE_EXECUTABLE
.. variable:: CPACK_IFW_DEVTOOL_EXECUTABLE
.. variable:: CPACK_IFW_ROOT
  CMake variable
  Environment variable
.. variable:: QTIFWDIR
  CMake variable
  Environment variable
``CPACK_IFW_DOWNLOAD_ALL`` variable allow for more specific
Some variables and command arguments support internationalization via
A localized variable or argument can contain a single default value, and
  https://doc.qt.io/qtinstallerframework/scripting.html#predefined-variables
The following variables are specific to the graphical installers built
.. variable:: CPACK_NSIS_INSTALL_ROOT
.. variable:: CPACK_NSIS_MUI_ICON
.. variable:: CPACK_NSIS_MUI_UNIICON
.. variable:: CPACK_NSIS_INSTALLER_MUI_ICON_CODE
.. variable:: CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP
.. variable:: CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP
.. variable:: CPACK_NSIS_EXTRA_PREINSTALL_COMMANDS
.. variable:: CPACK_NSIS_EXTRA_INSTALL_COMMANDS
.. variable:: CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS
.. variable:: CPACK_NSIS_COMPRESSOR
.. variable:: CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL
.. variable:: CPACK_NSIS_MODIFY_PATH
 directory should be added to the system ``PATH`` variable.
.. variable:: CPACK_NSIS_DISPLAY_NAME
.. variable:: CPACK_NSIS_PACKAGE_NAME
.. variable:: CPACK_NSIS_INSTALLED_ICON_NAME
.. variable:: CPACK_NSIS_HELP_LINK
.. variable:: CPACK_NSIS_URL_INFO_ABOUT
.. variable:: CPACK_NSIS_CONTACT
.. variable:: CPACK_NSIS_<compName>_INSTALL_DIRECTORY
.. variable:: CPACK_NSIS_CREATE_ICONS_EXTRA
.. variable:: CPACK_NSIS_DELETE_ICONS_EXTRA
.. variable:: CPACK_NSIS_EXECUTABLES_DIRECTORY
 variable is set.  For example, you would set this to ``exec`` if your
.. variable:: CPACK_NSIS_MUI_FINISHPAGE_RUN
.. variable:: CPACK_NSIS_MENU_LINKS
.. variable:: CPACK_NSIS_UNINSTALL_NAME
.. variable:: CPACK_NSIS_WELCOME_TITLE
.. variable:: CPACK_NSIS_WELCOME_TITLE_3LINES
.. variable:: CPACK_NSIS_FINISH_TITLE
.. variable:: CPACK_NSIS_FINISH_TITLE_3LINES
.. variable:: CPACK_NSIS_MUI_HEADERIMAGE
.. variable:: CPACK_NSIS_MANIFEST_DPI_AWARE
.. variable:: CPACK_NSIS_BRANDING_TEXT
.. variable:: CPACK_NSIS_BRANDING_TEXT_TRIM_POSITION
 Allowed values for this variable are ``LEFT``, ``CENTER`` or ``RIGHT``.
.. variable:: CPACK_NSIS_EXECUTABLE
.. variable:: CPACK_NSIS_IGNORE_LICENSE_PAGE
is no ``CPACK_NUGET_PACKAGE_FILE_NAME`` variable. To form the output filename
it uses the ``CPACK_XXX`` variables used by ``CPack``.
specifics ``CPACK_NUGET_XXX`` variables. In the "one per group" mode
in the variables below would contain a group name (uppercased and turned into
List of CPack NuGet generator specific variables:
.. variable:: CPACK_NUGET_COMPONENT_INSTALL
.. variable:: CPACK_NUGET_PACKAGE_NAME
.. variable:: CPACK_NUGET_PACKAGE_VERSION
.. variable:: CPACK_NUGET_PACKAGE_DESCRIPTION
.. variable:: CPACK_NUGET_PACKAGE_AUTHORS
.. variable:: CPACK_NUGET_PACKAGE_TITLE
.. variable:: CPACK_NUGET_PACKAGE_OWNERS
.. variable:: CPACK_NUGET_PACKAGE_HOMEPAGE_URL
.. variable:: CPACK_NUGET_PACKAGE_LICENSEURL
.. variable:: CPACK_NUGET_PACKAGE_LICENSE_EXPRESSION
.. variable:: CPACK_NUGET_PACKAGE_LICENSE_FILE_NAME
.. variable:: CPACK_NUGET_PACKAGE_ICONURL
.. variable:: CPACK_NUGET_PACKAGE_ICON
.. variable:: CPACK_NUGET_PACKAGE_DESCRIPTION_SUMMARY
.. variable:: CPACK_NUGET_PACKAGE_RELEASE_NOTES
.. variable:: CPACK_NUGET_PACKAGE_COPYRIGHT
.. variable:: CPACK_NUGET_PACKAGE_LANGUAGE
.. variable:: CPACK_NUGET_PACKAGE_TAGS
.. variable:: CPACK_NUGET_PACKAGE_DEPENDENCIES
.. variable:: CPACK_NUGET_PACKAGE_DEPENDENCIES_<dependency>_VERSION
.. variable:: CPACK_NUGET_PACKAGE_DEBUG
The following variable is specific to installers built on Mac
.. variable:: CPACK_COMMAND_PRODUCTBUILD
 the macOS Installer or Mac App Store.  This variable can be used to override
.. variable:: CPACK_PRODUCTBUILD_IDENTIFIER
.. variable:: CPACK_PRODUCTBUILD_IDENTITY_NAME
.. variable:: CPACK_PRODUCTBUILD_KEYCHAIN_PATH
.. variable:: CPACK_COMMAND_PKGBUILD
 on macOS.  This variable can be used to override the automatically detected
.. variable:: CPACK_PKGBUILD_IDENTITY_NAME
.. variable:: CPACK_PKGBUILD_KEYCHAIN_PATH
.. variable:: CPACK_PREFLIGHT_<COMP>_SCRIPT
 component name.  No ``preinstall`` script is added if this variable is not
.. variable:: CPACK_POSTFLIGHT_<COMP>_SCRIPT
 component name.  No ``postinstall`` script is added if this variable is not
.. variable:: CPACK_PRODUCTBUILD_RESOURCES_DIR
.. variable:: CPACK_PRODUCTBUILD_DOMAINS
.. variable:: CPACK_PRODUCTBUILD_DOMAINS_ANYWHERE
 ``CPACK_PRODUCTBUILD_DOMAINS`` must be set to true for this variable
.. variable:: CPACK_PRODUCTBUILD_DOMAINS_USER
 ``CPACK_PRODUCTBUILD_DOMAINS`` must be set to true for this variable
.. variable:: CPACK_PRODUCTBUILD_DOMAINS_ROOT
 ``CPACK_PRODUCTBUILD_DOMAINS`` must be set to true for this variable
This group of variables controls the background image of the generated
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_ALIGNMENT
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_SCALING
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_MIME_TYPE
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_UTI
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_DARKAQUA
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_DARKAQUA_ALIGNMENT
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_DARKAQUA_SCALING
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_DARKAQUA_MIME_TYPE
.. variable:: CPACK_PRODUCTBUILD_BACKGROUND_DARKAQUA_UTI
``CMAKE_MODULE_PATH`` variable. CPack will then pick up the project's
similar to the ``configure_file()`` command. Any variable set when
form. The following variables are also set internally and made available for
``CPACK_XXX`` variables used by ``CPack``.
``CPACK_RPM_XXX`` variables.
``CPACK_RPM_<COMPONENT>_XXXX`` variables may be used in order to have
a component GROUP name. Usually those variables correspond to RPM spec file
 `<COMPONENT>` part of variables is preferred to be in upper case (e.g. if
 component is named ``foo`` then use ``CPACK_RPM_FOO_XXXX`` variable name format)
 as is with other ``CPACK_<COMPONENT>_XXXX`` variables.
 ``CPACK_RPM_fOo_XXXX``) is still supported for variables defined in older
 versions of CMake/CPack but is not guaranteed for variables that
 component variables also override upper cased versions where both are
List of CPack RPM generator specific variables:
.. variable:: CPACK_RPM_COMPONENT_INSTALL
.. variable:: CPACK_RPM_PACKAGE_SUMMARY
  Per-component ``CPACK_RPM_<component>_PACKAGE_SUMMARY`` variables.
.. variable:: CPACK_RPM_PACKAGE_NAME
  Per-component ``CPACK_RPM_<component>_PACKAGE_NAME`` variables.
.. variable:: CPACK_RPM_FILE_NAME
 In such cases duplicate file names may occur as a result of this variable
 and it is up to the packager to set the variables in a manner that will
.. variable:: CPACK_RPM_MAIN_COMPONENT
 This variable can be set to any component or group name so that component or
.. variable:: CPACK_RPM_PACKAGE_EPOCH
.. variable:: CPACK_RPM_PACKAGE_VERSION
.. variable:: CPACK_RPM_PACKAGE_ARCHITECTURE
  Per-component ``CPACK_RPM_<component>_PACKAGE_ARCHITECTURE`` variables.
.. variable:: CPACK_RPM_PACKAGE_RELEASE
.. variable:: CPACK_RPM_PACKAGE_RELEASE_DIST
 ``%{dist}`` if RPM macro is not set. If this variable is set then RPM
.. variable:: CPACK_RPM_PACKAGE_LICENSE
.. variable:: CPACK_RPM_PACKAGE_GROUP
  Per-component ``CPACK_RPM_<component>_PACKAGE_GROUP`` variables.
.. variable:: CPACK_RPM_PACKAGE_VENDOR
.. variable:: CPACK_RPM_PACKAGE_URL
  The ``CMAKE_PROJECT_HOMEPAGE_URL`` variable.
.. variable:: CPACK_RPM_PACKAGE_DESCRIPTION
  Per-component ``CPACK_RPM_<component>_PACKAGE_DESCRIPTION`` variables.
.. variable:: CPACK_RPM_COMPRESSION_TYPE
.. variable:: CPACK_RPM_PACKAGE_AUTOREQ
.. variable:: CPACK_RPM_PACKAGE_AUTOPROV
.. variable:: CPACK_RPM_PACKAGE_AUTOREQPROV
.. variable:: CPACK_RPM_PACKAGE_REQUIRES
.. variable:: CPACK_RPM_PACKAGE_CONFLICTS
.. variable:: CPACK_RPM_PACKAGE_REQUIRES_PRE
.. variable:: CPACK_RPM_PACKAGE_REQUIRES_POST
.. variable:: CPACK_RPM_PACKAGE_REQUIRES_POSTUN
.. variable:: CPACK_RPM_PACKAGE_REQUIRES_PREUN
.. variable:: CPACK_RPM_PACKAGE_SUGGESTS
 variable. Note that you must enclose the complete requires string between
.. variable:: CPACK_RPM_PACKAGE_PROVIDES
.. variable:: CPACK_RPM_PACKAGE_OBSOLETES
.. variable:: CPACK_RPM_PACKAGE_RELOCATABLE
 If this variable is set to TRUE or ON, the CPack RPM generator will try
 currently this may fail if :variable:`CPACK_SET_DESTDIR` is set to ``ON``. If
 :variable:`CPACK_SET_DESTDIR` is set then you will get a warning message but
.. variable:: CPACK_RPM_SPEC_INSTALL_POST
.. variable:: CPACK_RPM_SPEC_MORE_DEFINE
.. variable:: CPACK_RPM_PACKAGE_DEBUG
.. variable:: CPACK_RPM_USER_BINARY_SPECFILE
.. variable:: CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE
 :variable:`CPACK_RPM_USER_BINARY_SPECFILE`.
.. variable:: CPACK_RPM_PRE_INSTALL_SCRIPT_FILE
  The ``CPACK_RPM_PRE_TRANS_SCRIPT_FILE`` variable.
.. variable:: CPACK_RPM_POST_INSTALL_SCRIPT_FILE
  The ``CPACK_RPM_POST_TRANS_SCRIPT_FILE`` variable.
.. variable:: CPACK_RPM_USER_FILELIST
.. variable:: CPACK_RPM_CHANGELOG_FILE
.. variable:: CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST
 reasonable set of values if the variable is not defined by the user. If the
 variable is defined by the user then the CPack RPM generator will NOT any of
 can use ``CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION`` variable.
.. variable:: CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
.. variable:: CPACK_RPM_RELOCATION_PATHS
.. variable:: CPACK_RPM_<COMPONENT>_PACKAGE_PREFIX
.. variable:: CPACK_RPM_NO_INSTALL_PREFIX_RELOCATION
.. variable:: CPACK_RPM_ADDITIONAL_MAN_DIRS
.. variable:: CPACK_RPM_DEFAULT_USER
.. variable:: CPACK_RPM_DEFAULT_GROUP
.. variable:: CPACK_RPM_DEFAULT_FILE_PERMISSIONS
.. variable:: CPACK_RPM_DEFAULT_DIR_PERMISSIONS
.. variable:: CPACK_RPM_INSTALL_WITH_EXEC
Debuginfo RPM packaging has its own set of variables:
.. variable:: CPACK_RPM_DEBUGINFO_PACKAGE
 or ``RelWithDebInfo`` for ``CMAKE_BUILD_TYPE`` variable value.
.. variable:: CPACK_BUILD_SOURCE_DIRS
.. variable:: CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX
 variable. This produces ``<CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX>/src_<index>``
 ``CPACK_RPM_BUILD_SOURCE_DIRS_PREFIX`` variable has to be set to
.. variable:: CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS
.. variable:: CPACK_RPM_DEBUGINFO_EXCLUDE_DIRS_ADDITION
.. variable:: CPACK_RPM_DEBUGINFO_SINGLE_PACKAGE
 When this variable is enabled it produces a single debuginfo package even if
 more than one component this variable requires ``CPACK_RPM_MAIN_COMPONENT``
 If none of the ``CPACK_RPM_<component>_DEBUGINFO_PACKAGE`` variables
.. variable:: CPACK_RPM_DEBUGINFO_FILE_NAME
 Setting the variable to ``RPM-DEFAULT`` may be used to explicitly set
 file name - disabled by default but can be enabled by setting the variable to
variable while usually using ``CPACK_INSTALLED_DIRECTORIES`` variable
 variables set by the package manager before starting the process of generating
Source RPM packaging has its own set of variables:
.. variable:: CPACK_RPM_PACKAGE_SOURCES
 For cmake projects ``CPACK_RPM_PACKAGE_SOURCES`` variable is set
.. variable:: CPACK_RPM_SOURCE_PKG_BUILD_PARAMS
.. variable:: CPACK_RPM_SOURCE_PKG_PACKAGING_INSTALL_PREFIX
 variable for producing binary RPM packages.
.. variable:: CPACK_RPM_BUILDREQUIRES
.. variable:: CPACK_RPM_REQUIRES_EXCLUDE_FROM
  Support ``CPACK_COMPONENT_<compName>_DISABLED`` variable.
The following variables are specific to the installers built on
.. variable:: CPACK_WIX_UPGRADE_GUID
 You may for example explicitly set this variable in your
.. variable:: CPACK_WIX_PRODUCT_GUID
.. variable:: CPACK_WIX_LICENSE_RTF
.. variable:: CPACK_WIX_PRODUCT_ICON
.. variable:: CPACK_WIX_UI_REF
 This variable allows you to override the Id of the ``<UIRef>`` element
.. variable:: CPACK_WIX_UI_BANNER
.. variable:: CPACK_WIX_UI_DIALOG
 If this variable is set, the installer will replace the default dialog
.. variable:: CPACK_WIX_PROGRAM_MENU_FOLDER
 If this variable is not set, it will be initialized with CPACK_PACKAGE_NAME
  If this variable is set to ``.``, then application shortcuts will be
.. variable:: CPACK_WIX_CULTURES
.. variable:: CPACK_WIX_TEMPLATE
 If this variable is set, the specified template will be used to generate
 If this variable is not set, the default MSI template included with CMake
.. variable:: CPACK_WIX_PATCH_FILE
 This optional variable can be used to specify an XML file that the
.. variable:: CPACK_WIX_EXTRA_SOURCES
 This variable provides an optional list of extra WiX source files (.wxs)
.. variable:: CPACK_WIX_EXTRA_OBJECTS
 This variable provides an optional list of extra WiX object (.wixobj)
.. variable:: CPACK_WIX_EXTENSIONS
 This variable provides a list of additional extensions for the WiX
.. variable:: CPACK_WIX_<TOOL>_EXTENSIONS
.. variable:: CPACK_WIX_<TOOL>_EXTRA_FLAGS
 This list variable allows you to pass additional
.. variable:: CPACK_WIX_CMAKE_PACKAGE_REGISTRY
 If this variable is set the generated installer will create
 The value for ``<PackageName>`` is provided by this variable.
.. variable:: CPACK_WIX_PROPERTY_<PROPERTY>
 This variable can be used to provide a value for
.. variable:: CPACK_WIX_ROOT_FEATURE_TITLE
.. variable:: CPACK_WIX_ROOT_FEATURE_DESCRIPTION
.. variable:: CPACK_WIX_SKIP_PROGRAM_FOLDER
 If this variable is set to true, the default install location
.. variable:: CPACK_WIX_ROOT_FOLDER_ID
 This variable allows specification of a custom root folder ID.
.. variable:: CPACK_WIX_ROOT
 This variable can optionally be set to the root directory
 installation via the ``WIX`` environment variable instead.
.. variable:: CPACK_WIX_CUSTOM_XMLNS
 This variable provides a list of custom namespace declarations that are necessary
.. variable:: CPACK_WIX_SKIP_WIX_UI_EXTENSION
 If this variable is set then the inclusion of WixUIExtensions is skipped,
.. variable:: CPACK_WIX_ARCHITECTURE
 This variable can be optionally set to specify the target architecture
+ CHECK_RESULT 0
+ actual_result=0
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 0 ']'
+ '[' 0 -eq 0 ']'
+ test 0x '!=' 0x
+ return 0
+ ccmake3 --help-command add_executable
+ grep add_executable
add_executable
 add_executable(<name> [WIN32] [MACOSX_BUNDLE]
  Source arguments to ``add_executable`` may use "generator expressions" with
 add_executable(<name> IMPORTED [GLOBAL])
 add_executable(<name> ALIAS <target>)
+ CHECK_RESULT 0
+ actual_result=0
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 0 ']'
+ '[' 0 -eq 0 ']'
+ test 0x '!=' 0x
+ return 0
+ ccmake3 --help-manual-list
+ grep cmake
ccmake(1)
cmake(1)
cmake-buildsystem(7)
cmake-commands(7)
cmake-compile-features(7)
cmake-developer(7)
cmake-env-variables(7)
cmake-file-api(7)
cmake-generator-expressions(7)
cmake-generators(7)
cmake-gui(1)
cmake-language(7)
cmake-modules(7)
cmake-packages(7)
cmake-policies(7)
cmake-presets(7)
cmake-properties(7)
cmake-qt(7)
cmake-server(7)
cmake-toolchains(7)
cmake-variables(7)
+ CHECK_RESULT 0
+ actual_result=0
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 0 ']'
+ '[' 0 -eq 0 ']'
+ test 0x '!=' 0x
+ return 0
+ '[' 23.03 '!=' 22.03 ']'
+ expect
spawn ccmake3 -B ../buildccmake3 -S ../../common/
Error opening terminal: unknown.
expect: spawn id exp3 not open
    while executing
"expect "*" {send "\r"}"
+ test -d ../buildccmake3/CMakeFiles
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 65'
+ message='oe_test_ccmake3.sh line 65'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 65'
Tue May 30 14:07:31 2023 - ERROR - oe_test_ccmake3.sh line 65
+ '[' 0 -eq 1 ']'
+ return 0
+ test -f ../buildccmake3/CMakeCache.txt -a -f ../buildccmake3/cmake_install.cmake -a -f ../buildccmake3/Makefile
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 67'
+ message='oe_test_ccmake3.sh line 67'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 67'
Tue May 30 14:07:33 2023 - ERROR - oe_test_ccmake3.sh line 67
+ '[' 0 -eq 1 ']'
+ return 0
+ '[' 23.03 '!=' 22.03 ']'
+ expect
spawn ccmake3 -C ../../common/mysettings.cmake ../../common/
Error opening terminal: unknown.
expect: spawn id exp3 not open
    while executing
"expect "*" {send "\r"}"
+ test -d CMakeFiles
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 92'
+ message='oe_test_ccmake3.sh line 92'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 92'
Tue May 30 14:07:36 2023 - ERROR - oe_test_ccmake3.sh line 92
+ '[' 0 -eq 1 ']'
+ return 0
+ test -f cmake_install.cmake -a -f CMakeCache.txt -a -f Makefile
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 94'
+ message='oe_test_ccmake3.sh line 94'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 94'
Tue May 30 14:07:38 2023 - ERROR - oe_test_ccmake3.sh line 94
+ '[' 0 -eq 1 ']'
+ return 0
+ rm -rf './*'
+ '[' 23.03 '!=' 22.03 ']'
+ expect
spawn ccmake3 -DCMAKE_BUILD_TYPE:STRING=RELEASE ../../common/
Error opening terminal: unknown.
expect: spawn id exp3 not open
    while executing
"expect "CMAKE_INSTALL_PREFIX:" {send "c"}"
+ test -d CMakeFiles
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 116'
+ message='oe_test_ccmake3.sh line 116'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 116'
Tue May 30 14:07:42 2023 - ERROR - oe_test_ccmake3.sh line 116
+ '[' 0 -eq 1 ']'
+ return 0
+ test -f cmake_install.cmake -a -f CMakeCache.txt -a -f Makefile
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 118'
+ message='oe_test_ccmake3.sh line 118'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 118'
Tue May 30 14:07:44 2023 - ERROR - oe_test_ccmake3.sh line 118
+ '[' 0 -eq 1 ']'
+ return 0
+ rm -rf './*'
+ '[' 23.03 '!=' 22.03 ']'
+ expect
spawn ccmake3 -UCMAKE_BUILD_TYPE ../../common/
Error opening terminal: unknown.
expect: spawn id exp3 not open
    while executing
"expect "*" {send "c"}"
+ test -d CMakeFiles
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 140'
+ message='oe_test_ccmake3.sh line 140'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 140'
Tue May 30 14:07:47 2023 - ERROR - oe_test_ccmake3.sh line 140
+ '[' 0 -eq 1 ']'
+ return 0
+ test -f cmake_install.cmake -a -f CMakeCache.txt -a -f Makefile
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 142'
+ message='oe_test_ccmake3.sh line 142'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 142'
Tue May 30 14:07:49 2023 - ERROR - oe_test_ccmake3.sh line 142
+ '[' 0 -eq 1 ']'
+ return 0
+ rm -rf './*'
+ '[' 23.03 '!=' 22.03 ']'
+ expect
spawn ccmake3 -G Unix Makefiles ../../common/
Error opening terminal: unknown.
expect: spawn id exp3 not open
    while executing
"expect "*" {send "c"}"
+ test -d CMakeFiles
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 164'
+ message='oe_test_ccmake3.sh line 164'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 164'
Tue May 30 14:07:52 2023 - ERROR - oe_test_ccmake3.sh line 164
+ '[' 0 -eq 1 ']'
+ return 0
+ test -f cmake_install.cmake -a -f CMakeCache.txt -a -f Makefile
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 166'
+ message='oe_test_ccmake3.sh line 166'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 166'
Tue May 30 14:07:54 2023 - ERROR - oe_test_ccmake3.sh line 166
+ '[' 0 -eq 1 ']'
+ return 0
+ rm -rf './*'
+ '[' 23.03 '!=' 22.03 ']'
+ expect
spawn ccmake3 -G Ninja ../../common/
Error opening terminal: unknown.
expect: spawn id exp3 not open
    while executing
"expect "*" {send "c"}"
+ test -d CMakeFiles
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 188'
+ message='oe_test_ccmake3.sh line 188'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 188'
Tue May 30 14:07:58 2023 - ERROR - oe_test_ccmake3.sh line 188
+ '[' 0 -eq 1 ']'
+ return 0
+ test -f cmake_install.cmake -a -f CMakeCache.txt -a -f build.ninja
+ CHECK_RESULT 1
+ actual_result=1
+ expect_result=0
+ mode=0
+ error_log=
+ exit_mode=0
+ '[' -z 1 ']'
+ '[' 0 -eq 0 ']'
+ test 1x '!=' 0x
+ test -n ''
+ (( exec_result++ ))
+ LOG_ERROR 'oe_test_ccmake3.sh line 190'
+ message='oe_test_ccmake3.sh line 190'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'oe_test_ccmake3.sh line 190'
Tue May 30 14:08:00 2023 - ERROR - oe_test_ccmake3.sh line 190
+ '[' 0 -eq 1 ']'
+ return 0
+ LOG_INFO 'End of the test.'
+ message='End of the test.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level info --message 'End of the test.'
Tue May 30 14:08:02 2023 - INFO  - End of the test.
+ CASE_RESULT 0
+ case_re=0
+ test -z 12
+ test 12 -gt 0
+ LOG_ERROR 'failed to execute the case.'
+ message='failed to execute the case.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level error --message 'failed to execute the case.'
Tue May 30 14:08:04 2023 - ERROR - failed to execute the case.
+ exit 12
+ post_test
+ LOG_INFO 'Start to restore the test environment.'
+ message='Start to restore the test environment.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level info --message 'Start to restore the test environment.'
Tue May 30 14:08:06 2023 - INFO  - Start to restore the test environment.
+ clear_env
+++ dirname oe_test_ccmake3.sh
++ cd .
++ pwd
+ currentDir=/root/mugen/testcases/cli-test/cmake/oe_test_ccmake3/build
++ echo /root/mugen/testcases/cli-test/cmake/oe_test_ccmake3/build
++ awk -F / '{print $NF}'
+ currentName=build
+ test buildx = buildx
+ cd ..
++ ls
++ grep -vE '\.sh|\.c|\.cpp|\.txt'
+ roc=build
+ rm -rf build
+ DNF_REMOVE
+ node=1
+ pkg_list=
+ mode=0
+ [[ -z /tmp/tmpqudw8loi ]]
+ '[' 0 -ne 0 ']'
+ '[' 1 == 0 ']'
+ python3 /root/mugen/libs/locallibs/rpm_manage.py remove --node 1 --pkgs '' --tempfile /tmp/tmpqudw8loi
+ '[' 0 -ne 0 ']'
+ LOG_INFO 'Finish restoring the test environment.'
+ message='Finish restoring the test environment.'
+ python3 /root/mugen/libs/locallibs/mugen_log.py --level info --message 'Finish restoring the test environment.'
Tue May 30 14:09:03 2023 - INFO  - Finish restoring the test environment.