Source/cmCacheDocumentationTable.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

// Built-in cache variable documentation table.
//
// This file is hand-maintained.  Each entry's Summary is a one-line tooltip
// installed as the ``HELPSTRING`` of cache variables created via
// ``cmake -D <var>=<value>`` when the user did not supply one.
//
// Membership policy: this table is deliberately limited to variables that a
// user would plausibly set on the ``cmake`` command line when configuring a
// project.
//
// Maintenance discipline:
//   * Adding a new user-facing variable: hand-write one entry below in
//     ASCII sort order and make sure the corresponding
//     Help/variable/<NAME>.rst exists.
//   * Significantly rewording a Help/variable/<NAME>.rst that has an entry
//     here: review and update the corresponding Summary in the same change
//     so the tooltip and the manual stay in step.  CMake reviewers should
//     look for this co-evolution.
//   * Structural drift (typo in NAME, RST renamed or removed) is caught by
//     Tests/RunCMake/CacheVarHelpCoverage, which asserts that every entry
//     in this table has a matching Help/variable/<NAME>.rst.
//
// The Entry layout below (two lines per row, ``{ "NAME",\n    "summary" },``)
// is intentional: it keeps the table easy to diff, review, and hand-edit
// against the corresponding Help/variable/*.rst manuals.  clang-format is
// suppressed across the array so contributors can update one Summary
// without the formatter reflowing every neighbor.

#include "cmCacheDocumentationTable.h"

#include <algorithm>
#include <cstddef>
#include <iterator>
#include <string>

#include <cm/string_view>
#include <cmext/string_view>

#include "cmCachePatternTable.h"

