#include "cmDocumentVariables.h" #include "cmake.h" #include void cmDocumentVariables::DefineVariables(cmake* cm) { // Subsection: variables defined by cmake, that give // information about the project, and cmake cm->DefineProperty ("CMAKE_AR", cmProperty::VARIABLE, "Name of archiving tool for static libraries.", "This specifies the name of the program that creates archive " "or static libraries.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_COMMAND", cmProperty::VARIABLE, "The full path to the cmake executable.", "This is the full path to the CMake executable cmake which is " "useful from custom commands that want to use the cmake -E " "option for portable system commands. " "(e.g. /usr/local/bin/cmake", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_BINARY_DIR", cmProperty::VARIABLE, "The path to the top level of the build tree.", "This is the full path to the top level of the current CMake " "build tree. For an in-source build, this would be the same " "as CMAKE_SOURCE_DIR. ", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SOURCE_DIR", cmProperty::VARIABLE, "The path to the top level of the source tree.", "This is the full path to the top level of the current CMake " "source tree. For an in-source build, this would be the same " "as CMAKE_BINARY_DIR. ", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CURRENT_BINARY_DIR", cmProperty::VARIABLE, "The path to the binary directory currently being processed.", "This the full path to the build directory that is currently " "being processed by cmake. Each directory added by " "add_subdirectory will create a binary directory in the build " "tree, and as it is being processed this variable will be set. " "For in-source builds this is the current source directory " "being processed.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CURRENT_SOURCE_DIR", cmProperty::VARIABLE, "The path to the source directory currently being processed.", "This the full path to the source directory that is currently " "being processed by cmake. ", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CURRENT_LIST_FILE", cmProperty::VARIABLE, "Full path to the listfile currently being processed.", "As CMake processes the listfiles in your project this " "variable will always be set to the one currently being " "processed. " "The value has dynamic scope. " "When CMake starts processing commands in a source file " "it sets this variable to the location of the file. " "When CMake finishes processing commands from the file it " "restores the previous value. " "Therefore the value of the variable inside a macro or " "function is the file invoking the bottom-most entry on " "the call stack, not the file containing the macro or " "function definition." "\n" "See also CMAKE_PARENT_LIST_FILE.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CURRENT_LIST_LINE", cmProperty::VARIABLE, "The line number of the current file being processed.", "This is the line number of the file currently being" " processed by cmake.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CURRENT_LIST_DIR", cmProperty::VARIABLE, "Full directory of the listfile currently being processed.", "As CMake processes the listfiles in your project this " "variable will always be set to the directory where the listfile which " "is currently being processed (CMAKE_CURRENT_LIST_FILE) is located. " "The value has dynamic scope. " "When CMake starts processing commands in a source file " "it sets this variable to the directory where this file is located. " "When CMake finishes processing commands from the file it " "restores the previous value. " "Therefore the value of the variable inside a macro or " "function is the directory of the file invoking the bottom-most entry on " "the call stack, not the directory of the file containing the macro or " "function definition." "\n" "See also CMAKE_CURRENT_LIST_FILE.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SCRIPT_MODE_FILE", cmProperty::VARIABLE, "Full path to the -P script file currently being processed. ", "When run in -P script mode, CMake sets this variable to the full " "path of the script file. When run to configure a CMakeLists.txt " "file, this variable is not set.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_ARGC", cmProperty::VARIABLE, "Number of command line arguments passed to CMake in script mode. ", "When run in -P script mode, CMake sets this variable to the number " "of command line arguments. See also CMAKE_ARGV0, 1, 2 ... ", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_ARGV0", cmProperty::VARIABLE, "Command line argument passed to CMake in script mode. ", "When run in -P script mode, CMake sets this variable to " "the first command line argument. It then also sets CMAKE_ARGV1, " "CMAKE_ARGV2, ... and so on, up to the number of command line arguments " "given. See also CMAKE_ARGC.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_BUILD_TOOL", cmProperty::VARIABLE, "Tool used for the actual build process.", "This variable is set to the program that will be" " needed to build the output of CMake. If the " "generator selected was Visual Studio 6, the " "CMAKE_BUILD_TOOL will be set to msdev, for " "Unix Makefiles it will be set to make or gmake, " "and for Visual Studio 7 it set to devenv. For " "NMake Makefiles the value is nmake. This can be " "useful for adding special flags and commands based" " on the final build environment. ", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CROSSCOMPILING", cmProperty::VARIABLE, "Is CMake currently cross compiling.", "This variable will be set to true by CMake if CMake is cross " "compiling. Specifically if the build platform is different " "from the target platform.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CACHEFILE_DIR", cmProperty::VARIABLE, "The directory with the CMakeCache.txt file.", "This is the full path to the directory that has the " "CMakeCache.txt file in it. This is the same as " "CMAKE_BINARY_DIR.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CACHE_MAJOR_VERSION", cmProperty::VARIABLE, "Major version of CMake used to create the CMakeCache.txt file", "This stores the major version of CMake used to " "write a CMake cache file. It is only different when " "a different version of CMake is run on a previously " "created cache file.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CACHE_MINOR_VERSION", cmProperty::VARIABLE, "Minor version of CMake used to create the CMakeCache.txt file", "This stores the minor version of CMake used to " "write a CMake cache file. It is only different when " "a different version of CMake is run on a previously " "created cache file.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CACHE_PATCH_VERSION", cmProperty::VARIABLE, "Patch version of CMake used to create the CMakeCache.txt file", "This stores the patch version of CMake used to " "write a CMake cache file. It is only different when " "a different version of CMake is run on a previously " "created cache file.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CFG_INTDIR", cmProperty::VARIABLE, "Build-time reference to per-configuration output subdirectory.", "For native build systems supporting multiple configurations " "in the build tree (such as Visual Studio and Xcode), " "the value is a reference to a build-time variable specifying " "the name of the per-configuration output subdirectory. " "On Makefile generators this evaluates to \".\" because there " "is only one configuration in a build tree. " "Example values:\n" " $(IntDir) = Visual Studio 6\n" " $(OutDir) = Visual Studio 7, 8, 9\n" " $(Configuration) = Visual Studio 10\n" " $(CONFIGURATION) = Xcode\n" " . = Make-based tools\n" "Since these values are evaluated by the native build system, this " "variable is suitable only for use in command lines that will be " "evaluated at build time. " "Example of intended usage:\n" " add_executable(mytool mytool.c)\n" " add_custom_command(\n" " OUTPUT out.txt\n" " COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool\n" " ${CMAKE_CURRENT_SOURCE_DIR}/in.txt out.txt\n" " DEPENDS mytool in.txt\n" " )\n" " add_custom_target(drive ALL DEPENDS out.txt)\n" "Note that CMAKE_CFG_INTDIR is no longer necessary for this purpose " "but has been left for compatibility with existing projects. " "Instead add_custom_command() recognizes executable target names in " "its COMMAND option, so " "\"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool\" can be " "replaced by just \"mytool\"." "\n" "This variable is read-only. Setting it is undefined behavior. " "In multi-configuration build systems the value of this variable " "is passed as the value of preprocessor symbol \"CMAKE_INTDIR\" to " "the compilation of all source files.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_CTEST_COMMAND", cmProperty::VARIABLE, "Full path to ctest command installed with cmake.", "This is the full path to the CTest executable ctest " "which is useful from custom commands that want " "to use the cmake -E option for portable system " "commands.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_DL_LIBS", cmProperty::VARIABLE, "Name of library containing dlopen and dlcose.", "The name of the library that has dlopen and " "dlclose in it, usually -ldl on most UNIX machines.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_EDIT_COMMAND", cmProperty::VARIABLE, "Full path to cmake-gui or ccmake.", "This is the full path to the CMake executable " "that can graphically edit the cache. For example," " cmake-gui, ccmake, or cmake -i.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_GENERATOR", cmProperty::VARIABLE, "The generator used to build the project.", "The name of the generator that is being used to generate the " "build files. (e.g. \"Unix Makefiles\", " "\"Visual Studio 6\", etc.)",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_EXTRA_GENERATOR", cmProperty::VARIABLE, "The extra generator used to build the project.", "When using the Eclipse, CodeBlocks or KDevelop generators, CMake " "generates Makefiles (CMAKE_GENERATOR) and additionally project files " "for the respective IDE. This IDE project file generator is stored in " "CMAKE_EXTRA_GENERATOR (e.g. \"Eclipse CDT4\").",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_GENERATOR_TOOLSET", cmProperty::VARIABLE, "Native build system toolset name specified by user.", "Some CMake generators support a toolset name to be given to the " "native build system to choose a compiler. " "If the user specifies a toolset name (e.g. via the cmake -T option) " "the value will be available in this variable.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_HOME_DIRECTORY", cmProperty::VARIABLE, "Path to top of source tree.", "This is the path to the top level of the source tree.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_LINK_LIBRARY_SUFFIX", cmProperty::VARIABLE, "The suffix for libraries that you link to.", "The suffix to use for the end of a library filename, .lib on Windows." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_EXECUTABLE_SUFFIX", cmProperty::VARIABLE, "The suffix for executables on this platform.", "The suffix to use for the end of an executable filename if any, " ".exe on Windows." "\n" "CMAKE_EXECUTABLE_SUFFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_MAJOR_VERSION", cmProperty::VARIABLE, "The Major version of cmake (i.e. the 2 in 2.X.X)", "This specifies the major version of the CMake executable" " being run.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_MAKE_PROGRAM", cmProperty::VARIABLE, "See CMAKE_BUILD_TOOL.", "This variable is around for backwards compatibility, " "see CMAKE_BUILD_TOOL.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_VS_PLATFORM_TOOLSET", cmProperty::VARIABLE, "Visual Studio Platform Toolset name.", "VS 10 and above use MSBuild under the hood and support multiple " "compiler toolchains. " "CMake may specify a toolset explicitly, such as \"v110\" for " "VS 11 or \"Windows7.1SDK\" for 64-bit support in VS 10 Express. " "CMake provides the name of the chosen toolset in this variable." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_XCODE_PLATFORM_TOOLSET", cmProperty::VARIABLE, "Xcode compiler selection.", "Xcode supports selection of a compiler from one of the installed " "toolsets. " "CMake provides the name of the chosen toolset in this variable, " "if any is explicitly selected (e.g. via the cmake -T option)." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_MINOR_VERSION", cmProperty::VARIABLE, "The Minor version of cmake (i.e. the 4 in X.4.X).", "This specifies the minor version of the CMake" " executable being run.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_PATCH_VERSION", cmProperty::VARIABLE, "The patch version of cmake (i.e. the 3 in X.X.3).", "This specifies the patch version of the CMake" " executable being run.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_TWEAK_VERSION", cmProperty::VARIABLE, "The tweak version of cmake (i.e. the 1 in X.X.X.1).", "This specifies the tweak version of the CMake executable being run. " "Releases use tweak < 20000000 and development versions use the date " "format CCYYMMDD for the tweak level." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_VERSION", cmProperty::VARIABLE, "The full version of cmake in major.minor.patch[.tweak[-id]] format.", "This specifies the full version of the CMake executable being run. " "This variable is defined by versions 2.6.3 and higher. " "See variables CMAKE_MAJOR_VERSION, CMAKE_MINOR_VERSION, " "CMAKE_PATCH_VERSION, and CMAKE_TWEAK_VERSION " "for individual version components. " "The [-id] component appears in non-release versions " "and may be arbitrary text.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_PARENT_LIST_FILE", cmProperty::VARIABLE, "Full path to the CMake file that included the current one.", "While processing a CMake file loaded by include() or find_package() " "this variable contains the full path to the file including it. " "The top of the include stack is always the CMakeLists.txt for the " "current directory. " "See also CMAKE_CURRENT_LIST_FILE.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_PROJECT_NAME", cmProperty::VARIABLE, "The name of the current project.", "This specifies name of the current project from" " the closest inherited PROJECT command.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_RANLIB", cmProperty::VARIABLE, "Name of randomizing tool for static libraries.", "This specifies name of the program that randomizes " "libraries on UNIX, not used on Windows, but may be present.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_ROOT", cmProperty::VARIABLE, "Install directory for running cmake.", "This is the install root for the running CMake and" " the Modules directory can be found here. This is" " commonly used in this format: ${CMAKE_ROOT}/Modules",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SIZEOF_VOID_P", cmProperty::VARIABLE, "Size of a void pointer.", "This is set to the size of a pointer on the machine, " "and is determined by a try compile. If a 64 bit size " "is found, then the library search path is modified to " "look for 64 bit libraries first.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SKIP_RPATH", cmProperty::VARIABLE, "If true, do not add run time path information.", "If this is set to TRUE, then the rpath information " "is not added to compiled executables. The default " "is to add rpath information if the platform supports it. " "This allows for easy running from the build tree. To omit RPATH " "in the install step, but not the build step, use " "CMAKE_SKIP_INSTALL_RPATH instead.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SOURCE_DIR", cmProperty::VARIABLE, "Source directory for project.", "This is the top level source directory for the project. " "It corresponds to the source directory given to " "cmake-gui or ccmake.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_STANDARD_LIBRARIES", cmProperty::VARIABLE, "Libraries linked into every executable and shared library.", "This is the list of libraries that are linked " "into all executables and libraries.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_VERBOSE_MAKEFILE", cmProperty::VARIABLE, "Create verbose makefiles if on.", "This variable defaults to false. You can set " "this variable to true to make CMake produce verbose " "makefiles that show each command line as it is used.",false, "Variables that Provide Information"); cm->DefineProperty ("PROJECT_BINARY_DIR", cmProperty::VARIABLE, "Full path to build directory for project.", "This is the binary directory of the most recent " "PROJECT command.",false,"Variables that Provide Information"); cm->DefineProperty ("PROJECT_NAME", cmProperty::VARIABLE, "Name of the project given to the project command.", "This is the name given to the most " "recent PROJECT command. ",false, "Variables that Provide Information"); cm->DefineProperty ("PROJECT_SOURCE_DIR", cmProperty::VARIABLE, "Top level source directory for the current project.", "This is the source directory of the most recent " "PROJECT command.",false, "Variables that Provide Information"); cm->DefineProperty ("[Project name]_BINARY_DIR", cmProperty::VARIABLE, "Top level binary directory for the named project.", "A variable is created with the name used in the PROJECT " "command, and is the binary directory for the project. " " This can be useful when SUBDIR is used to connect " "several projects.",false, "Variables that Provide Information"); cm->DefineProperty ("[Project name]_SOURCE_DIR", cmProperty::VARIABLE, "Top level source directory for the named project.", "A variable is created with the name used in the PROJECT " "command, and is the source directory for the project." " This can be useful when add_subdirectory " "is used to connect several projects.",false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_IMPORT_LIBRARY_PREFIX", cmProperty::VARIABLE, "The prefix for import libraries that you link to.", "The prefix to use for the name of an import library if used " "on this platform." "\n" "CMAKE_IMPORT_LIBRARY_PREFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_IMPORT_LIBRARY_SUFFIX", cmProperty::VARIABLE, "The suffix for import libraries that you link to.", "The suffix to use for the end of an import library filename if used " "on this platform." "\n" "CMAKE_IMPORT_LIBRARY_SUFFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SHARED_LIBRARY_PREFIX", cmProperty::VARIABLE, "The prefix for shared libraries that you link to.", "The prefix to use for the name of a shared library, lib on UNIX." "\n" "CMAKE_SHARED_LIBRARY_PREFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SHARED_LIBRARY_SUFFIX", cmProperty::VARIABLE, "The suffix for shared libraries that you link to.", "The suffix to use for the end of a shared library filename, " ".dll on Windows." "\n" "CMAKE_SHARED_LIBRARY_SUFFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SHARED_MODULE_PREFIX", cmProperty::VARIABLE, "The prefix for loadable modules that you link to.", "The prefix to use for the name of a loadable module on this platform." "\n" "CMAKE_SHARED_MODULE_PREFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_SHARED_MODULE_SUFFIX", cmProperty::VARIABLE, "The suffix for shared libraries that you link to.", "The suffix to use for the end of a loadable module filename " "on this platform" "\n" "CMAKE_SHARED_MODULE_SUFFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_STATIC_LIBRARY_PREFIX", cmProperty::VARIABLE, "The prefix for static libraries that you link to.", "The prefix to use for the name of a static library, lib on UNIX." "\n" "CMAKE_STATIC_LIBRARY_PREFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_STATIC_LIBRARY_SUFFIX", cmProperty::VARIABLE, "The suffix for static libraries that you link to.", "The suffix to use for the end of a static library filename, " ".lib on Windows." "\n" "CMAKE_STATIC_LIBRARY_SUFFIX_ overrides this for language ." ,false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES", cmProperty::VARIABLE, "Additional suffixes for shared libraries.", "Extensions for shared libraries other than that specified by " "CMAKE_SHARED_LIBRARY_SUFFIX, if any. " "CMake uses this to recognize external shared library files during " "analysis of libraries linked by a target.", false, "Variables that Provide Information"); cm->DefineProperty ("CMAKE_MINIMUM_REQUIRED_VERSION", cmProperty::VARIABLE, "Version specified to cmake_minimum_required command", "Variable containing the VERSION component specified in the " "cmake_minimum_required command.", false, "Variables that Provide Information"); // Variables defined by cmake, that change the behavior // of cmake cm->DefineProperty ("CMAKE_POLICY_DEFAULT_CMP", cmProperty::VARIABLE, "Default for CMake Policy CMP when it is otherwise left unset.", "Commands cmake_minimum_required(VERSION) and cmake_policy(VERSION) " "by default leave policies introduced after the given version unset. " "Set CMAKE_POLICY_DEFAULT_CMP to OLD or NEW to specify the " "default for policy CMP, where is the policy number." "\n" "This variable should not be set by a project in CMake code; " "use cmake_policy(SET) instead. " "Users running CMake may set this variable in the cache " "(e.g. -DCMAKE_POLICY_DEFAULT_CMP=) " "to set a policy not otherwise set by the project. " "Set to OLD to quiet a policy warning while using old behavior " "or to NEW to try building the project with new behavior.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_AUTOMOC_RELAXED_MODE", cmProperty::VARIABLE, "Switch between strict and relaxed automoc mode.", "By default, automoc behaves exactly as described in the documentation " "of the AUTOMOC target property. " "When set to TRUE, it accepts more input and tries to find the correct " "input file for moc even if it differs from the documented behaviour. " "In this mode it e.g. also checks whether a header file is intended to " "be processed by moc when a \"foo.moc\" file has been included.\n" "Relaxed mode has to be enabled for KDE4 compatibility.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME", cmProperty::VARIABLE, "Default component used in install() commands.", "If an install() command is used without the COMPONENT argument, " "these files will be grouped into a default component. The name of this " "default install component will be taken from this variable. " "It defaults to \"Unspecified\". ", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SYSROOT", cmProperty::VARIABLE, "Path to pass to the compiler in the --sysroot flag.", "The CMAKE_SYSROOT content is passed to the compiler in the --sysroot " "flag, if supported. The path is also stripped from the RPATH if " "necessary on installation. The CMAKE_SYSROOT is also used to prefix " "paths searched by the find_* commands.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_FIND_LIBRARY_PREFIXES", cmProperty::VARIABLE, "Prefixes to prepend when looking for libraries.", "This specifies what prefixes to add to library names when " "the find_library command looks for libraries. On UNIX " "systems this is typically lib, meaning that when trying " "to find the foo library it will look for libfoo.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_FIND_LIBRARY_SUFFIXES", cmProperty::VARIABLE, "Suffixes to append when looking for libraries.", "This specifies what suffixes to add to library names when " "the find_library command looks for libraries. On Windows " "systems this is typically .lib and .dll, meaning that when trying " "to find the foo library it will look for foo.dll etc.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_CONFIGURATION_TYPES", cmProperty::VARIABLE, "Specifies the available build types on multi-config generators.", "This specifies what build types (configurations) will be available " "such as Debug, Release, RelWithDebInfo etc. " "This has reasonable defaults on most platforms, " "but can be extended to provide other build types. " "See also CMAKE_BUILD_TYPE for details of managing configuration data, " "and CMAKE_CFG_INTDIR." ,false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_BUILD_TYPE", cmProperty::VARIABLE, "Specifies the build type on single-configuration generators.", "This statically specifies what build type (configuration) " "will be built in this build tree. Possible values are " "empty, Debug, Release, RelWithDebInfo and MinSizeRel. " "This variable is only meaningful to single-configuration generators " "(such as make and Ninja) i.e. " "those which choose a single configuration " "when CMake runs to generate a build tree as opposed to " "multi-configuration generators which offer selection of the build " "configuration within the generated build environment. " "There are many per-config properties and variables " "(usually following clean SOME_VAR_ order conventions), " "such as CMAKE_C_FLAGS_, specified as uppercase: " "CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL]. " "For example, in a build tree configured " "to build type Debug, CMake will see to having " "CMAKE_C_FLAGS_DEBUG settings get added to the CMAKE_C_FLAGS settings. " "See also CMAKE_CONFIGURATION_TYPES." ,false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_BACKWARDS_COMPATIBILITY", cmProperty::VARIABLE, "Version of cmake required to build project", "From the point of view of backwards compatibility, this " "specifies what version of CMake should be supported. By " "default this value is the version number of CMake that " "you are running. You can set this to an older version of" " CMake to support deprecated commands of CMake in projects" " that were written to use older versions of CMake. This " "can be set by the user or set at the beginning of a " "CMakeLists file.",false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_INSTALL_PREFIX", cmProperty::VARIABLE, "Install directory used by install.", "If \"make install\" is invoked or INSTALL is built" ", this directory is prepended onto all install " "directories. This variable defaults to /usr/local" " on UNIX and c:/Program Files on Windows.\n" "On UNIX one can use the DESTDIR mechanism in order" " to relocate the whole installation. " "DESTDIR means DESTination DIRectory. It is " "commonly used by makefile users " "in order to install software at non-default location. " "It is usually invoked like this:\n" " make DESTDIR=/home/john install\n" "which will install the concerned software using the" " installation prefix, e.g. \"/usr/local\" prepended with " "the DESTDIR value which finally gives \"/home/john/usr/local\".\n" "WARNING: DESTDIR may not be used on Windows because installation" " prefix usually contains a drive letter like in \"C:/Program Files\"" " which cannot be prepended with some other prefix." "\n" "The installation prefix is also added to CMAKE_SYSTEM_PREFIX_PATH " "so that find_package, find_program, find_library, find_path, and " "find_file will search the prefix for other software." ,false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY", cmProperty::VARIABLE, "Don't make the install target depend on the all target.", "By default, the \"install\" target depends on the \"all\" target. " "This has the effect, that when \"make install\" is invoked or INSTALL " "is built, first the \"all\" target is built, then the installation " "starts. " "If CMAKE_SKIP_INSTALL_ALL_DEPENDENCY is set to TRUE, this dependency " "is not created, so the installation process will start immediately, " "independent from whether the project has been completely built or not." ,false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_MODULE_PATH", cmProperty::VARIABLE, "List of directories to search for CMake modules.", "Commands like include() and find_package() search for files in " "directories listed by this variable before checking the default " "modules that come with CMake.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_WARN_DEPRECATED", cmProperty::VARIABLE, "Whether to issue deprecation warnings for macros and functions.", "If TRUE, this can be used by macros and functions to issue " "deprecation warnings. This variable is FALSE by default.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_ERROR_DEPRECATED", cmProperty::VARIABLE, "Whether to issue deprecation errors for macros and functions.", "If TRUE, this can be used by macros and functions to issue " "fatal errors when deprecated macros or functions are used. This " "variable is FALSE by default.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_PREFIX_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_XXX(), with appropriate suffixes added.", "Specifies a path which will be used by the FIND_XXX() commands. It " "contains the \"base\" directories, the FIND_XXX() commands append " "appropriate subdirectories to the base directories. So FIND_PROGRAM() " "adds /bin to each of the directories in the path, FIND_LIBRARY() " "appends /lib to each of the directories, and FIND_PATH() and " "FIND_FILE() append /include . By default it is empty, it is intended " "to be set by the project. See also CMAKE_SYSTEM_PREFIX_PATH, " "CMAKE_INCLUDE_PATH, CMAKE_LIBRARY_PATH, CMAKE_PROGRAM_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_INCLUDE_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_FILE() and FIND_PATH().", "Specifies a path which will be used both by FIND_FILE() and " "FIND_PATH(). Both commands will check each of the contained directories " "for the existence of the file which is currently searched. By default " "it is empty, it is intended to be set by the project. See also " "CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_PREFIX_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_LIBRARY_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_LIBRARY().", "Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() " "will check each of the contained directories for the existence of the " "library which is currently searched. By default it is empty, it is " "intended to be set by the project. See also CMAKE_SYSTEM_LIBRARY_PATH, " "CMAKE_PREFIX_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_PROGRAM_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_PROGRAM().", "Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM() " "will check each of the contained directories for the existence of the " "program which is currently searched. By default it is empty, it is " "intended to be set by the project. See also CMAKE_SYSTEM_PROGRAM_PATH, " " CMAKE_PREFIX_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SYSTEM_PREFIX_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_XXX(), with appropriate suffixes added.", "Specifies a path which will be used by the FIND_XXX() commands. It " "contains the \"base\" directories, the FIND_XXX() commands append " "appropriate subdirectories to the base directories. So FIND_PROGRAM() " "adds /bin to each of the directories in the path, FIND_LIBRARY() " "appends /lib to each of the directories, and FIND_PATH() and " "FIND_FILE() append /include . By default this contains the standard " "directories for the current system and the CMAKE_INSTALL_PREFIX. " "It is NOT intended " "to be modified by the project, use CMAKE_PREFIX_PATH for this. See also " "CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_SYSTEM_LIBRARY_PATH, " "CMAKE_SYSTEM_PROGRAM_PATH, and CMAKE_SYSTEM_IGNORE_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SYSTEM_IGNORE_PATH", cmProperty::VARIABLE, "Path to be ignored by FIND_XXX() commands.", "Specifies directories to be ignored by searches in FIND_XXX() " "commands. " "This is useful in cross-compiled environments where some system " "directories contain incompatible but possibly linkable libraries. For " "example, on cross-compiled cluster environments, this allows a user to " "ignore directories containing libraries meant for the front-end " "machine that modules like FindX11 (and others) would normally search. " "By default this contains a list of directories containing incompatible " "binaries for the host system. " "See also CMAKE_SYSTEM_PREFIX_PATH, CMAKE_SYSTEM_LIBRARY_PATH, " "CMAKE_SYSTEM_INCLUDE_PATH, and CMAKE_SYSTEM_PROGRAM_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_IGNORE_PATH", cmProperty::VARIABLE, "Path to be ignored by FIND_XXX() commands.", "Specifies directories to be ignored by searches in FIND_XXX() " "commands. " "This is useful in cross-compiled environments where some system " "directories contain incompatible but possibly linkable libraries. For " "example, on cross-compiled cluster environments, this allows a user to " "ignore directories containing libraries meant for the front-end " "machine that modules like FindX11 (and others) would normally search. " "By default this is empty; it is intended to be set by the project. " "Note that CMAKE_IGNORE_PATH takes a list of directory names, NOT a " "list of prefixes. If you want to ignore paths under prefixes (bin, " "include, lib, etc.), you'll need to specify them explicitly. " "See also CMAKE_PREFIX_PATH, CMAKE_LIBRARY_PATH, CMAKE_INCLUDE_PATH, " "CMAKE_PROGRAM_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SYSTEM_INCLUDE_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_FILE() and FIND_PATH().", "Specifies a path which will be used both by FIND_FILE() and " "FIND_PATH(). Both commands will check each of the contained directories " "for the existence of the file which is currently searched. By default " "it contains the standard directories for the current system. It is " "NOT intended to be modified by the project, use CMAKE_INCLUDE_PATH " "for this. See also CMAKE_SYSTEM_PREFIX_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SYSTEM_LIBRARY_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_LIBRARY().", "Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() " "will check each of the contained directories for the existence of the " "library which is currently searched. By default it contains the " "standard directories for the current system. It is NOT intended to be " "modified by the project, use CMAKE_LIBRARY_PATH for this. See " "also CMAKE_SYSTEM_PREFIX_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_SYSTEM_PROGRAM_PATH", cmProperty::VARIABLE, "Path used for searching by FIND_PROGRAM().", "Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM() " "will check each of the contained directories for the existence of the " "program which is currently searched. By default it contains the " "standard directories for the current system. It is NOT intended to be " "modified by the project, use CMAKE_PROGRAM_PATH for this. See also " "CMAKE_SYSTEM_PREFIX_PATH.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_DISABLE_FIND_PACKAGE_", cmProperty::VARIABLE, "Variable for disabling find_package() calls.", "Every non-REQUIRED find_package() call in a project can be disabled " "by setting the variable CMAKE_DISABLE_FIND_PACKAGE_ to " "TRUE. This can be used to build a project without an optional package, " "although that package is installed.\n" "This switch should be used during the initial CMake run. Otherwise if " "the package has already been found in a previous CMake run, the " "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 package from the cache using the cache editor or cmake -U", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_FIND_PACKAGE_WARN_NO_MODULE", cmProperty::VARIABLE, "Tell find_package to warn if called without an explicit mode.", "If find_package is called without an explicit mode option " "(MODULE, CONFIG or NO_MODULE) and no Find.cmake module is " "in CMAKE_MODULE_PATH then CMake implicitly assumes that the " "caller intends to search for a package configuration file. " "If no package configuration file is found then the wording " "of the failure message must account for both the case that the " "package is really missing and the case that the project has a " "bug and failed to provide the intended Find module. " "If instead the caller specifies an explicit mode option then " "the failure message can be more specific." "\n" "Set CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_package " "to warn when it implicitly assumes Config mode. " "This helps developers enforce use of an explicit mode in all calls " "to find_package within a project.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_USER_MAKE_RULES_OVERRIDE", cmProperty::VARIABLE, "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. " "The file may set platform information variables to override CMake's " "defaults." "\n" "This feature is intended for use only in overriding information " "variables that must be set before CMake builds its first test " "project to check that the compiler for a language works. " "It should not be used to load a file in cases that a normal include() " "will work. " "Use it only as a last resort for behavior that cannot be achieved " "any other way. " "For example, one may set CMAKE_C_FLAGS_INIT to change the default " "value used to initialize CMAKE_C_FLAGS before it is cached. " "The override file should NOT be used to set anything that could " "be set after languages are enabled, such as variables like " "CMAKE_RUNTIME_OUTPUT_DIRECTORY that affect the placement of binaries. " "Information set in the file will be used for try_compile and try_run " "builds too." ,false, "Variables That Change Behavior"); cm->DefineProperty ("BUILD_SHARED_LIBS", cmProperty::VARIABLE, "Global flag to cause add_library to create shared libraries if on.", "If present and true, this will cause all libraries to be " "built shared unless the library was explicitly added as a " "static library. This variable is often added to projects " "as an OPTION so that each user of a project can decide if " "they want to build the project using shared or static " "libraries.",false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_NOT_USING_CONFIG_FLAGS", cmProperty::VARIABLE, "Skip _BUILD_TYPE flags if true.", "This is an internal flag used by the generators in " "CMake to tell CMake to skip the _BUILD_TYPE flags.",false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_MFC_FLAG", cmProperty::VARIABLE, "Tell cmake to use MFC for an executable or dll.", "This can be set in a CMakeLists.txt file and will " "enable MFC in the application. It should be set " "to 1 for the static MFC library, and 2 for " "the shared MFC library. This is used in Visual " "Studio 6 and 7 project files. The CMakeSetup " "dialog used MFC and the CMakeLists.txt looks like this:\n" " add_definitions(-D_AFXDLL)\n" " set(CMAKE_MFC_FLAG 2)\n" " add_executable(CMakeSetup WIN32 ${SRCS})\n",false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_COLOR_MAKEFILE", cmProperty::VARIABLE, "Enables color output when using the Makefile generator.", "When enabled, the generated Makefiles will produce colored output. " "Default is ON.",false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_ABSOLUTE_DESTINATION_FILES", cmProperty::VARIABLE, "List of files which have been installed using " " an ABSOLUTE DESTINATION path.", "This variable is defined by CMake-generated cmake_install.cmake " "scripts." " It can be used (read-only) by programs or scripts that source those" " install scripts. This is used by some CPack generators (e.g. RPM).", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE, "Ask cmake_install.cmake script to warn each time a file with " "absolute INSTALL DESTINATION is encountered.", "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 warning messages from the script.", false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE, "Ask cmake_install.cmake script to error out as soon as " "a file with absolute INSTALL DESTINATION is encountered.", "The fatal error is emitted before the installation of " "the offending file takes place." " 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 fatal error messages from the script.",false, "Variables That Change Behavior"); cm->DefineProperty ("CMAKE_DEBUG_TARGET_PROPERTIES", cmProperty::VARIABLE, "Enables tracing output for target properties.", "This variable can be populated with a list of properties to generate " "debug output for when evaluating target properties. Currently it can " "only be used when evaluating the INCLUDE_DIRECTORIES target property. " "In that case, it outputs a backtrace for each include directory in " "the build. Default is unset.",false,"Variables That Change Behavior"); // Variables defined by CMake that describe the system cm->DefineProperty ("CMAKE_SYSTEM", cmProperty::VARIABLE, "Name of system cmake is compiling for.", "This variable is the composite of CMAKE_SYSTEM_NAME " "and CMAKE_SYSTEM_VERSION, like this " "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}. " "If CMAKE_SYSTEM_VERSION is not set, then " "CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_SYSTEM_NAME", cmProperty::VARIABLE, "Name of the OS CMake is building for.", "This is the name of the operating system on " "which CMake is targeting. On systems that " "have the uname command, this variable is set " "to the output of uname -s. Linux, Windows, " " and Darwin for Mac OS X are the values found " " on the big three operating systems." ,false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_SYSTEM_PROCESSOR", cmProperty::VARIABLE, "The name of the CPU CMake is building for.", "On systems that support uname, this variable is " "set to the output of uname -p, on windows it is " "set to the value of the environment variable " "PROCESSOR_ARCHITECTURE",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_SYSTEM_VERSION", cmProperty::VARIABLE, "OS version CMake is building for.", "A numeric version string for the system, on " "systems that support uname, this variable is " "set to the output of uname -r. On other " "systems this is set to major-minor version numbers.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_LIBRARY_ARCHITECTURE", cmProperty::VARIABLE, "Target architecture library directory name, if detected.", "This is the value of CMAKE__LIBRARY_ARCHITECTURE as " "detected for one of the enabled languages.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_LIBRARY_ARCHITECTURE_REGEX", cmProperty::VARIABLE, "Regex matching possible target architecture library directory names.", "This is used to detect CMAKE__LIBRARY_ARCHITECTURE from the " "implicit linker search path by matching the name.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_SYSTEM", cmProperty::VARIABLE, "Name of system cmake is being run on.", "The same as CMAKE_SYSTEM but for the host system instead " "of the target system when cross compiling.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_SYSTEM_NAME", cmProperty::VARIABLE, "Name of the OS CMake is running on.", "The same as CMAKE_SYSTEM_NAME but for the host system instead " "of the target system when cross compiling.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_SYSTEM_PROCESSOR", cmProperty::VARIABLE, "The name of the CPU CMake is running on.", "The same as CMAKE_SYSTEM_PROCESSOR but for the host system instead " "of the target system when cross compiling.",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_SYSTEM_VERSION", cmProperty::VARIABLE, "OS version CMake is running on.", "The same as CMAKE_SYSTEM_VERSION but for the host system instead " "of the target system when cross compiling.",false, "Variables That Describe the System"); cm->DefineProperty ("APPLE", cmProperty::VARIABLE, "True if running on Mac OS X.", "Set to true on Mac OS X." ,false, "Variables That Describe the System"); cm->DefineProperty ("BORLAND", cmProperty::VARIABLE, "True if the Borland compiler is being used.", "This is set to true if the Borland compiler is being used.",false, "Variables That Describe the System"); cm->DefineProperty ("CYGWIN", cmProperty::VARIABLE, "True for Cygwin.", "Set to true when using Cygwin." ,false, "Variables That Describe the System"); cm->DefineProperty ("MSVC", cmProperty::VARIABLE, "True when using Microsoft Visual C", "Set to true when the compiler is some version of Microsoft Visual C.", false, "Variables That Describe the System"); int msvc_versions[] = { 60, 70, 71, 80, 90, 100, 110, 120, 0 }; for (int i = 0; msvc_versions[i] != 0; i ++) { const char minor = (char)('0' + (msvc_versions[i] % 10)); cmStdString varName = "MSVC"; cmsys_ios::ostringstream majorStr; majorStr << (msvc_versions[i] / 10); varName += majorStr.str(); if (msvc_versions[i] < 100) { varName += minor; } cmStdString verString = majorStr.str() + "." + minor; cmStdString shortStr = "True when using Microsoft Visual C " + verString; cmStdString fullStr = "Set to true when the compiler is version " + verString + " of Microsoft Visual C."; cm->DefineProperty (varName.c_str(), cmProperty::VARIABLE, shortStr.c_str(), fullStr.c_str(), false, "Variables That Describe the System"); } cm->DefineProperty ("MSVC_IDE", cmProperty::VARIABLE, "True when using the Microsoft Visual C IDE", "Set to true when the target platform is the Microsoft Visual C IDE, " "as opposed to the command line compiler.", false, "Variables That Describe the System"); cm->DefineProperty ("MSVC_VERSION", cmProperty::VARIABLE, "The version of Microsoft Visual C/C++ being used if any.", "Known version numbers are:\n" " 1200 = VS 6.0\n" " 1300 = VS 7.0\n" " 1310 = VS 7.1\n" " 1400 = VS 8.0\n" " 1500 = VS 9.0\n" " 1600 = VS 10.0\n" " 1700 = VS 11.0\n" " 1800 = VS 12.0\n" "", false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_CL_64", cmProperty::VARIABLE, "Using the 64 bit compiler from Microsoft", "Set to true when using the 64 bit cl compiler from Microsoft.", false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_COMPILER_2005", cmProperty::VARIABLE, "Using the Visual Studio 2005 compiler from Microsoft", "Set to true when using the Visual Studio 2005 compiler " "from Microsoft.", false, "Variables That Describe the System"); cm->DefineProperty ("UNIX", cmProperty::VARIABLE, "True for UNIX and UNIX like operating systems.", "Set to true when the target system is UNIX or UNIX like " "(i.e. APPLE and CYGWIN).",false, "Variables That Describe the System"); cm->DefineProperty ("WIN32", cmProperty::VARIABLE, "True on windows systems, including win64.", "Set to true when the target system is Windows.",false, "Variables That Describe the System"); cm->DefineProperty ("XCODE_VERSION", cmProperty::VARIABLE, "Version of Xcode (Xcode generator only).", "Under the Xcode generator, this is the version of Xcode as specified in " "\"Xcode.app/Contents/version.plist\" (such as \"3.1.2\").",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_APPLE", cmProperty::VARIABLE, "True for Apple OS X operating systems.", "Set to true when the host system is Apple OS X.", false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_UNIX", cmProperty::VARIABLE, "True for UNIX and UNIX like operating systems.", "Set to true when the host system is UNIX or UNIX like " "(i.e. APPLE and CYGWIN).",false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_HOST_WIN32", cmProperty::VARIABLE, "True on windows systems, including win64.", "Set to true when the host system is Windows and on Cygwin." ,false, "Variables That Describe the System"); cm->DefineProperty ("CMAKE_OBJECT_PATH_MAX", cmProperty::VARIABLE, "Maximum object file full-path length allowed by native build tools.", "CMake computes for every source file an object file name that is " "unique to the source file and deterministic with respect to the " "full path to the source file. " "This allows multiple source files in a target to share the same name " "if they lie in different directories without rebuilding when one is " "added or removed. " "However, it can produce long full paths in a few cases, so CMake " "shortens the path using a hashing scheme when the full path to an " "object file exceeds a limit. " "CMake has a built-in limit for each platform that is sufficient for " "common tools, but some native tools may have a lower limit. " "This variable may be set to specify the limit explicitly. " "The value must be an integer no less than 128.",false, "Variables That Describe the System"); cm->DefineProperty ("ENV", cmProperty::VARIABLE, "Access environment variables.", "Use the syntax $ENV{VAR} to read environment variable VAR. " "See also the set() command to set ENV{VAR}." ,false, "Variables That Describe the System"); // Variables that affect the building of object files and // targets. // cm->DefineProperty ("CMAKE_INCLUDE_CURRENT_DIR", cmProperty::VARIABLE, "Automatically add the current source- and build directories " "to the include path.", "If this variable is enabled, CMake automatically adds in each " "directory ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} " "to the include path for this directory. These additional include " "directories do not propagate down to subdirectories. This is useful " "mainly for out-of-source builds, where files generated into the " "build tree are included by files located in the source tree.\n" "By default CMAKE_INCLUDE_CURRENT_DIR is OFF.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE", cmProperty::VARIABLE, "Automatically add the current source- and build directories " "to the INTERFACE_INCLUDE_DIRECTORIES.", "If this variable is enabled, CMake automatically adds for each shared " "library target, static library target, module target and executable " "target, ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} to " "the INTERFACE_INCLUDE_DIRECTORIES." "By default CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE is OFF.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_INSTALL_RPATH", cmProperty::VARIABLE, "The rpath to use for installed targets.", "A semicolon-separated list specifying the rpath " "to use in installed targets (for platforms that support it). " "This is used to initialize the target property " "INSTALL_RPATH for all targets.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_INSTALL_RPATH_USE_LINK_PATH", cmProperty::VARIABLE, "Add paths to linker search and installed rpath.", "CMAKE_INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true " "will append directories in the linker search path and outside the " "project to the INSTALL_RPATH. " "This is used to initialize the target property " "INSTALL_RPATH_USE_LINK_PATH for all targets.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_INSTALL_NAME_DIR", cmProperty::VARIABLE, "Mac OS X directory name for installed targets.", "CMAKE_INSTALL_NAME_DIR is used to initialize the " "INSTALL_NAME_DIR property on all targets. See that target " "property for more information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_Fortran_FORMAT", cmProperty::VARIABLE, "Set to FIXED or FREE to indicate the Fortran source layout.", "This variable is used to initialize the Fortran_FORMAT " "property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_Fortran_MODULE_DIRECTORY", cmProperty::VARIABLE, "Fortran module output directory.", "This variable is used to initialize the " "Fortran_MODULE_DIRECTORY property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LIBRARY_OUTPUT_DIRECTORY", cmProperty::VARIABLE, "Where to put all the LIBRARY targets when built.", "This variable is used to initialize the " "LIBRARY_OUTPUT_DIRECTORY property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_ARCHIVE_OUTPUT_DIRECTORY", cmProperty::VARIABLE, "Where to put all the ARCHIVE targets when built.", "This variable is used to initialize the " "ARCHIVE_OUTPUT_DIRECTORY property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_RUNTIME_OUTPUT_DIRECTORY", cmProperty::VARIABLE, "Where to put all the RUNTIME targets when built.", "This variable is used to initialize the " "RUNTIME_OUTPUT_DIRECTORY property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_PDB_OUTPUT_DIRECTORY", cmProperty::VARIABLE, "Where to put all the MS debug symbol files from linker.", "This variable is used to initialize the " "PDB_OUTPUT_DIRECTORY property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LINK_DEPENDS_NO_SHARED", cmProperty::VARIABLE, "Whether to skip link dependencies on shared library files.", "This variable initializes the LINK_DEPENDS_NO_SHARED " "property on targets when they are created. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_AUTOMOC", cmProperty::VARIABLE, "Whether to handle moc automatically for Qt targets.", "This variable is used to initialize the " "AUTOMOC property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_AUTOMOC_MOC_OPTIONS", cmProperty::VARIABLE, "Additional options for moc when using automoc (see CMAKE_AUTOMOC).", "This variable is used to initialize the " "AUTOMOC_MOC_OPTIONS property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_GNUtoMS", cmProperty::VARIABLE, "Convert GNU import libraries (.dll.a) to MS format (.lib).", "This variable is used to initialize the GNUtoMS property on targets " "when they are created. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_DEBUG_POSTFIX", cmProperty::VARIABLE, "See variable CMAKE__POSTFIX.", "This variable is a special case of the more-general " "CMAKE__POSTFIX variable for the DEBUG configuration.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE__POSTFIX", cmProperty::VARIABLE, "Default filename postfix for libraries under configuration .", "When a non-executable target is created its _POSTFIX " "target property is initialized with the value of this variable " "if it is set.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_BUILD_WITH_INSTALL_RPATH", cmProperty::VARIABLE, "Use the install path for the RPATH", "Normally CMake uses the build tree for the RPATH when building " "executables etc on systems that use RPATH. When the software " "is installed the executables etc are relinked by CMake to have " "the install RPATH. If this variable is set to true then the software " "is always built with the install path for the RPATH and does not " "need to be relinked when installed.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_NO_BUILTIN_CHRPATH", cmProperty::VARIABLE, "Do not use the builtin ELF editor to fix RPATHs on installation.", "When an ELF binary needs to have a different RPATH after installation " "than it does in the build tree, CMake uses a builtin editor to change " "the RPATH in the installed copy. " "If this variable is set to true then CMake will relink the binary " "before installation instead of using its builtin editor.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_SKIP_BUILD_RPATH", cmProperty::VARIABLE, "Do not include RPATHs in the build tree.", "Normally CMake uses the build tree for the RPATH when building " "executables etc on systems that use RPATH. When the software " "is installed the executables etc are relinked by CMake to have " "the install RPATH. If this variable is set to true then the software " "is always built with no RPATH.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_SKIP_INSTALL_RPATH", cmProperty::VARIABLE, "Do not include RPATHs in the install tree.", "Normally CMake uses the build tree for the RPATH when building " "executables etc on systems that use RPATH. When the software " "is installed the executables etc are relinked by CMake to have " "the install RPATH. If this variable is set to true then the software " "is always installed without RPATH, even if RPATH is enabled when " "building. This can be useful for example to allow running tests from " "the build directory with RPATH enabled before the installation step. " "To omit RPATH in both the build and install steps, use " "CMAKE_SKIP_RPATH instead.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_EXE_LINKER_FLAGS", cmProperty::VARIABLE, "Linker flags to be used to create executables.", "These flags will be used by the linker when creating an executable." ,false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_EXE_LINKER_FLAGS_", cmProperty::VARIABLE, "Flags to be used when linking an executable.", "Same as CMAKE_C_FLAGS_* but used by the linker " "when creating executables.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LIBRARY_PATH_FLAG", cmProperty::VARIABLE, "The flag to be used to add a library search path to a compiler.", "The flag will be used to specify a library directory to the compiler. " "On most compilers this is \"-L\".",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LINK_DEF_FILE_FLAG ", cmProperty::VARIABLE, "Linker flag to be used to specify a .def file for dll creation.", "The flag will be used to add a .def file when creating " "a dll on Windows; this is only defined on Windows." ,false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LINK_LIBRARY_FLAG", cmProperty::VARIABLE, "Flag to be used to link a library into an executable.", "The flag will be used to specify a library to link to an executable. " "On most compilers this is \"-l\".",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LINK_LIBRARY_FILE_FLAG", cmProperty::VARIABLE, "Flag to be used to link a library specified by a path to its file.", "The flag will be used before a library file path is given to the " "linker. " "This is needed only on very few platforms.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_USE_RELATIVE_PATHS", cmProperty::VARIABLE, "Use relative paths (May not work!).", "If this is set to TRUE, then CMake will use " "relative paths between the source and binary tree. " "This option does not work for more complicated " "projects, and relative paths are used when possible. " "In general, it is not possible to move CMake generated" " makefiles to a different location regardless " "of the value of this variable.",false, "Variables that Control the Build"); cm->DefineProperty ("EXECUTABLE_OUTPUT_PATH", cmProperty::VARIABLE, "Old executable location variable.", "The target property RUNTIME_OUTPUT_DIRECTORY supercedes " "this variable for a target if it is set. " "Executable targets are otherwise placed in this directory.",false, "Variables that Control the Build"); cm->DefineProperty ("LIBRARY_OUTPUT_PATH", cmProperty::VARIABLE, "Old library location variable.", "The target properties ARCHIVE_OUTPUT_DIRECTORY, " "LIBRARY_OUTPUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY supercede " "this variable for a target if they are set. " "Library targets are otherwise placed in this directory.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_TRY_COMPILE_CONFIGURATION", cmProperty::VARIABLE, "Build configuration used for try_compile and try_run projects.", "Projects built by try_compile and try_run are built " "synchronously during the CMake configuration step. " "Therefore a specific build configuration must be chosen even " "if the generated build system supports multiple configurations.",false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_LINK_INTERFACE_LIBRARIES", cmProperty::VARIABLE, "Default value for LINK_INTERFACE_LIBRARIES of targets.", "This variable is used to initialize the " "LINK_INTERFACE_LIBRARIES property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_WIN32_EXECUTABLE", cmProperty::VARIABLE, "Default value for WIN32_EXECUTABLE of targets.", "This variable is used to initialize the " "WIN32_EXECUTABLE property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_MACOSX_BUNDLE", cmProperty::VARIABLE, "Default value for MACOSX_BUNDLE of targets.", "This variable is used to initialize the " "MACOSX_BUNDLE property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); cm->DefineProperty ("CMAKE_POSITION_INDEPENDENT_CODE", cmProperty::VARIABLE, "Default value for POSITION_INDEPENDENT_CODE of targets.", "This variable is used to initialize the " "POSITION_INDEPENDENT_CODE property on all the targets. " "See that target property for additional information.", false, "Variables that Control the Build"); // Variables defined when the a language is enabled These variables will // also be defined whenever CMake has loaded its support for compiling (LANG) // programs. This support will be loaded whenever CMake is used to compile // (LANG) files. C and CXX are examples of the most common values for (LANG). cm->DefineProperty ("CMAKE_USER_MAKE_RULES_OVERRIDE_", cmProperty::VARIABLE, "Specify a CMake file that overrides platform information for .", "This is a language-specific version of " "CMAKE_USER_MAKE_RULES_OVERRIDE loaded only when enabling " "language .",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__COMPILER", cmProperty::VARIABLE, "The full path to the compiler for LANG.", "This is the command that will be used as the compiler. " "Once set, you can not change this variable.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__COMPILER_ID", cmProperty::VARIABLE, "Compiler identification string.", "A short string unique to the compiler vendor. " "Possible values include:\n" " Absoft = Absoft Fortran (absoft.com)\n" " ADSP = Analog VisualDSP++ (analog.com)\n" " Clang = LLVM Clang (clang.llvm.org)\n" " Cray = Cray Compiler (cray.com)\n" " Embarcadero, Borland = Embarcadero (embarcadero.com)\n" " G95 = G95 Fortran (g95.org)\n" " GNU = GNU Compiler Collection (gcc.gnu.org)\n" " HP = Hewlett-Packard Compiler (hp.com)\n" " Intel = Intel Compiler (intel.com)\n" " MIPSpro = SGI MIPSpro (sgi.com)\n" " MSVC = Microsoft Visual Studio (microsoft.com)\n" " PGI = The Portland Group (pgroup.com)\n" " PathScale = PathScale (pathscale.com)\n" " SDCC = Small Device C Compiler (sdcc.sourceforge.net)\n" " SunPro = Oracle Solaris Studio (oracle.com)\n" " TI = Texas Instruments (ti.com)\n" " TinyCC = Tiny C Compiler (tinycc.org)\n" " Watcom = Open Watcom (openwatcom.org)\n" " XL, VisualAge, zOS = IBM XL (ibm.com)\n" "This variable is not guaranteed to be defined for all " "compilers or languages.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__PLATFORM_ID", cmProperty::VARIABLE, "An internal variable subject to change.", "This is used in determining the platform and is subject to change.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__COMPILER_ABI", cmProperty::VARIABLE, "An internal variable subject to change.", "This is used in determining the compiler ABI and is subject to change.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__COMPILER_VERSION", cmProperty::VARIABLE, "Compiler version string.", "Compiler version in major[.minor[.patch[.tweak]]] format. " "This variable is not guaranteed to be defined for all " "compilers or languages.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE_INTERNAL_PLATFORM_ABI", cmProperty::VARIABLE, "An internal variable subject to change.", "This is used in determining the compiler ABI and is subject to change.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__SIZEOF_DATA_PTR", cmProperty::VARIABLE, "Size of pointer-to-data types for language .", "This holds the size (in bytes) of pointer-to-data types in the target " "platform ABI. " "It is defined for languages C and CXX (C++).", false, "Variables for Languages"); cm->DefineProperty ("CMAKE_COMPILER_IS_GNU", cmProperty::VARIABLE, "True if the compiler is GNU.", "If the selected compiler is the GNU " "compiler then this is TRUE, if not it is FALSE. " "Unlike the other per-language variables, this uses the GNU syntax for " "identifying languages instead of the CMake syntax. Recognized values of " "the suffix are:\n" " CC = C compiler\n" " CXX = C++ compiler\n" " G77 = Fortran compiler", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__FLAGS_DEBUG", cmProperty::VARIABLE, "Flags for Debug build type or configuration.", " flags used when CMAKE_BUILD_TYPE is Debug.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__FLAGS_MINSIZEREL", cmProperty::VARIABLE, "Flags for MinSizeRel build type or configuration.", " flags used when CMAKE_BUILD_TYPE is MinSizeRel." "Short for minimum size release.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__FLAGS_RELEASE", cmProperty::VARIABLE, "Flags for Release build type or configuration.", " flags used when CMAKE_BUILD_TYPE is Release",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__FLAGS_RELWITHDEBINFO", cmProperty::VARIABLE, "Flags for RelWithDebInfo type or configuration.", " flags used when CMAKE_BUILD_TYPE is RelWithDebInfo. " "Short for Release With Debug Information.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__COMPILE_OBJECT", cmProperty::VARIABLE, "Rule variable to compile a single object file.", "This is a rule variable that tells CMake how to " "compile a single object file for the language ." ,false, "Variables for Languages"); cm->DefineProperty ("CMAKE__CREATE_SHARED_LIBRARY", cmProperty::VARIABLE, "Rule variable to create a shared library.", "This is a rule variable that tells CMake how to " "create a shared library for the language .",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__CREATE_SHARED_MODULE", cmProperty::VARIABLE, "Rule variable to create a shared module.", "This is a rule variable that tells CMake how to " "create a shared library for the language .",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__CREATE_STATIC_LIBRARY", cmProperty::VARIABLE, "Rule variable to create a static library.", "This is a rule variable that tells CMake how " "to create a static library for the language .",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__ARCHIVE_CREATE", cmProperty::VARIABLE, "Rule variable to create a new static archive.", "This is a rule variable that tells CMake how to create a static " "archive. It is used in place of CMAKE__CREATE_STATIC_LIBRARY " "on some platforms in order to support large object counts. " "See also CMAKE__ARCHIVE_APPEND and CMAKE__ARCHIVE_FINISH.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__ARCHIVE_APPEND", cmProperty::VARIABLE, "Rule variable to append to a static archive.", "This is a rule variable that tells CMake how to append to a static " "archive. It is used in place of CMAKE__CREATE_STATIC_LIBRARY " "on some platforms in order to support large object counts. " "See also CMAKE__ARCHIVE_CREATE and CMAKE__ARCHIVE_FINISH.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__ARCHIVE_FINISH", cmProperty::VARIABLE, "Rule variable to finish an existing static archive.", "This is a rule variable that tells CMake how to finish a static " "archive. It is used in place of CMAKE__CREATE_STATIC_LIBRARY " "on some platforms in order to support large object counts. " "See also CMAKE__ARCHIVE_CREATE and CMAKE__ARCHIVE_APPEND.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__IGNORE_EXTENSIONS", cmProperty::VARIABLE, "File extensions that should be ignored by the build.", "This is a list of file extensions that may be " "part of a project for a given language but are not compiled. ",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__IMPLICIT_INCLUDE_DIRECTORIES", cmProperty::VARIABLE, "Directories implicitly searched by the compiler for header files.", "CMake does not explicitly specify these directories on compiler " "command lines for language . " "This prevents system include directories from being treated as user " "include directories on some compilers.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__IMPLICIT_LINK_DIRECTORIES", cmProperty::VARIABLE, "Implicit linker search path detected for language .", "Compilers typically pass directories containing language runtime " "libraries and default library search paths when they invoke a linker. " "These paths are implicit linker search directories for the compiler's " "language. " "CMake automatically detects these directories for each language and " "reports the results in this variable." "\n" "When a library in one of these directories is given by full path to " "target_link_libraries() CMake will generate the -l form on " "link lines to ensure the linker searches its implicit directories " "for the library. " "Note that some toolchains read implicit directories from an " "environment variable such as LIBRARY_PATH so keep its value " "consistent when operating in a given build tree.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__IMPLICIT_LINK_FRAMEWORK_DIRECTORIES", cmProperty::VARIABLE, "Implicit linker framework search path detected for language .", "These paths are implicit linker framework search directories for " "the compiler's language. " "CMake automatically detects these directories for each language and " "reports the results in this variable.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__IMPLICIT_LINK_LIBRARIES", cmProperty::VARIABLE, "Implicit link libraries and flags detected for language .", "Compilers typically pass language runtime library names and " "other flags when they invoke a linker. " "These flags are implicit link options for the compiler's language. " "CMake automatically detects these libraries and flags for each " "language and reports the results in this variable.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__LIBRARY_ARCHITECTURE", cmProperty::VARIABLE, "Target architecture library directory name detected for .", "If the compiler passes to the linker an architecture-specific " "system library search directory such as /lib/ this " "variable contains the name if/as detected by CMake.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__LINKER_PREFERENCE_PROPAGATES", cmProperty::VARIABLE, "True if CMAKE__LINKER_PREFERENCE propagates across targets.", "This is used when CMake selects a linker language for a target. " "Languages compiled directly into the target are always considered. " "A language compiled into static libraries linked by the target is " "considered if this variable is true.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__LINKER_PREFERENCE", cmProperty::VARIABLE, "Preference value for linker language selection.", "The \"linker language\" for executable, shared library, and module " "targets is the language whose compiler will invoke the linker. " "The LINKER_LANGUAGE target property sets the language explicitly. " "Otherwise, the linker language is that whose linker preference value " "is highest among languages compiled and linked into the target. " "See also the CMAKE__LINKER_PREFERENCE_PROPAGATES variable.", false, "Variables for Languages"); cm->DefineProperty ("CMAKE__LINK_EXECUTABLE ", cmProperty::VARIABLE, "Rule variable to link an executable.", "Rule variable to link an executable for the given language." ,false, "Variables for Languages"); cm->DefineProperty ("CMAKE__OUTPUT_EXTENSION", cmProperty::VARIABLE, "Extension for the output of a compile for a single file.", "This is the extension for an object file for " "the given . For example .obj for C on Windows.",false, "Variables for Languages"); cm->DefineProperty ("CMAKE__SOURCE_FILE_EXTENSIONS", cmProperty::VARIABLE, "Extensions of source files for the given language.", "This is the list of extensions for a " "given language's source files." ,false, "Variables for Languages"); cm->DefineProperty( "CMAKE__COMPILER_LOADED", cmProperty::VARIABLE, "Defined to true if the language is enabled.", "When language is enabled by project() or enable_language() " "this variable is defined to 1.", false,"Variables for Languages"); cm->DefineProperty( "CMAKE_Fortran_MODDIR_FLAG", cmProperty::VARIABLE, "Fortran flag for module output directory.", "This stores the flag needed to pass the value of the " "Fortran_MODULE_DIRECTORY target property to the compiler.", false,"Variables for Languages"); cm->DefineProperty( "CMAKE_Fortran_MODDIR_DEFAULT", cmProperty::VARIABLE, "Fortran default module output directory.", "Most Fortran compilers write .mod files to the current working " "directory. " "For those that do not, this is set to \".\" and used when the " "Fortran_MODULE_DIRECTORY target property is not set.", false,"Variables for Languages"); cm->DefineProperty( "CMAKE_Fortran_MODOUT_FLAG", cmProperty::VARIABLE, "Fortran flag to enable module output.", "Most Fortran compilers write .mod files out by default. " "For others, this stores the flag needed to enable module output.", false,"Variables for Languages"); // variables that are used by cmake but not to be documented cm->DefineProperty("CMAKE_MATCH_0", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_1", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_2", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_3", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_4", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_5", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_6", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_7", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_8", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MATCH_9", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__COMPILER_ARG1", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__COMPILER_ENV_VAR", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__COMPILER_ID_RUN", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__ABI_FILES", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__CREATE_ASSEMBLY_SOURCE", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__CREATE_PREPROCESSED_SOURCE", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__FLAGS_DEBUG_INIT", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__FLAGS_INIT", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__FLAGS_MINSIZEREL_INIT", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__FLAGS_RELEASE_INIT", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__FLAGS_RELWITHDEBINFO_INIT", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__INFORMATION_LOADED", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__LINK_EXECUTABLE", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__LINK_FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__RESPONSE_FILE_LINK_FLAG", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__STANDARD_LIBRARIES", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__STANDARD_LIBRARIES_INIT", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__USE_RESPONSE_FILE_FOR_INCLUDES", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE__USE_RESPONSE_FILE_FOR_OBJECTS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_EXECUTABLE_SUFFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_EXE_LINK_DYNAMIC__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_EXE_LINK_STATIC__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_GENERATOR_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_IMPORT_LIBRARY_PREFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_IMPORT_LIBRARY_SUFFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_INCLUDE_FLAG_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_INCLUDE_FLAG_SEP_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_INCLUDE_SYSTEM_FLAG_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_NEEDS_REQUIRES_STEP__FLAG", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_CREATE__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_DYNAMIC__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_STATIC__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_PREFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_SUFFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_RUNTIME__FLAG", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_RUNTIME__FLAG_SEP", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_LIBRARY_RPATH_LINK__FLAG", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_EXECUTABLE_RUNTIME__FLAG", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_EXECUTABLE_RUNTIME__FLAG_SEP", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_EXECUTABLE_RPATH_LINK__FLAG", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH", cmProperty::VARIABLE,0,0); cm->DefineProperty( "CMAKE__USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_MODULE_CREATE__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_MODULE__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_MODULE_LINK_DYNAMIC__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_MODULE_LINK_STATIC__FLAGS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_MODULE_PREFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_SHARED_MODULE_SUFFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_STATIC_LIBRARY_PREFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_STATIC_LIBRARY_SUFFIX_", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_LINK_DEPENDENT_LIBRARY_FILES", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS", cmProperty::VARIABLE,0,0); cm->DefineProperty("CMAKE_MAKE_INCLUDE_FROM_ROOT", cmProperty::VARIABLE,0,0); }