namespace {

using cmCacheDocumentationTable::Entry;

// The entries are sorted by Name in ASCII order so that std::lower_bound
// can locate a variable in O(log N) time without any runtime indexing
// structure.  The testCacheDocumentationTable regression test in
// Tests/CMakeLib verifies this invariant.
/* clang-format off */
Entry const kEntries[] = {
  { "BUILD_SHARED_LIBS"_s,
    "Global default for the library type used by add_library() when no STATIC/SHARED keyword is given: SHARED if true, STATIC otherwise. Not defined by CMake itself; commonly exposed as an option() by projects."_s },
  { "BUILD_TESTING"_s,
    "Control whether the CTest module invokes enable_testing()"_s },
  { "CMAKE_ADD_CUSTOM_COMMAND_DEPENDS_EXPLICIT_ONLY"_s,
    "Enable DEPENDS_EXPLICIT_ONLY option by default for add_custom_command()"_s },
  { "CMAKE_ADSP_ROOT"_s,
    "When cross-compiling for ADSP SHARC/Blackfin, this variable holds the absolute path to the root install directory of the CCES or VDSP++ toolchain."_s },
  { "CMAKE_AIX_EXPORT_ALL_SYMBOLS"_s,
    "Default value for AIX_EXPORT_ALL_SYMBOLS target property"_s },
  { "CMAKE_AIX_SHARED_LIBRARY_ARCHIVE"_s,
    "Enable or disable creation of shared library archives"_s },
  { "CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS"_s,
    "Default value for ANDROID_ANT_ADDITIONAL_OPTIONS target property"_s },
  { "CMAKE_ANDROID_API"_s,
    "When cross-compiling for Android with NVIDIA Nsight Tegra Visual Studio Edition, sets the default for the ANDROID_API target property. In other Android builds, initializes CMAKE_SYSTEM_VERSION if not already set."_s },
  { "CMAKE_ANDROID_API_MIN"_s,
    "Default minimum Android API level for targets"_s },
  { "CMAKE_ANDROID_ARCH"_s,
    "When cross-compiling for Android with NVIDIA Nsight Tegra Visual Studio Edition, sets the default for the ANDROID_ARCH target property. Otherwise, the architecture name (arm, arm64, x86, x86_64) corresponding to CMAKE_ANDROID_ARCH_ABI."_s },
  { "CMAKE_ANDROID_ARCH_ABI"_s,
    "When cross-compiling for Android, this variable specifies the target architecture and ABI (arm64-v8a, armeabi-v7a, x86, x86_64, etc.)."_s },
  { "CMAKE_ANDROID_ARM_MODE"_s,
    "When cross-compiling for Android with armeabi architecture, set to ON to target 32-bit ARM (-marm) instead of the default 16-bit Thumb."_s },
  { "CMAKE_ANDROID_ARM_NEON"_s,
    "When Cross Compiling for Android and CMAKE_ANDROID_ARCH_ABI is set to armeabi-v7a set CMAKE_ANDROID_ARM_NEON to ON to target ARM NEON devices."_s },
  { "CMAKE_ANDROID_ASSETS_DIRECTORIES"_s,
    "Default value for ANDROID_ASSETS_DIRECTORIES target property"_s },
  { "CMAKE_ANDROID_EXCEPTIONS"_s,
    "Specify whether C++ exceptions are enabled in Android NDK builds"_s },
  { "CMAKE_ANDROID_GUI"_s,
    "Default value for ANDROID_GUI target property of executables"_s },
  { "CMAKE_ANDROID_JAR_DEPENDENCIES"_s,
    "Default value for ANDROID_JAR_DEPENDENCIES target property"_s },
  { "CMAKE_ANDROID_JAR_DIRECTORIES"_s,
    "Default value for ANDROID_JAR_DIRECTORIES target property"_s },
  { "CMAKE_ANDROID_JAVA_SOURCE_DIR"_s,
    "Default value for ANDROID_JAVA_SOURCE_DIR target property"_s },
  { "CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES"_s,
    "Default value for ANDROID_NATIVE_LIB_DEPENDENCIES target property"_s },
  { "CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES"_s,
    "Default value for ANDROID_NATIVE_LIB_DIRECTORIES target property"_s },
  { "CMAKE_ANDROID_NDK"_s,
    "When Cross Compiling for Android with the NDK, this variable holds the absolute path to the root directory of the NDK. The directory must contain a platforms subdirectory holding the android-<api> directories."_s },
  { "CMAKE_ANDROID_NDK_DEPRECATED_HEADERS"_s,
    "When cross-compiling for Android with the NDK, specify whether to use deprecated per-api-level headers instead of the unified headers."_s },
  { "CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION"_s,
    "When cross-compiling for Android with the NDK, specify the toolchain version (clang on r19+, or GCC/Clang version on r18-); default selects latest available GCC."_s },
  { "CMAKE_ANDROID_PROCESS_MAX"_s,
    "Default value for ANDROID_PROCESS_MAX target property"_s },
  { "CMAKE_ANDROID_PROGUARD"_s,
    "Default value for ANDROID_PROGUARD target property"_s },
  { "CMAKE_ANDROID_PROGUARD_CONFIG_PATH"_s,
    "Default value for ProGuard config file location on Android targets"_s },
  { "CMAKE_ANDROID_RTTI"_s,
    "Enable RTTI for Android NDK cross compilation"_s },
  { "CMAKE_ANDROID_SECURE_PROPS_PATH"_s,
    "Default value for Android secure properties file location"_s },
  { "CMAKE_ANDROID_SKIP_ANT_STEP"_s,
    "Default value for skipping Ant build step for Android targets"_s },
  { "CMAKE_ANDROID_STANDALONE_TOOLCHAIN"_s,
    "When Cross Compiling for Android with a Standalone Toolchain, this variable holds the absolute path to the root directory of the toolchain. The specified directory must contain a sysroot subdirectory."_s },
  { "CMAKE_ANDROID_STL_TYPE"_s,
    "For Android with Tegra, sets default ANDROID_STL_TYPE target property; for NDK, selects STL variant (none, system, gabi++, gnustl, c++, stlport); default is gnustl_static or c++_static."_s },
  { "CMAKE_APPBUNDLE_PATH"_s,
    "Search path for macOS application bundles used by find_program() and find_package()"_s },
  { "CMAKE_APPLE_SILICON_PROCESSOR"_s,
    "On Apple Silicon macOS hosts, set to arm64 or x86_64 to specify CMAKE_HOST_SYSTEM_PROCESSOR; user cache entry only, never modified by project code."_s },
  { "CMAKE_ARCHIVE_OUTPUT_DIRECTORY"_s,
    "Default output directory for archive target files"_s },
  { "CMAKE_AUTOGEN_BETTER_GRAPH_MULTI_CONFIG"_s,
    "Enable better dependency graph for multi-config autogen targets"_s },
  { "CMAKE_AUTOGEN_COMMAND_LINE_LENGTH_MAX"_s,
    "Limit for autogen command line length triggering response file use on Windows"_s },
  { "CMAKE_AUTOGEN_INTERMEDIATE_DIR_STRATEGY"_s,
    "Strategy for autogen intermediate directories: FULL (pattern-based) or SHORT (hash-based)"_s },
  { "CMAKE_AUTOGEN_ORIGIN_DEPENDS"_s,
    "Forward origin target dependencies to autogen targets"_s },
  { "CMAKE_AUTOGEN_PARALLEL"_s,
    "Number of parallel moc/uic processes for autogen targets"_s },
  { "CMAKE_AUTOGEN_USE_SYSTEM_INCLUDE"_s,
    "Add autogen include directory as system include to targets"_s },
  { "CMAKE_AUTOGEN_VERBOSE"_s,
    "Sets verbosity of AUTOMOC/AUTOUIC/AUTORCC generators; positive integer or true boolean enables extra output."_s },
  { "CMAKE_AUTOMOC"_s,
    "Whether to handle Qt moc automatically for targets"_s },
  { "CMAKE_AUTOMOC_COMPILER_PREDEFINES"_s,
    "Whether to generate compiler predefines for moc"_s },
  { "CMAKE_AUTOMOC_DEPEND_FILTERS"_s,
    "Filter definitions for extracting additional dependencies for moc"_s },
  { "CMAKE_AUTOMOC_EXECUTABLE"_s,
    "Path to moc executable for AUTOMOC"_s },
  { "CMAKE_AUTOMOC_INCLUDE_DIRECTORIES"_s,
    "Include directories for AUTOMOC to pass to moc."_s },
  { "CMAKE_AUTOMOC_MACRO_NAMES"_s,
    "Macro names used by AUTOMOC to determine if a file needs moc processing."_s },
  { "CMAKE_AUTOMOC_MOC_OPTIONS"_s,
    "Additional options for moc when using CMAKE_AUTOMOC."_s },
  { "CMAKE_AUTOMOC_PATH_PREFIX"_s,
    "Generate -p path prefix option for moc on AUTOMOC targets."_s },
  { "CMAKE_AUTORCC"_s,
    "Whether to handle rcc automatically for Qt targets."_s },
  { "CMAKE_AUTORCC_EXECUTABLE"_s,
    "Custom rcc executable path for AUTORCC."_s },
  { "CMAKE_AUTORCC_OPTIONS"_s,
    "Additional options for rcc when using CMAKE_AUTORCC."_s },
  { "CMAKE_AUTOUIC"_s,
    "Whether to handle uic automatically for Qt targets."_s },
  { "CMAKE_AUTOUIC_EXECUTABLE"_s,
    "Custom uic executable path for AUTOUIC."_s },
  { "CMAKE_AUTOUIC_OPTIONS"_s,
    "Additional options for uic when using CMAKE_AUTOUIC."_s },
  { "CMAKE_AUTOUIC_SEARCH_PATHS"_s,
    "Search paths for AUTOUIC to find included .ui files."_s },
  { "CMAKE_BUILD_RPATH"_s,
    "Runtime path (RPATH) entries to add to binaries in the build tree."_s },
  { "CMAKE_BUILD_RPATH_USE_ORIGIN"_s,
    "Whether to use relative paths for the build RPATH."_s },
  { "CMAKE_BUILD_TYPE"_s,
    "Build type for single-configuration generators (Makefile Generators, Ninja, etc.). Typical values: Debug, Release, RelWithDebInfo, MinSizeRel; custom build types may also be defined."_s },
  { "CMAKE_BUILD_WITH_INSTALL_NAME_DIR"_s,
    "Whether to use INSTALL_NAME_DIR on targets in the build tree."_s },
  { "CMAKE_BUILD_WITH_INSTALL_RPATH"_s,
    "Build with install RPATH instead of requiring relinking."_s },
  { "CMAKE_CLANG_VFS_OVERLAY"_s,
    "Absolute path to clang virtual file system YAML file for Windows clang-cl cross-compilation"_s },
  { "CMAKE_CODEBLOCKS_COMPILER_ID"_s,
    "Compiler ID in generated CodeBlocks project files; auto-detected if empty"_s },
  { "CMAKE_CODEBLOCKS_EXCLUDE_EXTERNAL_FILES"_s,
    "Exclude files outside project root from CodeBlocks project files"_s },
  { "CMAKE_CODELITE_USE_TARGETS"_s,
    "Generate CodeLite project files based on targets rather than projects"_s },
  { "CMAKE_COLOR_DIAGNOSTICS"_s,
    "Enable color diagnostics in compiler and build system output"_s },
  { "CMAKE_COLOR_MAKEFILE"_s,
    "Enable color output when using Makefile generators"_s },
  { "CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY"_s,
    "Directory for compiler-generated .pdb debug symbol files"_s },
  { "CMAKE_COMPILE_WARNING_AS_ERROR"_s,
    "Specify whether to treat warnings on compile as errors. This variable is used to initialize the COMPILE_WARNING_AS_ERROR property on all the targets."_s },
  { "CMAKE_CONFIGURATION_TYPES"_s,
    "Semicolon-separated list of available build types for multi-config generators (Visual Studio, Xcode, Ninja Multi-Config). Typical entries: Debug, Release, RelWithDebInfo, MinSizeRel; custom entries may also be defined."_s },
  { "CMAKE_CROSSCOMPILING"_s,
    "Set to true by CMake when cross compiling (if CMAKE_SYSTEM_NAME is manually set). Not recommended for Apple device builds due to SDK-based target selection."_s },
  { "CMAKE_CROSS_CONFIGS"_s,
    "Semicolon-separated list of configurations for Ninja Multi-Config cross-config mode"_s },
  { "CMAKE_CTEST_ARGUMENTS"_s,
    "Command-line arguments to pass to ctest when running tests"_s },
  { "CMAKE_CUDA_ARCHITECTURES"_s,
    "Default GPU architectures for CUDA compilation"_s },
  { "CMAKE_CUDA_EXTENSIONS"_s,
    "Default value for CUDA_EXTENSIONS target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_CUDA_RESOLVE_DEVICE_SYMBOLS"_s,
    "Default value for CUDA_RESOLVE_DEVICE_SYMBOLS target property"_s },
  { "CMAKE_CUDA_RUNTIME_LIBRARY"_s,
    "Select CUDA runtime library for compiling and linking CUDA code"_s },
  { "CMAKE_CUDA_SEPARABLE_COMPILATION"_s,
    "Default value for CUDA_SEPARABLE_COMPILATION target property"_s },
  { "CMAKE_CUDA_STANDARD"_s,
    "Default value for CUDA_STANDARD target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_CUDA_STANDARD_REQUIRED"_s,
    "Default value for CUDA_STANDARD_REQUIRED target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_CXX_EXTENSIONS"_s,
    "Default value for CXX_EXTENSIONS target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_CXX_MODULE_STD"_s,
    "Whether to add utility targets as dependencies for C++23 targets"_s },
  { "CMAKE_CXX_SCAN_FOR_MODULES"_s,
    "Whether to scan C++ source files for module dependencies"_s },
  { "CMAKE_CXX_STANDARD"_s,
    "Default value used to initialize the CXX_STANDARD target property when a target is created. See the cmake-compile-features(7) manual for the list of supported standards and compilers."_s },
  { "CMAKE_CXX_STANDARD_REQUIRED"_s,
    "Default value for CXX_STANDARD_REQUIRED target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_C_EXTENSIONS"_s,
    "Default value for C_EXTENSIONS target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_C_STANDARD"_s,
    "Default value used to initialize the C_STANDARD target property when a target is created. See the cmake-compile-features(7) manual for the list of supported standards and compilers."_s },
  { "CMAKE_C_STANDARD_REQUIRED"_s,
    "Default value for C_STANDARD_REQUIRED target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_DEBUGGER_WORKING_DIRECTORY"_s,
    "Working directory for debugger when launching targets"_s },
  { "CMAKE_DEBUG_TARGET_PROPERTIES"_s,
    "Enables debug output for target properties by listing which properties to trace when evaluating targets."_s },
  { "CMAKE_DEFAULT_BUILD_TYPE"_s,
    "Default configuration to use in build.ninja for Ninja Multi-Config"_s },
  { "CMAKE_DEFAULT_CONFIGS"_s,
    "Default configurations to build for targets without :Config suffix"_s },
  { "CMAKE_DEPENDS_IN_PROJECT_ONLY"_s,
    "Only consider dependencies within project source and binary directories"_s },
  { "CMAKE_DEPENDS_USE_COMPILER"_s,
    "Set FALSE to use CMake for dependency discovery instead of compiler"_s },
  { "CMAKE_DISABLE_PRECOMPILE_HEADERS"_s,
    "Default value for disabling precompiled headers on all targets"_s },
  { "CMAKE_DLL_NAME_WITH_SOVERSION"_s,
    "Whether to include soversion in DLL names on Windows platform"_s },
  { "CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES"_s,
    "Generate linked resources in Eclipse project generator output"_s },
  { "CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT"_s,
    "Generate Eclipse project in source directory for version control integration"_s },
  { "CMAKE_ECLIPSE_RESOURCE_ENCODING"_s,
    "Set the resource encoding in Eclipse CDT4 project generator."_s },
  { "CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION"_s,
    "Error when cmake_install.cmake encounters absolute INSTALL DESTINATION."_s },
  { "CMAKE_EXECUTABLE_ENABLE_EXPORTS"_s,
    "Specify whether executables export symbols for loadable modules"_s },
  { "CMAKE_EXECUTE_PROCESS_COMMAND_ECHO"_s,
    "Print commands in execute_process() calls to STDERR, STDOUT, or NONE."_s },
  { "CMAKE_EXECUTE_PROCESS_COMMAND_ERROR_IS_FATAL"_s,
    "Default for execute_process() COMMAND_ERROR_IS_FATAL option."_s },
  { "CMAKE_EXE_LINKER_FLAGS"_s,
    "Linker flags to be used to create executables"_s },
  { "CMAKE_EXPORT_BUILD_DATABASE"_s,
    "Experimental; gated by CMAKE_EXPERIMENTAL_EXPORT_BUILD_DATABASE. Enables build_database.json with C++ module compile commands."_s },
  { "CMAKE_EXPORT_COMPILE_COMMANDS"_s,
    "Enable output of a compile_commands.json file listing the exact compiler invocation for each translation unit. Implemented by the Makefile and Ninja generators; ignored elsewhere."_s },
  { "CMAKE_EXPORT_NO_PACKAGE_REGISTRY"_s,
    "Disable the export(PACKAGE) command from writing to the user package registry when CMP0090 is not set to NEW."_s },
  { "CMAKE_EXPORT_PACKAGE_REGISTRY"_s,
    "Enable the export(PACKAGE) command to write to the user package registry when CMP0090 is set to NEW."_s },
  { "CMAKE_EXPORT_SARIF"_s,
    "Enable CMake diagnostics output in SARIF format, written to .cmake/sarif/cmake.sarif by default or to path specified by cmake --sarif-output."_s },
  { "CMAKE_FIND_APPBUNDLE"_s,
    "Control how find_*() commands select macOS Application Bundles."_s },
  { "CMAKE_FIND_DEBUG_MODE"_s,
    "Print debug information for find_program, find_library, find_file, find_path, and find_package to stderr. Output is human-readable, not machine-parseable."_s },
  { "CMAKE_FIND_FRAMEWORK"_s,
    "Control how find_*() commands select macOS Frameworks."_s },
  { "CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX"_s,
    "Suffix to search in lib<suffix> directories before lib in find_library()."_s },
  { "CMAKE_FIND_NO_INSTALL_PREFIX"_s,
    "Exclude CMAKE_INSTALL_PREFIX from CMAKE_SYSTEM_PREFIX_PATH."_s },
  { "CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY"_s,
    "DEPRECATED: Use CMAKE_FIND_USE_PACKAGE_REGISTRY instead. When unset, find_package uses User Package Registry unless disabled. Ignored if CMAKE_FIND_USE_PACKAGE_REGISTRY is set."_s },
  { "CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY"_s,
    "DEPRECATED: Use CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY instead. When unset, find_package uses System Package Registry unless disabled. Ignored if CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY is set."_s },
  { "CMAKE_FIND_PACKAGE_PREFER_CONFIG"_s,
    "Prefer find_package() Config mode over Module mode."_s },
  { "CMAKE_FIND_PACKAGE_RESOLVE_SYMLINKS"_s,
    "Resolve symbolic links in <PackageName>_DIR during find_package() lookups."_s },
  { "CMAKE_FIND_PACKAGE_TARGETS_GLOBAL"_s,
    "Promote IMPORTED targets found by find_package() to GLOBAL scope."_s },
  { "CMAKE_FIND_PACKAGE_WARN_NO_MODULE"_s,
    "Warn when find_package() implicitly assumes Config mode."_s },
  { "CMAKE_FIND_ROOT_PATH"_s,
    "Semicolon-separated list of alternative filesystem roots searched by find_package(), find_library(), and the other find_*() commands. Most useful when cross-compiling."_s },
  { "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE"_s,
    "Control whether CMAKE_FIND_ROOT_PATH is used by find_file/find_path"_s },
  { "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY"_s,
    "Control whether CMAKE_FIND_ROOT_PATH is used by find_library"_s },
  { "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE"_s,
    "Control whether CMAKE_FIND_ROOT_PATH is used by find_package"_s },
  { "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM"_s,
    "Control whether CMAKE_FIND_ROOT_PATH is used by find_program"_s },
  { "CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH"_s,
    "Controls whether find commands search cmake-specific environment variables"_s },
  { "CMAKE_FIND_USE_CMAKE_PATH"_s,
    "Controls whether find commands search cmake-specific cache variables"_s },
  { "CMAKE_FIND_USE_CMAKE_SYSTEM_PATH"_s,
    "Controls whether find commands search platform-specific cmake variables"_s },
  { "CMAKE_FIND_USE_INSTALL_PREFIX"_s,
    "Controls whether find commands search CMAKE_INSTALL_PREFIX locations"_s },
  { "CMAKE_FIND_USE_PACKAGE_REGISTRY"_s,
    "Controls whether find_package searches the User Package Registry; takes precedence over the deprecated CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY variable."_s },
  { "CMAKE_FIND_USE_PACKAGE_ROOT_PATH"_s,
    "Controls whether find commands search <PackageName>_ROOT variables"_s },
  { "CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH"_s,
    "Controls whether find commands search system environment variables"_s },
  { "CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY"_s,
    "Controls whether find_package searches the System Package Registry"_s },
  { "CMAKE_FOLDER"_s,
    "Set the folder name to organize targets in an IDE"_s },
  { "CMAKE_FRAMEWORK"_s,
    "Default value for FRAMEWORK target property"_s },
  { "CMAKE_FRAMEWORK_PATH"_s,
    "Semicolon-separated list of directories for macOS framework search path"_s },
  { "CMAKE_Fortran_FORMAT"_s,
    "Set to FIXED or FREE to indicate the Fortran source layout"_s },
  { "CMAKE_Fortran_MODULE_DIRECTORY"_s,
    "Fortran module output directory"_s },
  { "CMAKE_Fortran_PREPROCESS"_s,
    "Default value for Fortran_PREPROCESS target property"_s },
  { "CMAKE_GENERATOR_PLATFORM"_s,
    "Generator-specific target-platform name (set via cmake -A, cmake-gui, or the CMAKE_GENERATOR_PLATFORM environment variable). Used by Visual Studio and Green Hills MULTI; ignored by other generators. Not to be modified by project code."_s },
  { "CMAKE_GENERATOR_TOOLSET"_s,
    "Native-build-system toolset specification (set via cmake -T, cmake-gui, or the CMAKE_GENERATOR_TOOLSET environment variable). Used by Visual Studio, Xcode, and Green Hills MULTI; ignored by other generators. Not to be modified by project code."_s },
  { "CMAKE_GHS_NO_SOURCE_GROUP_FILE"_s,
    "ON/OFF boolean to control if project file for target is single or multiple"_s },
  { "CMAKE_GLOBAL_AUTOGEN_TARGET"_s,
    "Switch to enable generation of a global autogen target"_s },
  { "CMAKE_GLOBAL_AUTOGEN_TARGET_NAME"_s,
    "Change the name of the global autogen target"_s },
  { "CMAKE_GLOBAL_AUTORCC_TARGET"_s,
    "Switch to enable generation of a global autorcc target"_s },
  { "CMAKE_GLOBAL_AUTORCC_TARGET_NAME"_s,
    "Change the name of the global autorcc target"_s },
  { "CMAKE_GNUtoMS"_s,
    "Convert GNU import libraries (.dll.a) to MS format (.lib)"_s },
  { "CMAKE_HIP_ARCHITECTURES"_s,
    "List of GPU architectures for HIP device code generation; interpreted per CMAKE_HIP_PLATFORM"_s },
  { "CMAKE_HIP_EXTENSIONS"_s,
    "Default value for HIP_EXTENSIONS target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_HIP_PLATFORM"_s,
    "GPU platform for HIP targets (amd, nvidia, or spirv)"_s },
  { "CMAKE_HIP_STANDARD"_s,
    "Default value for HIP_STANDARD target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_HIP_STANDARD_REQUIRED"_s,
    "Default value for HIP_STANDARD_REQUIRED target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_IGNORE_PATH"_s,
    "Semicolon-separated list of directories to ignore in find commands"_s },
  { "CMAKE_IGNORE_PREFIX_PATH"_s,
    "Semicolon-separated list of search prefixes to ignore in find commands"_s },
  { "CMAKE_INCLUDE_CURRENT_DIR"_s,
    "Automatically add CMAKE_CURRENT_SOURCE_DIR and CMAKE_CURRENT_BINARY_DIR to include path. Does not propagate to subdirectories. Defaults to OFF."_s },
  { "CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE"_s,
    "Automatically add CMAKE_CURRENT_SOURCE_DIR and CMAKE_CURRENT_BINARY_DIR to INTERFACE_INCLUDE_DIRECTORIES for libraries and executables. Defaults to OFF."_s },
  { "CMAKE_INCLUDE_DIRECTORIES_BEFORE"_s,
    "When ON, include_directories prepends instead of appending directories"_s },
  { "CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE"_s,
    "Force project include directories to appear first in compiler command lines"_s },
  { "CMAKE_INCLUDE_PATH"_s,
    "Semicolon-separated search path for find_file and find_path commands"_s },
  { "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"_s,
    "Default component name for install commands when COMPONENT argument is omitted"_s },
  { "CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS"_s,
    "Default permissions for directories created implicitly during installation"_s },
  { "CMAKE_INSTALL_EXPORTS_AS_PACKAGE_INFO"_s,
    "Experimental feature (requires CMAKE_EXPERIMENTAL_FIXME gate): directives to install package information when exported target info is installed via install(EXPORT)."_s },
  { "CMAKE_INSTALL_MESSAGE"_s,
    "Verbosity of installation messages: ALWAYS (default, shows Installing and Up-to-date), LAZY (only Installing), or NEVER (silent)."_s },
  { "CMAKE_INSTALL_NAME_DIR"_s,
    "Directory name for installed targets on Apple platforms"_s },
  { "CMAKE_INSTALL_OBJECT_NAME_STRATEGY"_s,
    "Strategy to use for naming installed object files"_s },
  { "CMAKE_INSTALL_OBJECT_ONLY_USE_DESTINATION"_s,
    "Controls whether install DESTINATION for object libraries uses subdirectories"_s },
  { "CMAKE_INSTALL_PREFIX"_s,
    "Install directory prepended to all install() destinations. Defaults to c:/Program Files/${PROJECT_NAME} on Windows and /usr/local on UNIX; may be overridden at install time via cmake --install --prefix."_s },
  { "CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH"_s,
    "Boolean controlling whether toolchain-defined rpaths are removed during install"_s },
  { "CMAKE_INSTALL_RPATH"_s,
    "Semicolon-separated list specifying rpath to use in installed targets"_s },
  { "CMAKE_INSTALL_RPATH_USE_LINK_PATH"_s,
    "If TRUE, append linker search and installed library paths to installed rpath"_s },
  { "CMAKE_INTERMEDIATE_DIR_STRATEGY"_s,
    "CMAKE_INTERMEDIATE_DIR_STRATEGY is a string cache variable specifying the strategy to use for target intermediate directories and their contents. The supported values are:"_s },
  { "CMAKE_INTERPROCEDURAL_OPTIMIZATION"_s,
    "Default value for INTERPROCEDURAL_OPTIMIZATION of targets"_s },
  { "CMAKE_IOS_INSTALL_COMBINED"_s,
    "This is deprecated. Default value for IOS_INSTALL_COMBINED of targets. This variable is used to initialize the IOS_INSTALL_COMBINED property on all the targets."_s },
  { "CMAKE_ISPC_HEADER_DIRECTORY"_s,
    "Default output directory for ISPC-generated headers"_s },
  { "CMAKE_ISPC_HEADER_SUFFIX"_s,
    "Output suffix for ISPC-generated headers"_s },
  { "CMAKE_ISPC_INSTRUCTION_SETS"_s,
    "Default instruction sets for ISPC compilation"_s },
  { "CMAKE_KATE_FILES_MODE"_s,
    "Kate project generator file mode (AUTO, SVN, GIT, HG, FOSSIL, or LIST)"_s },
  { "CMAKE_KATE_MAKE_ARGUMENTS"_s,
    "Arguments passed to make tool when Kate invokes build"_s },
  { "CMAKE_LIBRARY_OUTPUT_DIRECTORY"_s,
    "Where to put all LIBRARY target files when built"_s },
  { "CMAKE_LIBRARY_PATH"_s,
    "Semicolon-separated search path for find_library command"_s },
  { "CMAKE_LINKER_TYPE"_s,
    "Specify which linker to use for link steps; initialized on targets and used by try_compile()."_s },
  { "CMAKE_LINK_DEPENDS_NO_SHARED"_s,
    "Whether to skip link dependencies on shared library files"_s },
  { "CMAKE_LINK_DEPENDS_USE_LINKER"_s,
    "For Makefile/Ninja generators, whether linker generates link dependencies"_s },
  { "CMAKE_LINK_DIRECTORIES_BEFORE"_s,
    "Prepend directories by default in link_directories instead of appending"_s },
  { "CMAKE_LINK_INTERFACE_LIBRARIES"_s,
    "Default value for LINK_INTERFACE_LIBRARIES of targets"_s },
  { "CMAKE_LINK_LIBRARIES_ONLY_TARGETS"_s,
    "Enable check that all target-like items in target_link_libraries() are existing targets."_s },
  { "CMAKE_LINK_LIBRARIES_STRATEGY"_s,
    "Specify a strategy for ordering targets' link dependencies on linker command lines."_s },
  { "CMAKE_LINK_SEARCH_END_STATIC"_s,
    "End link line with static system libraries; use -Bstatic with compatible linkers."_s },
  { "CMAKE_LINK_SEARCH_START_STATIC"_s,
    "Assume linker looks for static libraries by default; use -Bstatic with compatible linkers."_s },
  { "CMAKE_LINK_WARNING_AS_ERROR"_s,
    "Specify whether to treat warnings on link as errors. This variable is used to initialize the LINK_WARNING_AS_ERROR property on all the targets."_s },
  { "CMAKE_LINK_WHAT_YOU_USE"_s,
    "Default value for LINK_WHAT_YOU_USE target property"_s },
  { "CMAKE_MACOSX_BUNDLE"_s,
    "Default value for MACOSX_BUNDLE target property"_s },
  { "CMAKE_MACOSX_RPATH"_s,
    "Whether to use rpaths on macOS and iOS"_s },
  { "CMAKE_MAKE_PROGRAM"_s,
    "Tool that can launch the native build system. The value may be the full path to an executable or just the tool name if it is expected to be in the PATH. The tool selected depends on the CMAKE_GENERATOR used to configure the project:"_s },
  { "CMAKE_MAXIMUM_RECURSION_DEPTH"_s,
    "Maximum recursion depth for CMake scripts"_s },
  { "CMAKE_MESSAGE_CONTEXT"_s,
    "List of context names prepended to message output when logging context enabled"_s },
  { "CMAKE_MESSAGE_CONTEXT_SHOW"_s,
    "Setting this variable to true enables showing a context with each line logged by message command (see CMAKE_MESSAGE_CONTEXT for how context is specified), as an alternative to cmake --log-context option."_s },
  { "CMAKE_MESSAGE_INDENT"_s,
    "Indentation strings prepended to message command output for NOTICE and below"_s },
  { "CMAKE_MESSAGE_LOG_LEVEL"_s,
    "When set, specifies the logging level used by message command with values same as cmake(1) --log-level option; command line option takes precedence if both are set."_s },
  { "CMAKE_MFC_FLAG"_s,
    "Use the MFC library for an executable or dll; enables Microsoft Foundation Classes (MFC); set to 1 for static library, 2 for shared; used in Visual Studio project files."_s },
  { "CMAKE_MODULE_LINKER_FLAGS"_s,
    "Linker flags to be used to create modules"_s },
  { "CMAKE_MODULE_PATH"_s,
    "Semicolon-separated list of directories searched for CMake modules by include() and find_package() before the modules shipped with CMake. Empty by default."_s },
  { "CMAKE_MSVCIDE_RUN_PATH"_s,
    "Extra PATH locations for executing add_custom_command or add_custom_target with Visual Studio Generators; allows running commands and dlls the IDE doesn't know about; initialized from CMAKE_MSVCIDE_RUN_PATH environment variable if set."_s },
  { "CMAKE_MSVC_DEBUG_INFORMATION_FORMAT"_s,
    "Select the MSVC debug information format targeting the MSVC ABI"_s },
  { "CMAKE_MSVC_RUNTIME_CHECKS"_s,
    "Select the list of enabled runtime checks when targeting MSVC ABI"_s },
  { "CMAKE_MSVC_RUNTIME_LIBRARY"_s,
    "Select the MSVC runtime library for use by compilers targeting MSVC ABI"_s },
  { "CMAKE_NINJA_OUTPUT_PATH_PREFIX"_s,
    "Tell Ninja Generators to add a prefix to every output path"_s },
  { "CMAKE_NO_BUILTIN_CHRPATH"_s,
    "Do not use builtin binary editor to fix runtime library search paths"_s },
  { "CMAKE_NO_SYSTEM_FROM_IMPORTED"_s,
    "Default value for NO_SYSTEM_FROM_IMPORTED target property"_s },
  { "CMAKE_OBJCXX_EXTENSIONS"_s,
    "Default value for OBJCXX_EXTENSIONS target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_OBJCXX_STANDARD"_s,
    "Default value for OBJCXX_STANDARD target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_OBJCXX_STANDARD_REQUIRED"_s,
    "Default value for OBJCXX_STANDARD_REQUIRED target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_OBJC_EXTENSIONS"_s,
    "Default value for OBJC_EXTENSIONS target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_OBJC_STANDARD"_s,
    "Default value for OBJC_STANDARD target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_OBJC_STANDARD_REQUIRED"_s,
    "Default value for OBJC_STANDARD_REQUIRED target property if set when a target is created. See the cmake-compile-features(7) manual for information on compile features and a list of supported compilers."_s },
  { "CMAKE_OBJECT_PATH_MAX"_s,
    "Maximum object file full-path length allowed by native build tools; CMake hashes long paths to keep them under this limit."_s },
  { "CMAKE_OPTIMIZE_DEPENDENCIES"_s,
    "Initializes the OPTIMIZE_DEPENDENCIES target property"_s },
  { "CMAKE_OSX_ARCHITECTURES"_s,
    "Target architectures for macOS and iOS builds (e.g. x86_64;arm64). Initializes the OSX_ARCHITECTURES target property; if empty, the compiler's default architecture is used."_s },
  { "CMAKE_OSX_DEPLOYMENT_TARGET"_s,
    "Minimum macOS or iOS version on which the built binaries are to be deployed. Initialized from the MACOSX_DEPLOYMENT_TARGET environment variable when not set explicitly."_s },
  { "CMAKE_OSX_SYSROOT"_s,
    "Location or short name (e.g. macosx) of the macOS platform SDK passed to the compiler via -isysroot. Initialized from the SDKROOT environment variable; empty by default."_s },
  { "CMAKE_PCH_INSTANTIATE_TEMPLATES"_s,
    "Initializes the PCH_INSTANTIATE_TEMPLATES target property"_s },
  { "CMAKE_PCH_WARN_INVALID"_s,
    "Initializes the PCH_WARN_INVALID target property"_s },
  { "CMAKE_PDB_OUTPUT_DIRECTORY"_s,
    "Output directory for MS debug symbol .pdb files generated by linker"_s },
  { "CMAKE_PKG_CONFIG_DISABLE_UNINSTALLED"_s,
    "Disable uninstalled package file priority in pkg-config searches"_s },
  { "CMAKE_PKG_CONFIG_PC_LIB_DIRS"_s,
    "Primary search paths for pkg-config package files"_s },
  { "CMAKE_PKG_CONFIG_PC_PATH"_s,
    "Supplementary search paths for pkg-config package files"_s },
  { "CMAKE_PKG_CONFIG_SYSROOT_DIR"_s,
    "Path to prepend to -I include and -L library directories extracted by cmake_pkg_config command."_s },
  { "CMAKE_PKG_CONFIG_TOP_BUILD_DIR"_s,
    "Path to derive pc_top_builddir package variable by cmake_pkg_config command."_s },
  { "CMAKE_PLATFORM_NO_VERSIONED_SONAME"_s,
    "Disable version information on shared library targets on applicable platforms"_s },
  { "CMAKE_POLICY_VERSION_MINIMUM"_s,
    "Set minimum Policy Version for a project; for configuring third-party projects without modifying their code."_s },
  { "CMAKE_POSITION_INDEPENDENT_CODE"_s,
    "Default value used to initialize the POSITION_INDEPENDENT_CODE target property on targets that are not SHARED or MODULE libraries. SHARED and MODULE libraries always have PIC enabled."_s },
  { "CMAKE_PREFIX_PATH"_s,
    "Semicolon-separated list of installation prefixes searched by find_package(), find_program(), find_library(), find_file(), and find_path(). Empty by default; intended to be set by the project or the user."_s },
  { "CMAKE_PROGRAM_PATH"_s,
    "Semicolon-separated list of directories to search for programs with find_program command."_s },
  { "CMAKE_PROJECT_INCLUDE"_s,
    "CMake language file(s) to include as last step of project command calls for code injection without source modification."_s },
  { "CMAKE_PROJECT_INCLUDE_BEFORE"_s,
    "CMake language file(s) to include as first step of project command calls for code injection without source modification."_s },
  { "CMAKE_PROJECT_TOP_LEVEL_INCLUDES"_s,
    "Semicolon-separated list of CMake language files to include as part of the very first project() call."_s },
  { "CMAKE_RUNTIME_OUTPUT_DIRECTORY"_s,
    "Where to put all RUNTIME target files when built"_s },
  { "CMAKE_Rust_EDITION"_s,
    "Default Rust edition for Rust targets when created"_s },
  { "CMAKE_SHARED_LIBRARY_ENABLE_EXPORTS"_s,
    "Specify whether shared library generates an import file"_s },
  { "CMAKE_SHARED_LINKER_FLAGS"_s,
    "Linker flags to be used to create shared libraries"_s },
  { "CMAKE_SKIP_BUILD_RPATH"_s,
    "Do not include RPATHs in the build tree"_s },
  { "CMAKE_SKIP_INSTALL_ALL_DEPENDENCY"_s,
    "If true, install target does not depend on all target; installation proceeds independently of build status."_s },
  { "CMAKE_SKIP_INSTALL_RPATH"_s,
    "Do not include RPATHs in the install tree"_s },
  { "CMAKE_SKIP_LINTING"_s,
    "Default value for the SKIP_LINTING target property"_s },
  { "CMAKE_SKIP_TEST_ALL_DEPENDENCY"_s,
    "If true, test target does not depend on all target; test execution proceeds independently of build status."_s },
  { "CMAKE_STAGING_PREFIX"_s,
    "Install path to use when cross-compiling; also used as a search prefix by find_*() commands."_s },
  { "CMAKE_STATIC_LINKER_FLAGS"_s,
    "Flags to be used to create static libraries"_s },
  { "CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS"_s,
    "Semicolon-separated list of environment variables (var=value format) for Sublime Text 2 project generation."_s },
  { "CMAKE_SUBLIME_TEXT_2_EXCLUDE_BUILD_TREE"_s,
    "If true, exclude build tree from Sublime Text 2 .sublime-project file if build tree is inside source tree."_s },
  { "CMAKE_SUPPRESS_REGENERATION"_s,
    "If true, CMake does not add special regeneration target or perform build system checks for source changes."_s },
  { "CMAKE_SYSROOT"_s,
    "Path passed to the compiler via --sysroot (when supported) and used as a prefix for find_*() searches. May only be set in a toolchain file (CMAKE_TOOLCHAIN_FILE)."_s },
  { "CMAKE_SYSTEM_NAME"_s,
    "Name of the operating system being targeted (e.g. Linux, Darwin, Windows). Defaults to CMAKE_HOST_SYSTEM_NAME; set explicitly when first configuring a build tree to enable cross-compiling."_s },
  { "CMAKE_SYSTEM_PROCESSOR"_s,
    "Target system processor; same as CMAKE_HOST_SYSTEM_PROCESSOR for non-cross-compiling, set explicitly in toolchain files."_s },
  { "CMAKE_SYSTEM_VERSION"_s,
    "Version of the target operating system. Defaults to CMAKE_HOST_SYSTEM_VERSION for host builds; must be set explicitly alongside CMAKE_SYSTEM_NAME when cross-compiling."_s },
  { "CMAKE_Swift_LANGUAGE_VERSION"_s,
    "Swift language version (defaults based on Xcode version if not set)"_s },
  { "CMAKE_TLS_CAINFO"_s,
    "Path to TLS CA certificate file for file(DOWNLOAD), file(UPLOAD), ExternalProject, and FetchContent"_s },
  { "CMAKE_TLS_VERIFY"_s,
    "Enable TLS verification for file(DOWNLOAD), file(UPLOAD), ExternalProject, and FetchContent"_s },
  { "CMAKE_TLS_VERSION"_s,
    "Minimum TLS version for file(DOWNLOAD), file(UPLOAD), ExternalProject, and FetchContent (see manual)"_s },
  { "CMAKE_TOOLCHAIN_FILE"_s,
    "Path to a CMake toolchain file, read early in the CMake run, that specifies the compilers, toolchain utilities, and target-platform information used when cross-compiling."_s },
  { "CMAKE_TRY_COMPILE_CONFIGURATION"_s,
    "Build configuration used for try_compile and try_run projects"_s },
  { "CMAKE_TRY_COMPILE_NO_PLATFORM_VARIABLES"_s,
    "Set to a true value to tell the try_compile command not to propagate any platform variables into the test project. The try_compile command normally passes some CMake variables that configure the platform and toolchain behavior into test projects. See policy CMP0137."_s },
  { "CMAKE_TRY_COMPILE_PLATFORM_VARIABLES"_s,
    "List of variables that the try_compile command source file signature must propagate into the test project in order to target the same platform as the host project. This variable should not be set by project code. It is meant to be set by CMake's platform information modules or by a toolchain file."_s },
  { "CMAKE_TRY_COMPILE_TARGET_TYPE"_s,
    "Type of target generated for try_compile calls using the source file signature. Valid values are EXECUTABLE (use add_executable, default) or STATIC_LIBRARY (use add_library with STATIC option to avoid linking)."_s },
  { "CMAKE_UNITY_BUILD"_s,
    "Enable batch compilation of multiple sources within targets"_s },
  { "CMAKE_UNITY_BUILD_BATCH_SIZE"_s,
    "Specifies default upper limit on number of source files combined in one unity source file"_s },
  { "CMAKE_UNITY_BUILD_RELOCATABLE"_s,
    "Enable relative paths in generated unity build source files"_s },
  { "CMAKE_UNITY_BUILD_UNIQUE_ID"_s,
    "Specify unique identifier name generated per file in unity build"_s },
  { "CMAKE_USER_MAKE_RULES_OVERRIDE"_s,
    "Specify a CMake file that overrides platform information. CMake loads the specified file while enabling support for each language from either the project or enable_language commands. It is loaded after CMake's builtin compiler and platform information modules have been loaded but before the information is used."_s },
  { "CMAKE_VERBOSE_MAKEFILE"_s,
    "Enable verbose output from Makefile builds, showing each command line as it is launched. Initialized to FALSE by the project() command; users may override per build tree."_s },
  { "CMAKE_VERIFY_INTERFACE_HEADER_SETS"_s,
    "Enable interface header set verification for targets"_s },
  { "CMAKE_VERIFY_PRIVATE_HEADER_SETS"_s,
    "Enable private header set verification for targets"_s },
  { "CMAKE_VISIBILITY_INLINES_HIDDEN"_s,
    "Default value for VISIBILITY_INLINES_HIDDEN target property"_s },
  { "CMAKE_VS_DEBUGGER_COMMAND"_s,
    "Initialize debugger command path for Visual Studio targets"_s },
  { "CMAKE_VS_DEBUGGER_COMMAND_ARGUMENTS"_s,
    "Initialize debugger command arguments for Visual Studio targets"_s },
  { "CMAKE_VS_DEBUGGER_ENVIRONMENT"_s,
    "Initialize debugger environment variables for Visual Studio targets"_s },
  { "CMAKE_VS_DEBUGGER_WORKING_DIRECTORY"_s,
    "Initialize debugger working directory for Visual Studio targets"_s },
  { "CMAKE_VS_GLOBALS"_s,
    "Set custom global Visual Studio properties on all targets"_s },
  { "CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD"_s,
    "Include INSTALL target in default Visual Studio build"_s },
  { "CMAKE_VS_INCLUDE_PACKAGE_TO_DEFAULT_BUILD"_s,
    "Include PACKAGE target in default Visual Studio build"_s },
  { "CMAKE_VS_JUST_MY_CODE_DEBUGGING"_s,
    "Enable Just My Code debugging with Visual Studio"_s },
  { "CMAKE_VS_NO_COMPILE_BATCHING"_s,
    "Disable compile batching for Visual Studio generator"_s },
  { "CMAKE_VS_NUGET_PACKAGE_RESTORE"_s,
    "Controls whether msbuild automatically restores NuGet packages before a build (Visual Studio Generators)"_s },
  { "CMAKE_VS_SDK_EXCLUDE_DIRECTORIES"_s,
    "Override Visual Studio default Exclude Directories"_s },
  { "CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES"_s,
    "Override Visual Studio default Executable Directories"_s },
  { "CMAKE_VS_SDK_INCLUDE_DIRECTORIES"_s,
    "Override Visual Studio default Include Directories"_s },
  { "CMAKE_VS_SDK_LIBRARY_DIRECTORIES"_s,
    "Override Visual Studio default Library Directories"_s },
  { "CMAKE_VS_SDK_LIBRARY_WINRT_DIRECTORIES"_s,
    "Override Visual Studio default Library WinRT Directories"_s },
  { "CMAKE_VS_SDK_REFERENCE_DIRECTORIES"_s,
    "Override Visual Studio default Reference Directories"_s },
  { "CMAKE_VS_SDK_SOURCE_DIRECTORIES"_s,
    "Override Visual Studio default Source Directories"_s },
  { "CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION"_s,
    "Visual Studio Windows Target Platform Version. CMake selects the Windows SDK version when targeting Windows 10 and above on VS 2015+."_s },
  { "CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION"_s,
    "Ask cmake_install.cmake script to warn when encountering files with absolute INSTALL DESTINATION"_s },
  { "CMAKE_WATCOM_RUNTIME_LIBRARY"_s,
    "Initialize WATCOM_RUNTIME_LIBRARY target property for all targets"_s },
  { "CMAKE_WIN32_EXECUTABLE"_s,
    "Default value for WIN32_EXECUTABLE target property"_s },
  { "CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS"_s,
    "Default value for WINDOWS_EXPORT_ALL_SYMBOLS target property"_s },
  { "CMAKE_XCODE_GENERATE_SCHEME"_s,
    "Enable generation of scheme files by the Xcode generator for analyze, archive, and test actions"_s },
  { "CMAKE_XCODE_GENERATE_TOP_LEVEL_PROJECT_ONLY"_s,
    "If enabled, Xcode generator produces a single project file instead of one per project() invocation"_s },
  { "CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER"_s,
    "Enable Address Sanitizer in the Diagnostics section of the generated Xcode scheme"_s },
  { "CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN"_s,
    "Enable detection of stack use-after-return in the Diagnostics section of the generated Xcode scheme"_s },
  { "CMAKE_XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING"_s,
    "Enable debugging when using document Versions Browser in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_DISABLE_MAIN_THREAD_CHECKER"_s,
    "Disable the Main Thread Checker in the Diagnostics section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS"_s,
    "Enable Dynamic Library Loads in the Diagnostics section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_DYNAMIC_LINKER_API_USAGE"_s,
    "Enable Dynamic Linker API usage in the Diagnostics section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_ENABLE_GPU_API_VALIDATION"_s,
    "Populate Metal: API Validation in the Options section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_ENABLE_GPU_FRAME_CAPTURE_MODE"_s,
    "Set GPU Frame Capture to Metal or Disabled in the Options section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_ENABLE_GPU_SHADER_VALIDATION"_s,
    "Populate Metal: Shader Validation in the Options section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_ENVIRONMENT"_s,
    "Specify environment variables as MYVAR=value list to add to the Arguments section of the Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_GUARD_MALLOC"_s,
    "Enable Guard Malloc in the Diagnostics section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_LAUNCH_CONFIGURATION"_s,
    "Set the build configuration to run the target in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_LAUNCH_MODE"_s,
    "Populate Launch in the Info section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_LLDB_INIT_FILE"_s,
    "Populate LLDB Init File in the Info section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP"_s,
    "Enable Main Thread Checker pause-on-issues in the Diagnostics section of the Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_MALLOC_GUARD_EDGES"_s,
    "Enable Malloc Guard Edges in the Diagnostics section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_MALLOC_SCRIBBLE"_s,
    "Enable Malloc Scribble in the Diagnostics section of the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_MALLOC_STACK"_s,
    "Enable Malloc Stack diagnostics in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_TEST_CONFIGURATION"_s,
    "Build configuration for testing targets in the Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_THREAD_SANITIZER"_s,
    "Enable Thread Sanitizer diagnostics in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_THREAD_SANITIZER_STOP"_s,
    "Enable Thread Sanitizer pause-on-issues in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER"_s,
    "Enable Undefined Behavior Sanitizer in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER_STOP"_s,
    "Enable Undefined Behavior Sanitizer pause-on-issues in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_WORKING_DIRECTORY"_s,
    "Working directory for Run and Profile actions in the Xcode scheme."_s },
  { "CMAKE_XCODE_SCHEME_ZOMBIE_OBJECTS"_s,
    "Enable Zombie Objects diagnostics in the generated Xcode scheme."_s },
  { "CMAKE_XCODE_XCCONFIG"_s,
    "If set, the Xcode generator will register the specified file as a global XCConfig file. For target-level XCConfig files see the XCODE_XCCONFIG target property."_s },
};
/* clang-format on */

} // namespace

cmCacheDocumentationTable::LookupResult cmCacheDocumentationTable::Get(
  cm::string_view varName)
{
  auto const* const first = std::begin(kEntries);
  auto const* const last = std::end(kEntries);
  auto const* const it = std::lower_bound(
    first, last, varName, [](Entry const& entry, cm::string_view target) {
      return entry.Name < target;
    });
  if (it != last && it->Name == varName) {
    return { it->Summary };
  }
  // Exact-match miss: fall back to the pattern table (CMAKE_<LANG>_FLAGS,
  // CMAKE_POLICY_DEFAULT_CMP<NNNN>, etc.).  Exact-match always wins by
  // construction; only on a miss do we consult the (small, linearly
  // scanned) pattern table.  See Source/cmCachePatternTable.{h,cxx} and
  // the testPatternMatch* cases in Tests/CMakeLib for the contract.
  return cmCachePatternTable::Match(varName);
}

cmCacheDocumentationTable::Entry const*
cmCacheDocumentationTable::EntriesBegin()
{
  return std::begin(kEntries);
}

cmCacheDocumentationTable::Entry const* cmCacheDocumentationTable::EntriesEnd()
{
  return std::end(kEntries);
}

std::size_t cmCacheDocumentationTable::EntriesSize()
{
  return static_cast<std::size_t>(std::end(kEntries) - std::begin(kEntries));
}