Source/cmDocumentVariables.cxx

   1 #include "cmDocumentVariables.h"
   2 #include "cmake.h"
   3
   4 #include <cmsys/ios/sstream>
   5
   6 void cmDocumentVariables::DefineVariables(cmake* cm)
   7 {
   8   // Subsection: variables defined by cmake, that give
   9   // information about the project, and cmake
  10   cm->DefineProperty
  11     ("CMAKE_AR", cmProperty::VARIABLE,
  12      "Name of archiving tool for static libraries.",
  13      "This specifies name of the program that creates archive "
  14      "or static libraries.",false,
  15      "Variables that Provide Information");
  16
  17   cm->DefineProperty
  18     ("CMAKE_COMMAND", cmProperty::VARIABLE,
  19      "The full path to the cmake executable.",
  20      "This is the full path to the CMake executable cmake which is "
  21      "useful from custom commands that want to use the cmake -E "
  22      "option for portable system commands. "
  23      "(e.g. /usr/local/bin/cmake", false,
  24      "Variables that Provide Information");
  25   cm->DefineProperty
  26     ("CMAKE_BINARY_DIR", cmProperty::VARIABLE,
  27      "The path to the top level of the build tree.",
  28      "This is the full path to the top level of the current CMake "
  29      "build tree. For an in-source build, this would be the same "
  30      "as CMAKE_SOURCE_DIR. ", false,
  31      "Variables that Provide Information");
  32   cm->DefineProperty
  33     ("CMAKE_SOURCE_DIR", cmProperty::VARIABLE,
  34      "The path to the top level of the source tree.",
  35      "This is the full path to the top level of the current CMake "
  36      "source tree. For an in-source build, this would be the same "
  37      "as CMAKE_BINARY_DIR. ", false,
  38      "Variables that Provide Information");
  39   cm->DefineProperty
  40     ("CMAKE_CURRENT_BINARY_DIR", cmProperty::VARIABLE,
  41      "The path to the binary directory currently being processed.",
  42      "This the full path to the build directory that is currently "
  43      "being processed by cmake.  Each directory added by "
  44      "add_subdirectory will create a binary directory in the build "
  45      "tree, and as it is being processed this variable will be set. "
  46      "For in-source builds this is the current source directory "
  47      "being processed.", false,
  48      "Variables that Provide Information");
  49   cm->DefineProperty
  50     ("CMAKE_CURRENT_SOURCE_DIR", cmProperty::VARIABLE,
  51      "The path to the source directory currently being processed.",
  52      "This the full path to the source directory that is currently "
  53      "being processed by cmake.  ", false,
  54      "Variables that Provide Information");
  55
  56   cm->DefineProperty
  57     ("CMAKE_CURRENT_LIST_FILE", cmProperty::VARIABLE,
  58      "Full path to the listfile currently being processed.",
  59      "As CMake processes the listfiles in your project this "
  60      "variable will always be set to the one currently being "
  61      "processed.  "
  62      "The value has dynamic scope.  "
  63      "When CMake starts processing commands in a source file "
  64      "it sets this variable to the location of the file.  "
  65      "When CMake finishes processing commands from the file it "
  66      "restores the previous value.  "
  67      "Therefore the value of the variable inside a macro or "
  68      "function is the file invoking the bottom-most entry on "
  69      "the call stack, not the file containing the macro or "
  70      "function definition."
  71      "\n"
  72      "See also CMAKE_PARENT_LIST_FILE.",false,
  73      "Variables that Provide Information");
  74
  75   cm->DefineProperty
  76     ("CMAKE_CURRENT_LIST_LINE", cmProperty::VARIABLE,
  77      "The line number of the current file being processed.",
  78      "This is the line number of the file currently being"
  79      " processed by cmake.", false,
  80      "Variables that Provide Information");
  81
  82   cm->DefineProperty
  83     ("CMAKE_CURRENT_LIST_DIR", cmProperty::VARIABLE,
  84      "Full directory of the listfile currently being processed.",
  85      "As CMake processes the listfiles in your project this "
  86      "variable will always be set to the directory where the listfile which "
  87      "is currently being processed (CMAKE_CURRENT_LIST_FILE) is located.  "
  88      "The value has dynamic scope.  "
  89      "When CMake starts processing commands in a source file "
  90      "it sets this variable to the directory where this file is located.  "
  91      "When CMake finishes processing commands from the file it "
  92      "restores the previous value.  "
  93      "Therefore the value of the variable inside a macro or "
  94      "function is the directory of the file invoking the bottom-most entry on "
  95      "the call stack, not the directory of the file containing the macro or "
  96      "function definition."
  97      "\n"
  98      "See also CMAKE_CURRENT_LIST_FILE.",false,
  99      "Variables that Provide Information");
 100
 101   cm->DefineProperty
 102     ("CMAKE_SCRIPT_MODE_FILE", cmProperty::VARIABLE,
 103      "Full path to the -P script file currently being processed. ",
 104      "When run in -P script mode, CMake sets this variable to the full "
 105      "path of the script file. When run to configure a CMakeLists.txt "
 106      "file, this variable is not set.", false,
 107      "Variables that Provide Information");
 108
 109   cm->DefineProperty
 110     ("CMAKE_ARGC", cmProperty::VARIABLE,
 111      "Number of command line arguments passed to CMake in script mode. ",
 112      "When run in -P script mode, CMake sets this variable to the number "
 113      "of command line arguments. See also CMAKE_ARGV0, 1, 2 ... ", false,
 114      "Variables that Provide Information");
 115
 116   cm->DefineProperty
 117     ("CMAKE_ARGV0", cmProperty::VARIABLE,
 118      "Command line argument passed to CMake in script mode. ",
 119      "When run in -P script mode, CMake sets this variable to "
 120      "the first command line argument. It then also sets CMAKE_ARGV1, "
 121      "CMAKE_ARGV2, ... and so on, up to the number of command line arguments "
 122      "given. See also CMAKE_ARGC.", false,
 123      "Variables that Provide Information");
 124
 125   cm->DefineProperty
 126     ("CMAKE_BUILD_TOOL", cmProperty::VARIABLE,
 127      "Tool used for the actual build process.",
 128      "This variable is set to the program that will be"
 129      " needed to build the output of CMake.   If the "
 130      "generator selected was Visual Studio 6, the "
 131      "CMAKE_BUILD_TOOL will be set to msdev, for "
 132      "Unix makefiles it will be set to make or gmake, "
 133      "and for Visual Studio 7 it set to devenv.  For "
 134      "Nmake Makefiles the value is nmake. This can be "
 135      "useful for adding special flags and commands based"
 136      " on the final build environment. ", false,
 137      "Variables that Provide Information");
 138   cm->DefineProperty
 139     ("CMAKE_CROSSCOMPILING", cmProperty::VARIABLE,
 140      "Is CMake currently cross compiling.",
 141      "This variable will be set to true by CMake if CMake is cross "
 142      "compiling. Specifically if the build platform is different "
 143      "from the target platform.", false,
 144      "Variables that Provide Information");
 145   cm->DefineProperty
 146     ("CMAKE_CACHEFILE_DIR", cmProperty::VARIABLE,
 147      "The directory with the CMakeCache.txt file.",
 148      "This is the full path to the directory that has the "
 149      "CMakeCache.txt file in it.  This is the same as "
 150      "CMAKE_BINARY_DIR.", false,
 151      "Variables that Provide Information");
 152   cm->DefineProperty
 153     ("CMAKE_CACHE_MAJOR_VERSION", cmProperty::VARIABLE,
 154      "Major version of CMake used to create the CMakeCache.txt file",
 155      "This is stores the major version of CMake used to "
 156      "write a CMake cache file. It is only different when "
 157      "a different version of CMake is run on a previously "
 158      "created cache file.", false,
 159      "Variables that Provide Information");
 160   cm->DefineProperty
 161     ("CMAKE_CACHE_MINOR_VERSION", cmProperty::VARIABLE,
 162      "Minor version of CMake used to create the CMakeCache.txt file",
 163      "This is stores the minor version of CMake used to "
 164      "write a CMake cache file. It is only different when "
 165      "a different version of CMake is run on a previously "
 166      "created cache file.", false,
 167      "Variables that Provide Information");
 168
 169   cm->DefineProperty
 170     ("CMAKE_CACHE_PATCH_VERSION", cmProperty::VARIABLE,
 171      "Patch version of CMake used to create the CMakeCache.txt file",
 172      "This is stores the patch version of CMake used to "
 173      "write a CMake cache file. It is only different when "
 174      "a different version of CMake is run on a previously "
 175      "created cache file.", false,
 176      "Variables that Provide Information");
 177
 178   cm->DefineProperty
 179     ("CMAKE_CFG_INTDIR", cmProperty::VARIABLE,
 180      "Build-time reference to per-configuration output subdirectory.",
 181      "For native build systems supporting multiple configurations "
 182      "in the build tree (such as Visual Studio and Xcode), "
 183      "the value is a reference to a build-time variable specifying "
 184      "the name of the per-configuration output subdirectory.  "
 185      "On Makefile generators this evaluates to \".\" because there "
 186      "is only one configuration in a build tree.  "
 187      "Example values:\n"
 188      "  $(IntDir)        = Visual Studio 6\n"
 189      "  $(OutDir)        = Visual Studio 7, 8, 9\n"
 190      "  $(Configuration) = Visual Studio 10\n"
 191      "  $(CONFIGURATION) = Xcode\n"
 192      "  .                = Make-based tools\n"
 193      "Since these values are evaluated by the native build system, this "
 194      "variable is suitable only for use in command lines that will be "
 195      "evaluated at build time.  "
 196      "Example of intended usage:\n"
 197      "  add_executable(mytool mytool.c)\n"
 198      "  add_custom_command(\n"
 199      "    OUTPUT out.txt\n"
 200      "    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool\n"
 201      "            ${CMAKE_CURRENT_SOURCE_DIR}/in.txt out.txt\n"
 202      "    DEPENDS mytool in.txt\n"
 203      "    )\n"
 204      "  add_custom_target(drive ALL DEPENDS out.txt)\n"
 205      "Note that CMAKE_CFG_INTDIR is no longer necessary for this purpose "
 206      "but has been left for compatibility with existing projects.  "
 207      "Instead add_custom_command() recognizes executable target names in "
 208      "its COMMAND option, so "
 209      "\"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool\" can be "
 210      "replaced by just \"mytool\"."
 211      "\n"
 212      "This variable is read-only.  Setting it is undefined behavior.  "
 213      "In multi-configuration build systems the value of this variable "
 214      "is passed as the value of preprocessor symbol \"CMAKE_INTDIR\" to "
 215      "the compilation of all source files.",false,
 216      "Variables that Provide Information");
 217
 218   cm->DefineProperty
 219     ("CMAKE_CTEST_COMMAND", cmProperty::VARIABLE,
 220      "Full path to ctest command installed with cmake.",
 221      "This is the full path to the CTest executable ctest "
 222      "which is useful from custom commands that want "
 223      "to use the cmake -E option for portable system "
 224      "commands.",false,
 225      "Variables that Provide Information");
 226
 227   cm->DefineProperty
 228     ("CMAKE_DL_LIBS", cmProperty::VARIABLE,
 229      "Name of library containing dlopen and dlcose.",
 230      "The name of the library that has dlopen and "
 231      "dlclose in it, usually -ldl on most UNIX machines.",false,
 232      "Variables that Provide Information");
 233
 234   cm->DefineProperty
 235     ("CMAKE_EDIT_COMMAND", cmProperty::VARIABLE,
 236      "Full path to cmake-gui or ccmake.",
 237      "This is the full path to the CMake executable "
 238      "that can graphically edit the cache.  For example,"
 239      " cmake-gui, ccmake, or cmake -i.",false,
 240      "Variables that Provide Information");
 241
 242   cm->DefineProperty
 243     ("CMAKE_GENERATOR", cmProperty::VARIABLE,
 244      "The generator used to build the project.",
 245      "The name of the generator that is being used to generate the "
 246      "build files.  (e.g. \"Unix Makefiles\", "
 247      "\"Visual Studio 6\", etc.)",false,
 248      "Variables that Provide Information");
 249   cm->DefineProperty
 250     ("CMAKE_EXTRA_GENERATOR", cmProperty::VARIABLE,
 251      "The extra generator used to build the project.",
 252      "When using the Eclipse, CodeBlocks or KDevelop generators, CMake "
 253      "generates Makefiles (CMAKE_GENERATOR) and additionally project files "
 254      "for the respective IDE. This IDE project file generator is stored in "
 255      "CMAKE_EXTRA_GENERATOR (e.g. \"Eclipse CDT4\").",false,
 256      "Variables that Provide Information");
 257   cm->DefineProperty
 258     ("CMAKE_GENERATOR_TOOLSET", cmProperty::VARIABLE,
 259      "Native build system toolset name specified by user.",
 260      "Some CMake generators support a toolset name to be given to the "
 261      "native build system to choose a compiler.  "
 262      "If the user specifies a toolset name (e.g. via the cmake -T option) "
 263      "the value will be available in this variable.",false,
 264      "Variables that Provide Information");
 265   cm->DefineProperty
 266     ("CMAKE_HOME_DIRECTORY", cmProperty::VARIABLE,
 267      "Path to top of source tree.",
 268      "This is the path to the top level of the source tree.",false,
 269      "Variables that Provide Information");
 270   cm->DefineProperty
 271     ("CMAKE_LINK_LIBRARY_SUFFIX", cmProperty::VARIABLE,
 272      "The suffix for libraries that you link to.",
 273      "The suffix to use for the end of a library, .lib on Windows.",false,
 274      "Variables that Provide Information");
 275   cm->DefineProperty
 276     ("CMAKE_EXECUTABLE_SUFFIX", cmProperty::VARIABLE,
 277      "The suffix for executables on this platform.",
 278      "The suffix to use for the end of an executable if any, "
 279      ".exe on Windows."
 280      "\n"
 281      "CMAKE_EXECUTABLE_SUFFIX_<LANG> overrides this for language <LANG>."
 282      ,false, "Variables that Provide Information");
 283   cm->DefineProperty
 284     ("CMAKE_MAJOR_VERSION", cmProperty::VARIABLE,
 285      "The Major version of cmake (i.e. the 2 in 2.X.X)",
 286      "This specifies the major version of the CMake executable"
 287      " being run.",false,
 288      "Variables that Provide Information");
 289   cm->DefineProperty
 290     ("CMAKE_MAKE_PROGRAM", cmProperty::VARIABLE,
 291      "See CMAKE_BUILD_TOOL.",
 292      "This variable is around for backwards compatibility, "
 293      "see CMAKE_BUILD_TOOL.",false,
 294      "Variables that Provide Information");
 295   cm->DefineProperty
 296     ("CMAKE_VS_PLATFORM_TOOLSET", cmProperty::VARIABLE,
 297      "Visual Studio Platform Toolset name.",
 298      "VS 10 and above use MSBuild under the hood and support multiple "
 299      "compiler toolchains.  "
 300      "CMake may specify a toolset explicitly, such as \"v110\" for "
 301      "VS 11 or \"Windows7.1SDK\" for 64-bit support in VS 10 Express.  "
 302      "CMake provides the name of the chosen toolset in this variable."
 303      ,false,
 304      "Variables that Provide Information");
 305   cm->DefineProperty
 306     ("CMAKE_XCODE_PLATFORM_TOOLSET", cmProperty::VARIABLE,
 307      "Xcode compiler selection.",
 308      "Xcode supports selection of a compiler from one of the installed "
 309      "toolsets.  "
 310      "CMake provides the name of the chosen toolset in this variable, "
 311      "if any is explicitly selected (e.g. via the cmake -T option)."
 312      ,false,
 313      "Variables that Provide Information");
 314   cm->DefineProperty
 315     ("CMAKE_MINOR_VERSION", cmProperty::VARIABLE,
 316      "The Minor version of cmake (i.e. the 4 in X.4.X).",
 317      "This specifies the minor version of the CMake"
 318      " executable being run.",false,
 319      "Variables that Provide Information");
 320   cm->DefineProperty
 321     ("CMAKE_PATCH_VERSION", cmProperty::VARIABLE,
 322      "The patch version of cmake (i.e. the 3 in X.X.3).",
 323      "This specifies the patch version of the CMake"
 324      " executable being run.",false,
 325      "Variables that Provide Information");
 326   cm->DefineProperty
 327     ("CMAKE_TWEAK_VERSION", cmProperty::VARIABLE,
 328      "The tweak version of cmake (i.e. the 1 in X.X.X.1).",
 329      "This specifies the tweak version of the CMake executable being run.  "
 330      "Releases use tweak < 20000000 and development versions use the date "
 331      "format CCYYMMDD for the tweak level."
 332      ,false, "Variables that Provide Information");
 333   cm->DefineProperty
 334     ("CMAKE_VERSION", cmProperty::VARIABLE,
 335      "The full version of cmake in major.minor.patch[.tweak[-id]] format.",
 336      "This specifies the full version of the CMake executable being run.  "
 337      "This variable is defined by versions 2.6.3 and higher.  "
 338      "See variables CMAKE_MAJOR_VERSION, CMAKE_MINOR_VERSION, "
 339      "CMAKE_PATCH_VERSION, and CMAKE_TWEAK_VERSION "
 340      "for individual version components.  "
 341      "The [-id] component appears in non-release versions "
 342      "and may be arbitrary text.", false,
 343      "Variables that Provide Information");
 344
 345   cm->DefineProperty
 346     ("CMAKE_PARENT_LIST_FILE", cmProperty::VARIABLE,
 347      "Full path to the parent listfile of the one currently being processed.",
 348      "As CMake processes the listfiles in your project this "
 349      "variable will always be set to the listfile that included "
 350      "or somehow invoked the one currently being "
 351      "processed. See also CMAKE_CURRENT_LIST_FILE.",false,
 352      "Variables that Provide Information");
 353
 354   cm->DefineProperty
 355     ("CMAKE_PROJECT_NAME", cmProperty::VARIABLE,
 356      "The name of the current project.",
 357      "This specifies name of the current project from"
 358      " the closest inherited PROJECT command.",false,
 359      "Variables that Provide Information");
 360   cm->DefineProperty
 361     ("CMAKE_RANLIB", cmProperty::VARIABLE,
 362      "Name of randomizing tool for static libraries.",
 363      "This specifies name of the program that randomizes "
 364      "libraries on UNIX, not used on Windows, but may be present.",false,
 365      "Variables that Provide Information");
 366   cm->DefineProperty
 367     ("CMAKE_ROOT", cmProperty::VARIABLE,
 368      "Install directory for running cmake.",
 369      "This is the install root for the running CMake and"
 370      " the Modules directory can be found here. This is"
 371      " commonly used in this format: ${CMAKE_ROOT}/Modules",false,
 372      "Variables that Provide Information");
 373   cm->DefineProperty
 374     ("CMAKE_SIZEOF_VOID_P", cmProperty::VARIABLE,
 375      "Size of a void pointer.",
 376      "This is set to the size of a pointer on the machine, "
 377      "and is determined by a try compile. If a 64 bit size "
 378      "is found, then the library search path is modified to "
 379      "look for 64 bit libraries first.",false,
 380      "Variables that Provide Information");
 381   cm->DefineProperty
 382     ("CMAKE_SKIP_RPATH", cmProperty::VARIABLE,
 383      "If true, do not add run time path information.",
 384      "If this is set to TRUE, then the rpath information "
 385      "is not added to compiled executables.  The default "
 386      "is to add rpath information if the platform supports it.  "
 387      "This allows for easy running from the build tree.  To omit RPATH "
 388      "in the install step, but not the build step, use "
 389      "CMAKE_SKIP_INSTALL_RPATH instead.",false,
 390      "Variables that Provide Information");
 391   cm->DefineProperty
 392     ("CMAKE_SOURCE_DIR", cmProperty::VARIABLE,
 393      "Source directory for project.",
 394      "This is the top level source directory for the project. "
 395      "It corresponds to the source directory given to "
 396      "cmake-gui or ccmake.",false,
 397      "Variables that Provide Information");
 398   cm->DefineProperty
 399     ("CMAKE_STANDARD_LIBRARIES", cmProperty::VARIABLE,
 400      "Libraries linked into every executable and shared library.",
 401      "This is the list of libraries that are linked "
 402      "into all executables and libraries.",false,
 403      "Variables that Provide Information");
 404   cm->DefineProperty
 405     ("CMAKE_VERBOSE_MAKEFILE", cmProperty::VARIABLE,
 406      "Create verbose makefiles if on.",
 407      "This variable defaults to false. You can set "
 408      "this variable to true to make CMake produce verbose "
 409      "makefiles that show each command line as it is used.",false,
 410      "Variables that Provide Information");
 411   cm->DefineProperty
 412     ("PROJECT_BINARY_DIR", cmProperty::VARIABLE,
 413      "Full path to build directory for project.",
 414      "This is the binary directory of the most recent "
 415      "PROJECT command.",false,"Variables that Provide Information");
 416   cm->DefineProperty
 417     ("PROJECT_NAME", cmProperty::VARIABLE,
 418      "Name of the project given to the project command.",
 419      "This is the name given to the most "
 420      "recent PROJECT command. ",false,
 421      "Variables that Provide Information");
 422   cm->DefineProperty
 423     ("PROJECT_SOURCE_DIR", cmProperty::VARIABLE,
 424      "Top level source directory for the current project.",
 425      "This is the source directory of the most recent "
 426      "PROJECT command.",false,
 427      "Variables that Provide Information");
 428   cm->DefineProperty
 429     ("[Project name]_BINARY_DIR", cmProperty::VARIABLE,
 430      "Top level binary directory for the named project.",
 431      "A variable is created with the name used in the PROJECT "
 432      "command, and is the binary directory for the project.  "
 433      " This can be useful when SUBDIR is used to connect "
 434      "several projects.",false,
 435      "Variables that Provide Information");
 436   cm->DefineProperty
 437     ("[Project name]_SOURCE_DIR", cmProperty::VARIABLE,
 438      "Top level source directory for the named project.",
 439      "A variable is created with the name used in the PROJECT "
 440      "command, and is the source directory for the project."
 441      "   This can be useful when add_subdirectory "
 442      "is used to connect several projects.",false,
 443      "Variables that Provide Information");
 444
 445   cm->DefineProperty
 446     ("CMAKE_IMPORT_LIBRARY_PREFIX", cmProperty::VARIABLE,
 447      "The prefix for import libraries that you link to.",
 448      "The prefix to use for the name of an import library if used "
 449      "on this platform."
 450      "\n"
 451      "CMAKE_IMPORT_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>."
 452      ,false, "Variables that Provide Information");
 453   cm->DefineProperty
 454     ("CMAKE_IMPORT_LIBRARY_SUFFIX", cmProperty::VARIABLE,
 455      "The suffix for import  libraries that you link to.",
 456      "The suffix to use for the end of an import library if used "
 457      "on this platform."
 458      "\n"
 459      "CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>."
 460      ,false, "Variables that Provide Information");
 461   cm->DefineProperty
 462     ("CMAKE_SHARED_LIBRARY_PREFIX", cmProperty::VARIABLE,
 463      "The prefix for shared libraries that you link to.",
 464      "The prefix to use for the name of a shared library, lib on UNIX."
 465      "\n"
 466      "CMAKE_SHARED_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>."
 467      ,false, "Variables that Provide Information");
 468   cm->DefineProperty
 469     ("CMAKE_SHARED_LIBRARY_SUFFIX", cmProperty::VARIABLE,
 470      "The suffix for shared libraries that you link to.",
 471      "The suffix to use for the end of a shared library, .dll on Windows."
 472      "\n"
 473      "CMAKE_SHARED_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>."
 474      ,false, "Variables that Provide Information");
 475   cm->DefineProperty
 476     ("CMAKE_SHARED_MODULE_PREFIX", cmProperty::VARIABLE,
 477      "The prefix for loadable modules that you link to.",
 478      "The prefix to use for the name of a loadable module on this platform."
 479      "\n"
 480      "CMAKE_SHARED_MODULE_PREFIX_<LANG> overrides this for language <LANG>."
 481      ,false, "Variables that Provide Information");
 482   cm->DefineProperty
 483     ("CMAKE_SHARED_MODULE_SUFFIX", cmProperty::VARIABLE,
 484      "The suffix for shared libraries that you link to.",
 485      "The suffix to use for the end of a loadable module on this platform"
 486      "\n"
 487      "CMAKE_SHARED_MODULE_SUFFIX_<LANG> overrides this for language <LANG>."
 488      ,false, "Variables that Provide Information");
 489   cm->DefineProperty
 490     ("CMAKE_STATIC_LIBRARY_PREFIX", cmProperty::VARIABLE,
 491      "The prefix for static libraries that you link to.",
 492      "The prefix to use for the name of a static library, lib on UNIX."
 493      "\n"
 494      "CMAKE_STATIC_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>."
 495      ,false, "Variables that Provide Information");
 496   cm->DefineProperty
 497     ("CMAKE_STATIC_LIBRARY_SUFFIX", cmProperty::VARIABLE,
 498      "The suffix for static libraries that you link to.",
 499      "The suffix to use for the end of a static library, .lib on Windows."
 500      "\n"
 501      "CMAKE_STATIC_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>."
 502      ,false, "Variables that Provide Information");
 503   cm->DefineProperty
 504     ("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES", cmProperty::VARIABLE,
 505      "Additional suffixes for shared libraries.",
 506      "Extensions for shared libraries other than that specified by "
 507      "CMAKE_SHARED_LIBRARY_SUFFIX, if any.  "
 508      "CMake uses this to recognize external shared library files during "
 509      "analysis of libraries linked by a target.",
 510      false,
 511      "Variables that Provide Information");
 512
 513
 514   // Variables defined by cmake, that change the behavior
 515   // of cmake
 516
 517   cm->DefineProperty
 518     ("CMAKE_POLICY_DEFAULT_CMP<NNNN>",  cmProperty::VARIABLE,
 519      "Default for CMake Policy CMP<NNNN> when it is otherwise left unset.",
 520      "Commands cmake_minimum_required(VERSION) and cmake_policy(VERSION) "
 521      "by default leave policies introduced after the given version unset.  "
 522      "Set CMAKE_POLICY_DEFAULT_CMP<NNNN> to OLD or NEW to specify the "
 523      "default for policy CMP<NNNN>, where <NNNN> is the policy number."
 524      "\n"
 525      "This variable should not be set by a project in CMake code; "
 526      "use cmake_policy(SET) instead.  "
 527      "Users running CMake may set this variable in the cache "
 528      "(e.g. -DCMAKE_POLICY_DEFAULT_CMP<NNNN>=<OLD|NEW>) "
 529      "to set a policy not otherwise set by the project.  "
 530      "Set to OLD to quiet a policy warning while using old behavior "
 531      "or to NEW to try building the project with new behavior.",
 532      false,
 533      "Variables That Change Behavior");
 534
 535     cm->DefineProperty
 536     ("CMAKE_AUTOMOC_RELAXED_MODE",  cmProperty::VARIABLE,
 537      "Switch between strict and relaxed automoc mode.",
 538      "By default, automoc behaves exactly as described in the documentation "
 539      "of the AUTOMOC target property.  "
 540      "When set to TRUE, it accepts more input and tries to find the correct "
 541      "input file for moc even if it differs from the documented behaviour. "
 542      "In this mode it e.g. also checks whether a header file is intended to "
 543      "be processed by moc when a \"foo.moc\" file has been included.\n"
 544      "Relaxed mode has to be enabled for KDE4 compatibility.",
 545      false,
 546      "Variables That Change Behavior");
 547
 548     cm->DefineProperty
 549     ("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME",  cmProperty::VARIABLE,
 550      "Default component used in install() commands.",
 551      "If an install() command is used without the COMPONENT argument, "
 552      "these files will be grouped into a default component. The name of this "
 553      "default install component will be taken from this variable.  "
 554      "It defaults to \"Unspecified\". ",
 555      false,
 556      "Variables That Change Behavior");
 557
 558     cm->DefineProperty
 559     ("CMAKE_FIND_LIBRARY_PREFIXES",  cmProperty::VARIABLE,
 560      "Prefixes to prepend when looking for libraries.",
 561      "This specifies what prefixes to add to library names when "
 562      "the find_library command looks for libraries. On UNIX "
 563      "systems this is typically lib, meaning that when trying "
 564      "to find the foo library it will look for libfoo.",
 565      false,
 566      "Variables That Change Behavior");
 567
 568     cm->DefineProperty
 569     ("CMAKE_FIND_LIBRARY_SUFFIXES",  cmProperty::VARIABLE,
 570      "Suffixes to append when looking for libraries.",
 571      "This specifies what suffixes to add to library names when "
 572      "the find_library command looks for libraries. On Windows "
 573      "systems this is typically .lib and .dll, meaning that when trying "
 574      "to find the foo library it will look for foo.dll etc.",
 575      false,
 576      "Variables That Change Behavior");
 577
 578     cm->DefineProperty
 579     ("CMAKE_CONFIGURATION_TYPES",  cmProperty::VARIABLE,
 580      "Specifies the available build types.",
 581      "This specifies what build types will be available such as "
 582      "Debug, Release, RelWithDebInfo etc. This has reasonable defaults "
 583      "on most platforms. But can be extended to provide other "
 584      "build types. See also CMAKE_BUILD_TYPE.",
 585      false,
 586      "Variables That Change Behavior");
 587
 588     cm->DefineProperty
 589     ("CMAKE_BUILD_TYPE",  cmProperty::VARIABLE,
 590      "Specifies the build type for make based generators.",
 591      "This specifies what build type will be built in this tree. "
 592      " Possible values are empty, Debug, Release, RelWithDebInfo"
 593      " and MinSizeRel. This variable is only supported for "
 594      "make based generators. If this variable is supported, "
 595      "then CMake will also provide initial values for the "
 596      "variables with the name "
 597      " CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL]."
 598      " For example, if CMAKE_BUILD_TYPE is Debug, then "
 599      "CMAKE_C_FLAGS_DEBUG will be added to the CMAKE_C_FLAGS.",false,
 600      "Variables That Change Behavior");
 601
 602   cm->DefineProperty
 603     ("CMAKE_BACKWARDS_COMPATIBILITY", cmProperty::VARIABLE,
 604      "Version of cmake required to build project",
 605      "From the point of view of backwards compatibility, this "
 606      "specifies what version of CMake should be supported. By "
 607      "default this value is the version number of CMake that "
 608      "you are running. You can set this to an older version of"
 609      " CMake to support deprecated commands of CMake in projects"
 610      " that were written to use older versions of CMake. This "
 611      "can be set by the user or set at the beginning of a "
 612      "CMakeLists file.",false,
 613      "Variables That Change Behavior");
 614
 615   cm->DefineProperty
 616     ("CMAKE_INSTALL_PREFIX", cmProperty::VARIABLE,
 617      "Install directory used by install.",
 618      "If \"make install\" is invoked or INSTALL is built"
 619      ", this directory is pre-pended onto all install "
 620      "directories. This variable defaults to /usr/local"
 621      " on UNIX and c:/Program Files on Windows.\n"
 622      "On UNIX one can use the DESTDIR mechanism in order"
 623      " to relocate the whole installation. "
 624      "DESTDIR means DESTination DIRectory. It is "
 625      "commonly used by makefile users "
 626      "in order to install software at non-default location. "
 627      "It is usually invoked like this:\n"
 628      " make DESTDIR=/home/john install\n"
 629      "which will install the concerned software using the"
 630      " installation prefix, e.g. \"/usr/local\" pre-pended with "
 631      "the DESTDIR value which finally gives \"/home/john/usr/local\".\n"
 632      "WARNING: DESTDIR may not be used on Windows because installation"
 633      " prefix usually contains a drive letter like in \"C:/Program Files\""
 634      " which cannot be pre-pended with some other prefix."
 635      ,false,
 636      "Variables That Change Behavior");
 637
 638   cm->DefineProperty
 639     ("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY", cmProperty::VARIABLE,
 640      "Don't make the install target depend on the all target.",
 641      "By default, the \"install\" target depends on the \"all\" target. "
 642      "This has the effect, that when \"make install\" is invoked or INSTALL "
 643      "is built, first the \"all\" target is built, then the installation "
 644      "starts. "
 645      "If CMAKE_SKIP_INSTALL_ALL_DEPENDENCY is set to TRUE, this dependency "
 646      "is not created, so the installation process will start immediately, "
 647      "independent from whether the project has been completely built or not."
 648      ,false,
 649      "Variables That Change Behavior");
 650
 651   cm->DefineProperty
 652     ("CMAKE_MODULE_PATH", cmProperty::VARIABLE,
 653      "List of directories to search for CMake modules.",
 654      "Commands like include() and find_package() search for files in "
 655      "directories listed by this variable before checking the default "
 656      "modules that come with CMake.",
 657      false,
 658      "Variables That Change Behavior");
 659
 660   cm->DefineProperty
 661     ("CMAKE_PREFIX_PATH", cmProperty::VARIABLE,
 662      "Path used for searching by FIND_XXX(), with appropriate suffixes added.",
 663      "Specifies a path which will be used by the FIND_XXX() commands. It "
 664      "contains the \"base\" directories, the FIND_XXX() commands append "
 665      "appropriate subdirectories to the base directories. So FIND_PROGRAM() "
 666      "adds /bin to each of the directories in the path, FIND_LIBRARY() "
 667      "appends /lib to each of the directories, and FIND_PATH() and "
 668      "FIND_FILE() append /include . By default it is empty, it is intended "
 669      "to be set by the project. See also CMAKE_SYSTEM_PREFIX_PATH, "
 670      "CMAKE_INCLUDE_PATH, CMAKE_LIBRARY_PATH, CMAKE_PROGRAM_PATH.", false,
 671      "Variables That Change Behavior");
 672
 673   cm->DefineProperty
 674     ("CMAKE_INCLUDE_PATH", cmProperty::VARIABLE,
 675      "Path used for searching by FIND_FILE() and FIND_PATH().",
 676      "Specifies a path which will be used both by FIND_FILE() and "
 677      "FIND_PATH(). Both commands will check each of the contained directories "
 678      "for the existence of the file which is currently searched. By default "
 679      "it is empty, it is intended to be set by the project. See also "
 680      "CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_PREFIX_PATH.", false,
 681      "Variables That Change Behavior");
 682
 683   cm->DefineProperty
 684     ("CMAKE_LIBRARY_PATH", cmProperty::VARIABLE,
 685      "Path used for searching by FIND_LIBRARY().",
 686      "Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() "
 687      "will check each of the contained directories for the existence of the "
 688      "library which is currently searched. By default it is empty, it is "
 689      "intended to be set by the project. See also CMAKE_SYSTEM_LIBRARY_PATH, "
 690      "CMAKE_PREFIX_PATH.", false,
 691      "Variables That Change Behavior");
 692
 693   cm->DefineProperty
 694     ("CMAKE_PROGRAM_PATH", cmProperty::VARIABLE,
 695      "Path used for searching by FIND_PROGRAM().",
 696      "Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM() "
 697      "will check each of the contained directories for the existence of the "
 698      "program which is currently searched. By default it is empty, it is "
 699      "intended to be set by the project. See also CMAKE_SYSTEM_PROGRAM_PATH, "
 700      " CMAKE_PREFIX_PATH.", false,
 701      "Variables That Change Behavior");
 702
 703   cm->DefineProperty
 704     ("CMAKE_SYSTEM_PREFIX_PATH", cmProperty::VARIABLE,
 705      "Path used for searching by FIND_XXX(), with appropriate suffixes added.",
 706      "Specifies a path which will be used by the FIND_XXX() commands. It "
 707      "contains the \"base\" directories, the FIND_XXX() commands append "
 708      "appropriate subdirectories to the base directories. So FIND_PROGRAM() "
 709      "adds /bin to each of the directories in the path, FIND_LIBRARY() "
 710      "appends /lib to each of the directories, and FIND_PATH() and "
 711      "FIND_FILE() append /include . By default this contains the standard "
 712      "directories for the current system. It is NOT intended "
 713      "to be modified by the project, use CMAKE_PREFIX_PATH for this. See also "
 714      "CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_SYSTEM_LIBRARY_PATH, "
 715      "CMAKE_SYSTEM_PROGRAM_PATH, and CMAKE_SYSTEM_IGNORE_PATH.", false,
 716      "Variables That Change Behavior");
 717
 718   cm->DefineProperty
 719     ("CMAKE_SYSTEM_IGNORE_PATH", cmProperty::VARIABLE,
 720      "Path to be ignored by FIND_XXX() commands.",
 721      "Specifies directories to be ignored by searches in FIND_XXX() "
 722      "commands.  "
 723      "This is useful in cross-compiled environments where some system "
 724      "directories contain incompatible but possibly linkable libraries. For "
 725      "example, on cross-compiled cluster environments, this allows a user to "
 726      "ignore directories containing libraries meant for the front-end "
 727      "machine that modules like FindX11 (and others) would normally search. "
 728      "By default this contains a list of directories containing incompatible "
 729      "binaries for the host system. "
 730      "See also CMAKE_SYSTEM_PREFIX_PATH, CMAKE_SYSTEM_LIBRARY_PATH, "
 731      "CMAKE_SYSTEM_INCLUDE_PATH, and CMAKE_SYSTEM_PROGRAM_PATH.", false,
 732      "Variables That Change Behavior");
 733
 734   cm->DefineProperty
 735     ("CMAKE_IGNORE_PATH", cmProperty::VARIABLE,
 736      "Path to be ignored by FIND_XXX() commands.",
 737      "Specifies directories to be ignored by searches in FIND_XXX() "
 738      "commands.  "
 739      "This is useful in cross-compiled environments where some system "
 740      "directories contain incompatible but possibly linkable libraries. For "
 741      "example, on cross-compiled cluster environments, this allows a user to "
 742      "ignore directories containing libraries meant for the front-end "
 743      "machine that modules like FindX11 (and others) would normally search. "
 744      "By default this is empty; it is intended to be set by the project. "
 745      "Note that CMAKE_IGNORE_PATH takes a list of directory names, NOT a "
 746      "list of prefixes. If you want to ignore paths under prefixes (bin, "
 747      "include, lib, etc.), you'll need to specify them explicitly. "
 748      "See also CMAKE_PREFIX_PATH, CMAKE_LIBRARY_PATH, CMAKE_INCLUDE_PATH, "
 749      "CMAKE_PROGRAM_PATH.", false,
 750      "Variables That Change Behavior");
 751
 752   cm->DefineProperty
 753     ("CMAKE_SYSTEM_INCLUDE_PATH", cmProperty::VARIABLE,
 754      "Path used for searching by FIND_FILE() and FIND_PATH().",
 755      "Specifies a path which will be used both by FIND_FILE() and "
 756      "FIND_PATH(). Both commands will check each of the contained directories "
 757      "for the existence of the file which is currently searched. By default "
 758      "it contains the standard directories for the current system. It is "
 759      "NOT intended to be modified by the project, use CMAKE_INCLUDE_PATH "
 760      "for this. See also CMAKE_SYSTEM_PREFIX_PATH.", false,
 761      "Variables That Change Behavior");
 762
 763   cm->DefineProperty
 764     ("CMAKE_SYSTEM_LIBRARY_PATH", cmProperty::VARIABLE,
 765      "Path used for searching by FIND_LIBRARY().",
 766      "Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() "
 767      "will check each of the contained directories for the existence of the "
 768      "library which is currently searched. By default it contains the "
 769      "standard directories for the current system. It is NOT intended to be "
 770      "modified by the project, use CMAKE_LIBRARY_PATH for this. See "
 771      "also CMAKE_SYSTEM_PREFIX_PATH.", false,
 772      "Variables That Change Behavior");
 773
 774   cm->DefineProperty
 775     ("CMAKE_SYSTEM_PROGRAM_PATH", cmProperty::VARIABLE,
 776      "Path used for searching by FIND_PROGRAM().",
 777      "Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM() "
 778      "will check each of the contained directories for the existence of the "
 779      "program which is currently searched. By default it contains the "
 780      "standard directories for the current system. It is NOT intended to be "
 781      "modified by the project, use CMAKE_PROGRAM_PATH for this. See also "
 782      "CMAKE_SYSTEM_PREFIX_PATH.", false,
 783      "Variables That Change Behavior");
 784
 785   cm->DefineProperty
 786     ("CMAKE_DISABLE_FIND_PACKAGE_<PackageName>", cmProperty::VARIABLE,
 787      "Variable for disabling find_package() calls.",
 788      "Every non-REQUIRED find_package() call in a project can be disabled "
 789      "by setting the variable CMAKE_DISABLE_FIND_PACKAGE_<PackageName> to "
 790      "TRUE. This can be used to build a project without an optional package, "
 791      "although that package is installed.\n"
 792      "This switch should be used during the initial CMake run. Otherwise if "
 793      "the package has already been found in a previous CMake run, the "
 794      "variables which have been stored in the cache will still be there. "
 795      "In the case it is recommended to remove the cache variables for "
 796      "this package from the cache using the cache editor or cmake -U", false,
 797      "Variables That Change Behavior");
 798
 799   cm->DefineProperty
 800     ("CMAKE_FIND_PACKAGE_WARN_NO_MODULE", cmProperty::VARIABLE,
 801      "Tell find_package to warn if called without an explicit mode.",
 802      "If find_package is called without an explicit mode option "
 803      "(MODULE, CONFIG or NO_MODULE) and no Find<pkg>.cmake module is "
 804      "in CMAKE_MODULE_PATH then CMake implicitly assumes that the "
 805      "caller intends to search for a package configuration file.  "
 806      "If no package configuration file is found then the wording "
 807      "of the failure message must account for both the case that the "
 808      "package is really missing and the case that the project has a "
 809      "bug and failed to provide the intended Find module.  "
 810      "If instead the caller specifies an explicit mode option then "
 811      "the failure message can be more specific."
 812      "\n"
 813      "Set CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_package "
 814      "to warn when it implicitly assumes Config mode.  "
 815      "This helps developers enforce use of an explicit mode in all calls "
 816      "to find_package within a project.", false,
 817      "Variables That Change Behavior");
 818
 819   cm->DefineProperty
 820     ("CMAKE_USER_MAKE_RULES_OVERRIDE", cmProperty::VARIABLE,
 821      "Specify a CMake file that overrides platform information.",
 822      "CMake loads the specified file while enabling support for each "
 823      "language from either the project() or enable_language() commands.  "
 824      "It is loaded after CMake's builtin compiler and platform information "
 825      "modules have been loaded but before the information is used.  "
 826      "The file may set platform information variables to override CMake's "
 827      "defaults."
 828      "\n"
 829      "This feature is intended for use only in overriding information "
 830      "variables that must be set before CMake builds its first test "
 831      "project to check that the compiler for a language works.  "
 832      "It should not be used to load a file in cases that a normal include() "
 833      "will work.  "
 834      "Use it only as a last resort for behavior that cannot be achieved "
 835      "any other way.  "
 836      "For example, one may set CMAKE_C_FLAGS_INIT to change the default "
 837      "value used to initialize CMAKE_C_FLAGS before it is cached.  "
 838      "The override file should NOT be used to set anything that could "
 839      "be set after languages are enabled, such as variables like "
 840      "CMAKE_RUNTIME_OUTPUT_DIRECTORY that affect the placement of binaries.  "
 841      "Information set in the file will be used for try_compile and try_run "
 842      "builds too."
 843      ,false,
 844      "Variables That Change Behavior");
 845
 846   cm->DefineProperty
 847     ("BUILD_SHARED_LIBS", cmProperty::VARIABLE,
 848      "Global flag to cause add_library to create shared libraries if on.",
 849      "If present and true, this will cause all libraries to be "
 850      "built shared unless the library was explicitly added as a "
 851      "static library.  This variable is often added to projects "
 852      "as an OPTION so that each user of a project can decide if "
 853      "they want to build the project using shared or static "
 854      "libraries.",false,
 855      "Variables That Change Behavior");
 856
 857   cm->DefineProperty
 858     ("CMAKE_NOT_USING_CONFIG_FLAGS", cmProperty::VARIABLE,
 859      "Skip _BUILD_TYPE flags if true.",
 860      "This is an internal flag used by the generators in "
 861      "CMake to tell CMake to skip the _BUILD_TYPE flags.",false,
 862      "Variables That Change Behavior");
 863
 864   cm->DefineProperty
 865     ("CMAKE_MFC_FLAG", cmProperty::VARIABLE,
 866      "Tell cmake to use MFC for an executable or dll.",
 867      "This can be set in a CMakeLists.txt file and will "
 868      "enable MFC in the application.  It should be set "
 869      "to 1 for the static MFC library, and 2 for "
 870      "the shared MFC library.  This is used in Visual "
 871      "Studio 6 and 7 project files.   The CMakeSetup "
 872      "dialog used MFC and the CMakeLists.txt looks like this:\n"
 873      "  add_definitions(-D_AFXDLL)\n"
 874      "  set(CMAKE_MFC_FLAG 2)\n"
 875      "  add_executable(CMakeSetup WIN32 ${SRCS})\n",false,
 876      "Variables That Change Behavior");
 877
 878   cm->DefineProperty
 879     ("CMAKE_COLOR_MAKEFILE", cmProperty::VARIABLE,
 880      "Enables color output when using the Makefile generator.",
 881      "When enabled, the generated Makefiles will produce colored output. "
 882      "Default is ON.",false,
 883      "Variables That Change Behavior");
 884
 885   cm->DefineProperty
 886     ("CMAKE_ABSOLUTE_DESTINATION_FILES", cmProperty::VARIABLE,
 887       "List of files which have been installed using "
 888       " an ABSOLUTE DESTINATION path.",
 889       "This variable is defined by CMake-generated cmake_install.cmake "
 890       "scripts."
 891       " It can be used (read-only) by program or script that source those"
 892       " install scripts. This is used by some CPack generators (e.g. RPM).",
 893       false,
 894       "Variables That Change Behavior");
 895
 896   cm->DefineProperty
 897     ("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
 898       "Ask cmake_install.cmake script to warn each time a file with "
 899       "absolute INSTALL DESTINATION is encountered.",
 900       "This variable is used by CMake-generated cmake_install.cmake"
 901       " scripts. If ones set this variable to ON while running the"
 902       " script, it may get warning messages from the script.", false,
 903       "Variables That Change Behavior");
 904
 905   cm->DefineProperty
 906     ("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
 907       "Ask cmake_install.cmake script to error out as soon as "
 908       "a file with absolute INSTALL DESTINATION is encountered.",
 909       "The fatal error is emitted before the installation of "
 910       "the offending file takes place."
 911       " This variable is used by CMake-generated cmake_install.cmake"
 912       " scripts. If ones set this variable to ON while running the"
 913       " script, it may get fatal error messages from the script.",false,
 914       "Variables That Change Behavior");
 915
 916   cm->DefineProperty
 917     ("CMAKE_DEBUG_TARGET_PROPERTIES", cmProperty::VARIABLE,
 918      "Enables tracing output for target properties.",
 919      "This variable can be populated with a list of properties to generate "
 920      "debug output for when evaluating target properties.  Currently it can "
 921      "only be used when evaluating the INCLUDE_DIRECTORIES target property.  "
 922      "In that case, it outputs a backtrace for each include directory in "
 923      "the build.  Default is unset.",false,"Variables That Change Behavior");
 924
 925   // Variables defined by CMake that describe the system
 926
 927   cm->DefineProperty
 928     ("CMAKE_SYSTEM", cmProperty::VARIABLE,
 929      "Name of system cmake is compiling for.",
 930      "This variable is the composite of CMAKE_SYSTEM_NAME "
 931      "and CMAKE_SYSTEM_VERSION, like this "
 932      "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}. "
 933      "If CMAKE_SYSTEM_VERSION is not set, then "
 934      "CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.",false,
 935      "Variables That Describe the System");
 936   cm->DefineProperty
 937     ("CMAKE_SYSTEM_NAME", cmProperty::VARIABLE,
 938      "Name of the OS CMake is building for.",
 939      "This is the name of the operating system on "
 940      "which CMake is targeting.   On systems that "
 941      "have the uname command, this variable is set "
 942      "to the output of uname -s.  Linux, Windows, "
 943      " and Darwin for Mac OSX are the values found "
 944      " on the big three operating systems."  ,false,
 945      "Variables That Describe the System");
 946   cm->DefineProperty
 947     ("CMAKE_SYSTEM_PROCESSOR", cmProperty::VARIABLE,
 948      "The name of the CPU CMake is building for.",
 949      "On systems that support uname, this variable is "
 950      "set to the output of uname -p, on windows it is "
 951      "set to the value of the environment variable "
 952      "PROCESSOR_ARCHITECTURE",false,
 953      "Variables That Describe the System");
 954   cm->DefineProperty
 955     ("CMAKE_SYSTEM_VERSION", cmProperty::VARIABLE,
 956      "OS version CMake is building for.",
 957      "A numeric version string for the system, on "
 958      "systems that support uname, this variable is "
 959      "set to the output of uname -r. On other "
 960      "systems this is set to major-minor version numbers.",false,
 961      "Variables That Describe the System");
 962   cm->DefineProperty
 963     ("CMAKE_LIBRARY_ARCHITECTURE", cmProperty::VARIABLE,
 964      "Target architecture library directory name, if detected.",
 965      "This is the value of CMAKE_<lang>_LIBRARY_ARCHITECTURE as "
 966      "detected for one of the enabled languages.",false,
 967      "Variables That Describe the System");
 968   cm->DefineProperty
 969     ("CMAKE_LIBRARY_ARCHITECTURE_REGEX", cmProperty::VARIABLE,
 970      "Regex matching possible target architecture library directory names.",
 971      "This is used to detect CMAKE_<lang>_LIBRARY_ARCHITECTURE from the "
 972      "implicit linker search path by matching the <arch> name.",false,
 973      "Variables That Describe the System");
 974
 975   cm->DefineProperty
 976     ("CMAKE_HOST_SYSTEM", cmProperty::VARIABLE,
 977      "Name of system cmake is being run on.",
 978      "The same as CMAKE_SYSTEM but for the host system instead "
 979      "of the target system when cross compiling.",false,
 980      "Variables That Describe the System");
 981   cm->DefineProperty
 982     ("CMAKE_HOST_SYSTEM_NAME", cmProperty::VARIABLE,
 983      "Name of the OS CMake is running on.",
 984      "The same as CMAKE_SYSTEM_NAME but for the host system instead "
 985      "of the target system when cross compiling.",false,
 986      "Variables That Describe the System");
 987   cm->DefineProperty
 988     ("CMAKE_HOST_SYSTEM_PROCESSOR", cmProperty::VARIABLE,
 989      "The name of the CPU CMake is running on.",
 990      "The same as CMAKE_SYSTEM_PROCESSOR but for the host system instead "
 991      "of the target system when cross compiling.",false,
 992      "Variables That Describe the System");
 993   cm->DefineProperty
 994     ("CMAKE_HOST_SYSTEM_VERSION", cmProperty::VARIABLE,
 995      "OS version CMake is running on.",
 996      "The same as CMAKE_SYSTEM_VERSION but for the host system instead "
 997      "of the target system when cross compiling.",false,
 998      "Variables That Describe the System");
 999
1000   cm->DefineProperty
1001     ("APPLE", cmProperty::VARIABLE,
1002      "True if running on Mac OSX.",
1003      "Set to true on Mac OSX.",false,
1004      "Variables That Describe the System");
1005
1006   cm->DefineProperty
1007     ("BORLAND", cmProperty::VARIABLE,
1008      "True if the borland compiler is being used.",
1009      "This is set to true if the Borland compiler is being used.",false,
1010      "Variables That Describe the System");
1011
1012   cm->DefineProperty
1013     ("CYGWIN", cmProperty::VARIABLE,
1014      "True for cygwin.",
1015      "Set to true when using CYGWIN.",false,
1016      "Variables That Describe the System");
1017
1018   cm->DefineProperty
1019     ("MSVC", cmProperty::VARIABLE,
1020      "True when using Microsoft Visual C",
1021      "Set to true when the compiler is some version of Microsoft Visual C.",
1022      false,
1023      "Variables That Describe the System");
1024
1025   int msvc_versions[] = { 60, 70, 71, 80, 90, 100, 110, 120, 0 };
1026   for (int i = 0; msvc_versions[i] != 0; i ++)
1027     {
1028     const char minor = (char)('0' + (msvc_versions[i] % 10));
1029     cmStdString varName = "MSVC";
1030     cmsys_ios::ostringstream majorStr;
1031
1032     majorStr << (msvc_versions[i] / 10);
1033     varName += majorStr.str();
1034     if (msvc_versions[i] < 100)
1035       {
1036       varName += minor;
1037       }
1038
1039     cmStdString verString = majorStr.str() + "." + minor;
1040
1041     cmStdString shortStr = "True when using Microsoft Visual C " + verString;
1042     cmStdString fullStr = "Set to true when the compiler is version " +
1043                           verString +
1044                           " of Microsoft Visual C.";
1045     cm->DefineProperty
1046       (varName.c_str(), cmProperty::VARIABLE,
1047        shortStr.c_str(),
1048        fullStr.c_str(),
1049        false,
1050        "Variables That Describe the System");
1051     }
1052
1053   cm->DefineProperty
1054     ("MSVC_IDE", cmProperty::VARIABLE,
1055      "True when using the Microsoft Visual C IDE",
1056      "Set to true when the target platform is the Microsoft Visual C IDE, "
1057      "as opposed to the command line compiler.",
1058      false,
1059      "Variables That Describe the System");
1060
1061   cm->DefineProperty
1062     ("MSVC_VERSION", cmProperty::VARIABLE,
1063      "The version of Microsoft Visual C/C++ being used if any.",
1064      "Known version numbers are:\n"
1065      "  1200 = VS  6.0\n"
1066      "  1300 = VS  7.0\n"
1067      "  1310 = VS  7.1\n"
1068      "  1400 = VS  8.0\n"
1069      "  1500 = VS  9.0\n"
1070      "  1600 = VS 10.0\n"
1071      "  1700 = VS 11.0\n"
1072      "  1800 = VS 12.0\n"
1073      "",
1074      false,
1075      "Variables That Describe the System");
1076
1077   cm->DefineProperty
1078     ("CMAKE_CL_64", cmProperty::VARIABLE,
1079      "Using the 64 bit compiler from Microsoft",
1080      "Set to true when using the 64 bit cl compiler from Microsoft.",
1081      false,
1082      "Variables That Describe the System");
1083
1084   cm->DefineProperty
1085     ("CMAKE_COMPILER_2005", cmProperty::VARIABLE,
1086      "Using the Visual Studio 2005 compiler from Microsoft",
1087      "Set to true when using the Visual Studio 2005 compiler "
1088      "from Microsoft.",
1089      false,
1090      "Variables That Describe the System");
1091
1092   cm->DefineProperty
1093     ("UNIX", cmProperty::VARIABLE,
1094      "True for UNIX and UNIX like operating systems.",
1095      "Set to true when the target system is UNIX or UNIX like "
1096      "(i.e. APPLE and CYGWIN).",false,
1097      "Variables That Describe the System");
1098
1099   cm->DefineProperty
1100     ("WIN32", cmProperty::VARIABLE,
1101      "True on windows systems, including win64.",
1102      "Set to true when the target system is Windows.",false,
1103      "Variables That Describe the System");
1104
1105   cm->DefineProperty
1106     ("XCODE_VERSION", cmProperty::VARIABLE,
1107      "Version of Xcode (Xcode generator only).",
1108      "Under the Xcode generator, this is the version of Xcode as specified in "
1109      "\"Xcode.app/Contents/version.plist\" (such as \"3.1.2\").",false,
1110      "Variables That Describe the System");
1111
1112   cm->DefineProperty
1113     ("CMAKE_HOST_APPLE", cmProperty::VARIABLE,
1114      "True for Apple OSXoperating systems.",
1115      "Set to true when the host system is Apple OSX.",
1116      false,
1117      "Variables That Describe the System");
1118
1119   cm->DefineProperty
1120     ("CMAKE_HOST_UNIX", cmProperty::VARIABLE,
1121      "True for UNIX and UNIX like operating systems.",
1122      "Set to true when the host system is UNIX or UNIX like "
1123      "(i.e. APPLE and CYGWIN).",false,
1124      "Variables That Describe the System");
1125
1126   cm->DefineProperty
1127     ("CMAKE_HOST_WIN32", cmProperty::VARIABLE,
1128      "True on windows systems, including win64.",
1129      "Set to true when the host system is Windows and on cygwin.",false,
1130      "Variables That Describe the System");
1131
1132   cm->DefineProperty
1133     ("CMAKE_OBJECT_PATH_MAX", cmProperty::VARIABLE,
1134      "Maximum object file full-path length allowed by native build tools.",
1135      "CMake computes for every source file an object file name that is "
1136      "unique to the source file and deterministic with respect to the "
1137      "full path to the source file.  "
1138      "This allows multiple source files in a target to share the same name "
1139      "if they lie in different directories without rebuilding when one is "
1140      "added or removed.  "
1141      "However, it can produce long full paths in a few cases, so CMake "
1142      "shortens the path using a hashing scheme when the full path to an "
1143      "object file exceeds a limit.  "
1144      "CMake has a built-in limit for each platform that is sufficient for "
1145      "common tools, but some native tools may have a lower limit.  "
1146      "This variable may be set to specify the limit explicitly.  "
1147      "The value must be an integer no less than 128.",false,
1148      "Variables That Describe the System");
1149
1150   // Variables that affect the building of object files and
1151   // targets.
1152   //
1153   cm->DefineProperty
1154     ("CMAKE_INCLUDE_CURRENT_DIR", cmProperty::VARIABLE,
1155      "Automatically add the current source- and build directories "
1156      "to the include path.",
1157      "If this variable is enabled, CMake automatically adds in each "
1158      "directory ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} "
1159      "to the include path for this directory. These additional include "
1160      "directories do not propagate down to subdirectories. This is useful "
1161      "mainly for out-of-source builds, where files generated into the "
1162      "build tree are included by files located in the source tree.\n"
1163      "By default CMAKE_INCLUDE_CURRENT_DIR is OFF.",
1164      false,
1165      "Variables that Control the Build");
1166
1167   cm->DefineProperty
1168     ("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE", cmProperty::VARIABLE,
1169      "Automatically add the current source- and build directories "
1170      "to the INTERFACE_INCLUDE_DIRECTORIES.",
1171      "If this variable is enabled, CMake automatically adds for each shared "
1172      "library target, static library target, module target and executable "
1173      "target, ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} to "
1174      "the INTERFACE_INCLUDE_DIRECTORIES."
1175      "By default CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE is OFF.",
1176      false,
1177      "Variables that Control the Build");
1178
1179   cm->DefineProperty
1180     ("CMAKE_INSTALL_RPATH", cmProperty::VARIABLE,
1181      "The rpath to use for installed targets.",
1182      "A semicolon-separated list specifying the rpath "
1183      "to use in installed targets (for platforms that support it). "
1184      "This is used to initialize the target property "
1185      "INSTALL_RPATH for all targets.",
1186      false,
1187      "Variables that Control the Build");
1188
1189   cm->DefineProperty
1190     ("CMAKE_INSTALL_RPATH_USE_LINK_PATH", cmProperty::VARIABLE,
1191      "Add paths to linker search and installed rpath.",
1192      "CMAKE_INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true "
1193      "will append directories in the linker search path and outside the "
1194      "project to the INSTALL_RPATH. "
1195      "This is used to initialize the target property "
1196      "INSTALL_RPATH_USE_LINK_PATH for all targets.",
1197      false,
1198      "Variables that Control the Build");
1199
1200   cm->DefineProperty
1201     ("CMAKE_INSTALL_NAME_DIR", cmProperty::VARIABLE,
1202      "Mac OSX directory name for installed targets.",
1203      "CMAKE_INSTALL_NAME_DIR is used to initialize the "
1204      "INSTALL_NAME_DIR property on all targets. See that target "
1205      "property for more information.",
1206      false,
1207      "Variables that Control the Build");
1208
1209   cm->DefineProperty
1210     ("CMAKE_Fortran_FORMAT", cmProperty::VARIABLE,
1211      "Set to FIXED or FREE to indicate the Fortran source layout.",
1212      "This variable is used to initialize the Fortran_FORMAT "
1213      "property on all the targets. "
1214      "See that target property for additional information.",
1215      false,
1216      "Variables that Control the Build");
1217
1218   cm->DefineProperty
1219     ("CMAKE_Fortran_MODULE_DIRECTORY", cmProperty::VARIABLE,
1220      "Fortran module output directory.",
1221      "This variable is used to initialize the "
1222      "Fortran_MODULE_DIRECTORY property on all the targets. "
1223      "See that target property for additional information.",
1224      false,
1225      "Variables that Control the Build");
1226
1227   cm->DefineProperty
1228     ("CMAKE_LIBRARY_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
1229      "Where to put all the LIBRARY targets when built.",
1230      "This variable is used to initialize the "
1231      "LIBRARY_OUTPUT_DIRECTORY property on all the targets. "
1232      "See that target property for additional information.",
1233      false,
1234      "Variables that Control the Build");
1235
1236   cm->DefineProperty
1237     ("CMAKE_ARCHIVE_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
1238      "Where to put all the ARCHIVE targets when built.",
1239      "This variable is used to initialize the "
1240      "ARCHIVE_OUTPUT_DIRECTORY property on all the targets. "
1241      "See that target property for additional information.",
1242      false,
1243      "Variables that Control the Build");
1244
1245   cm->DefineProperty
1246     ("CMAKE_RUNTIME_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
1247      "Where to put all the RUNTIME targets when built.",
1248      "This variable is used to initialize the "
1249      "RUNTIME_OUTPUT_DIRECTORY property on all the targets. "
1250      "See that target property for additional information.",
1251      false,
1252      "Variables that Control the Build");
1253
1254   cm->DefineProperty
1255     ("CMAKE_PDB_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
1256      "Where to put all the MS debug symbol files.",
1257      "This variable is used to initialize the "
1258      "PDB_OUTPUT_DIRECTORY property on all the targets. "
1259      "See that target property for additional information.",
1260      false,
1261      "Variables that Control the Build");
1262
1263   cm->DefineProperty
1264     ("CMAKE_LINK_DEPENDS_NO_SHARED", cmProperty::VARIABLE,
1265      "Whether to skip link dependencies on shared library files.",
1266      "This variable initializes the LINK_DEPENDS_NO_SHARED "
1267      "property on targets when they are created.  "
1268      "See that target property for additional information.",
1269      false,
1270      "Variables that Control the Build");
1271
1272   cm->DefineProperty
1273     ("CMAKE_AUTOMOC", cmProperty::VARIABLE,
1274      "Whether to handle moc automatically for Qt targets.",
1275      "This variable is used to initialize the "
1276      "AUTOMOC property on all the targets. "
1277      "See that target property for additional information.",
1278      false,
1279      "Variables that Control the Build");
1280
1281   cm->DefineProperty
1282     ("CMAKE_AUTOMOC_MOC_OPTIONS", cmProperty::VARIABLE,
1283      "Additional options for moc when using automoc (see CMAKE_AUTOMOC).",
1284      "This variable is used to initialize the "
1285      "AUTOMOC_MOC_OPTIONS property on all the targets. "
1286      "See that target property for additional information.",
1287      false,
1288      "Variables that Control the Build");
1289
1290   cm->DefineProperty
1291     ("CMAKE_GNUtoMS", cmProperty::VARIABLE,
1292      "Convert GNU import libraries (.dll.a) to MS format (.lib).",
1293      "This variable is used to initialize the GNUtoMS property on targets "
1294      "when they are created.  "
1295      "See that target property for additional information.",
1296      false,
1297      "Variables that Control the Build");
1298
1299   cm->DefineProperty
1300     ("CMAKE_DEBUG_POSTFIX", cmProperty::VARIABLE,
1301      "See variable CMAKE_<CONFIG>_POSTFIX.",
1302      "This variable is a special case of the more-general "
1303      "CMAKE_<CONFIG>_POSTFIX variable for the DEBUG configuration.",
1304      false,
1305      "Variables that Control the Build");
1306   cm->DefineProperty
1307     ("CMAKE_<CONFIG>_POSTFIX", cmProperty::VARIABLE,
1308      "Default filename postfix for libraries under configuration <CONFIG>.",
1309      "When a non-executable target is created its <CONFIG>_POSTFIX "
1310      "target property is initialized with the value of this variable "
1311      "if it is set.",
1312      false,
1313      "Variables that Control the Build");
1314
1315   cm->DefineProperty
1316     ("CMAKE_BUILD_WITH_INSTALL_RPATH", cmProperty::VARIABLE,
1317      "Use the install path for the RPATH",
1318      "Normally CMake uses the build tree for the RPATH when building "
1319      "executables etc on systems that use RPATH. When the software "
1320      "is installed the executables etc are relinked by CMake to have "
1321      "the install RPATH. If this variable is set to true then the software "
1322      "is always built with the install path for the RPATH and does not "
1323      "need to be relinked when installed.",false,
1324      "Variables that Control the Build");
1325
1326   cm->DefineProperty
1327     ("CMAKE_NO_BUILTIN_CHRPATH", cmProperty::VARIABLE,
1328      "Do not use the builtin ELF editor to fix RPATHs on installation.",
1329      "When an ELF binary needs to have a different RPATH after installation "
1330      "than it does in the build tree, CMake uses a builtin editor to change "
1331      "the RPATH in the installed copy.  "
1332      "If this variable is set to true then CMake will relink the binary "
1333      "before installation instead of using its builtin editor.",false,
1334      "Variables that Control the Build");
1335
1336   cm->DefineProperty
1337     ("CMAKE_SKIP_BUILD_RPATH", cmProperty::VARIABLE,
1338      "Do not include RPATHs in the build tree.",
1339      "Normally CMake uses the build tree for the RPATH when building "
1340      "executables etc on systems that use RPATH. When the software "
1341      "is installed the executables etc are relinked by CMake to have "
1342      "the install RPATH. If this variable is set to true then the software "
1343      "is always built with no RPATH.",false,
1344      "Variables that Control the Build");
1345
1346   cm->DefineProperty
1347     ("CMAKE_SKIP_INSTALL_RPATH", cmProperty::VARIABLE,
1348      "Do not include RPATHs in the install tree.",
1349      "Normally CMake uses the build tree for the RPATH when building "
1350      "executables etc on systems that use RPATH. When the software "
1351      "is installed the executables etc are relinked by CMake to have "
1352      "the install RPATH. If this variable is set to true then the software "
1353      "is always installed without RPATH, even if RPATH is enabled when "
1354      "building.  This can be useful for example to allow running tests from "
1355      "the build directory with RPATH enabled before the installation step.  "
1356      "To omit RPATH in both the build and install steps, use "
1357      "CMAKE_SKIP_RPATH instead.",false,
1358      "Variables that Control the Build");
1359
1360   cm->DefineProperty
1361     ("CMAKE_EXE_LINKER_FLAGS", cmProperty::VARIABLE,
1362      "Linker flags used to create executables.",
1363      "Flags used by the linker when creating an executable.",false,
1364      "Variables that Control the Build");
1365
1366   cm->DefineProperty
1367     ("CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE]", cmProperty::VARIABLE,
1368      "Flag used when linking an executable.",
1369      "Same as CMAKE_C_FLAGS_* but used by the linker "
1370      "when creating executables.",false,
1371      "Variables that Control the Build");
1372   cm->DefineProperty
1373     ("CMAKE_LIBRARY_PATH_FLAG", cmProperty::VARIABLE,
1374      "The flag used to add a library search path to a compiler.",
1375      "The flag used to specify a library directory to the compiler. "
1376      "On most compilers this is \"-L\".",false,
1377      "Variables that Control the Build");
1378   cm->DefineProperty
1379     ("CMAKE_LINK_DEF_FILE_FLAG  ", cmProperty::VARIABLE,
1380      "Linker flag used to specify a .def file for dll creation.",
1381      "The flag used to add a .def file when creating "
1382      "a dll on Windows, this is only defined on Windows.",false,
1383      "Variables that Control the Build");
1384   cm->DefineProperty
1385     ("CMAKE_LINK_LIBRARY_FLAG", cmProperty::VARIABLE,
1386      "Flag used to link a library into an executable.",
1387      "The flag used to specify a library to link to an executable.  "
1388      "On most compilers this is \"-l\".",false,
1389      "Variables that Control the Build");
1390   cm->DefineProperty
1391     ("CMAKE_LINK_LIBRARY_FILE_FLAG", cmProperty::VARIABLE,
1392      "Flag used to link a library specified by a path to its file.",
1393      "The flag used before a library file path is given to the linker.  "
1394      "This is needed only on very few platforms.", false,
1395      "Variables that Control the Build");
1396   cm->DefineProperty
1397     ("CMAKE_USE_RELATIVE_PATHS", cmProperty::VARIABLE,
1398      "Use relative paths (May not work!).",
1399      "If this is set to TRUE, then the CMake will use "
1400      "relative paths between the source and binary tree. "
1401      "This option does not work for more complicated "
1402      "projects, and relative paths are used when possible.  "
1403      "In general, it is not possible to move CMake generated"
1404      " makefiles to a different location regardless "
1405      "of the value of this variable.",false,
1406      "Variables that Control the Build");
1407   cm->DefineProperty
1408     ("EXECUTABLE_OUTPUT_PATH", cmProperty::VARIABLE,
1409      "Old executable location variable.",
1410      "The target property RUNTIME_OUTPUT_DIRECTORY supercedes "
1411      "this variable for a target if it is set.  "
1412      "Executable targets are otherwise placed in this directory.",false,
1413      "Variables that Control the Build");
1414   cm->DefineProperty
1415     ("LIBRARY_OUTPUT_PATH", cmProperty::VARIABLE,
1416      "Old library location variable.",
1417      "The target properties ARCHIVE_OUTPUT_DIRECTORY, "
1418      "LIBRARY_OUTPUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY supercede "
1419      "this variable for a target if they are set.  "
1420      "Library targets are otherwise placed in this directory.",false,
1421      "Variables that Control the Build");
1422   cm->DefineProperty
1423     ("CMAKE_TRY_COMPILE_CONFIGURATION", cmProperty::VARIABLE,
1424      "Build configuration used for try_compile and try_run projects.",
1425      "Projects built by try_compile and try_run are built "
1426      "synchronously during the CMake configuration step.  "
1427      "Therefore a specific build configuration must be chosen even "
1428      "if the generated build system supports multiple configurations.",false,
1429      "Variables that Control the Build");
1430   cm->DefineProperty
1431     ("CMAKE_LINK_INTERFACE_LIBRARIES", cmProperty::VARIABLE,
1432      "Default value for LINK_INTERFACE_LIBRARIES of targets.",
1433      "This variable is used to initialize the "
1434      "LINK_INTERFACE_LIBRARIES property on all the targets. "
1435      "See that target property for additional information.",
1436      false,
1437      "Variables that Control the Build");
1438   cm->DefineProperty
1439     ("CMAKE_WIN32_EXECUTABLE", cmProperty::VARIABLE,
1440      "Default value for WIN32_EXECUTABLE of targets.",
1441      "This variable is used to initialize the "
1442      "WIN32_EXECUTABLE property on all the targets. "
1443      "See that target property for additional information.",
1444      false,
1445      "Variables that Control the Build");
1446   cm->DefineProperty
1447     ("CMAKE_MACOSX_BUNDLE", cmProperty::VARIABLE,
1448      "Default value for MACOSX_BUNDLE of targets.",
1449      "This variable is used to initialize the "
1450      "MACOSX_BUNDLE property on all the targets. "
1451      "See that target property for additional information.",
1452      false,
1453      "Variables that Control the Build");
1454   cm->DefineProperty
1455     ("CMAKE_POSITION_INDEPENDENT_CODE", cmProperty::VARIABLE,
1456      "Default value for POSITION_INDEPENDENT_CODE of targets.",
1457      "This variable is used to initialize the "
1458      "POSITION_INDEPENDENT_CODE property on all the targets. "
1459      "See that target property for additional information.",
1460      false,
1461      "Variables that Control the Build");
1462
1463 //   Variables defined when the a language is enabled These variables will
1464 // also be defined whenever CMake has loaded its support for compiling (LANG)
1465 // programs. This support will be loaded whenever CMake is used to compile
1466 // (LANG) files. C and CXX are examples of the most common values for (LANG).
1467
1468   cm->DefineProperty
1469     ("CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG>", cmProperty::VARIABLE,
1470      "Specify a CMake file that overrides platform information for <LANG>.",
1471      "This is a language-specific version of "
1472      "CMAKE_USER_MAKE_RULES_OVERRIDE loaded only when enabling "
1473      "language <LANG>.",false,
1474      "Variables for Languages");
1475
1476   cm->DefineProperty
1477     ("CMAKE_<LANG>_COMPILER", cmProperty::VARIABLE,
1478      "The full path to the compiler for LANG.",
1479      "This is the command that will be used as the <LANG> compiler. "
1480      "Once set, you can not change this variable.",false,
1481      "Variables for Languages");
1482
1483   cm->DefineProperty
1484     ("CMAKE_<LANG>_COMPILER_ID", cmProperty::VARIABLE,
1485      "Compiler identification string.",
1486      "A short string unique to the compiler vendor.  "
1487      "Possible values include:\n"
1488      "  Absoft = Absoft Fortran (absoft.com)\n"
1489      "  ADSP = Analog VisualDSP++ (analog.com)\n"
1490      "  Clang = LLVM Clang (clang.llvm.org)\n"
1491      "  Cray = Cray Compiler (cray.com)\n"
1492      "  Embarcadero, Borland = Embarcadero (embarcadero.com)\n"
1493      "  G95 = G95 Fortran (g95.org)\n"
1494      "  GNU = GNU Compiler Collection (gcc.gnu.org)\n"
1495      "  HP = Hewlett-Packard Compiler (hp.com)\n"
1496      "  Intel = Intel Compiler (intel.com)\n"
1497      "  MIPSpro = SGI MIPSpro (sgi.com)\n"
1498      "  MSVC = Microsoft Visual Studio (microsoft.com)\n"
1499      "  PGI = The Portland Group (pgroup.com)\n"
1500      "  PathScale = PathScale (pathscale.com)\n"
1501      "  SDCC = Small Device C Compiler (sdcc.sourceforge.net)\n"
1502      "  SunPro = Oracle Solaris Studio (oracle.com)\n"
1503      "  TI = Texas Instruments (ti.com)\n"
1504      "  TinyCC = Tiny C Compiler (tinycc.org)\n"
1505      "  Watcom = Open Watcom (openwatcom.org)\n"
1506      "  XL, VisualAge, zOS = IBM XL (ibm.com)\n"
1507      "This variable is not guaranteed to be defined for all "
1508      "compilers or languages.",
1509      false,
1510      "Variables for Languages");
1511
1512   cm->DefineProperty
1513     ("CMAKE_<LANG>_PLATFORM_ID", cmProperty::VARIABLE,
1514      "An internal variable subject to change.",
1515      "This is used in determining the platform and is subject to change.",
1516      false,
1517      "Variables for Languages");
1518
1519   cm->DefineProperty
1520     ("CMAKE_<LANG>_COMPILER_ABI", cmProperty::VARIABLE,
1521      "An internal variable subject to change.",
1522      "This is used in determining the compiler ABI and is subject to change.",
1523      false,
1524      "Variables for Languages");
1525
1526   cm->DefineProperty
1527     ("CMAKE_<LANG>_COMPILER_VERSION", cmProperty::VARIABLE,
1528      "Compiler version string.",
1529      "Compiler version in major[.minor[.patch[.tweak]]] format.  "
1530      "This variable is not guaranteed to be defined for all "
1531      "compilers or languages.",
1532      false,
1533      "Variables for Languages");
1534
1535   cm->DefineProperty
1536     ("CMAKE_INTERNAL_PLATFORM_ABI", cmProperty::VARIABLE,
1537      "An internal variable subject to change.",
1538      "This is used in determining the compiler ABI and is subject to change.",
1539      false,
1540      "Variables for Languages");
1541
1542   cm->DefineProperty
1543     ("CMAKE_<LANG>_SIZEOF_DATA_PTR", cmProperty::VARIABLE,
1544      "Size of pointer-to-data types for language <LANG>.",
1545      "This holds the size (in bytes) of pointer-to-data types in the target "
1546      "platform ABI.  "
1547      "It is defined for languages C and CXX (C++).",
1548      false,
1549      "Variables for Languages");
1550
1551   cm->DefineProperty
1552     ("CMAKE_COMPILER_IS_GNU<LANG>", cmProperty::VARIABLE,
1553      "True if the compiler is GNU.",
1554      "If the selected <LANG> compiler is the GNU "
1555      "compiler then this is TRUE, if not it is FALSE. "
1556      "Unlike the other per-language variables, this uses the GNU syntax for "
1557      "identifying languages instead of the CMake syntax. Recognized values of "
1558      "the <LANG> suffix are:\n"
1559      "  CC = C compiler\n"
1560      "  CXX = C++ compiler\n"
1561      "  G77 = Fortran compiler",
1562      false,
1563      "Variables for Languages");
1564
1565   cm->DefineProperty
1566     ("CMAKE_<LANG>_FLAGS_DEBUG", cmProperty::VARIABLE,
1567      "Flags for Debug build type or configuration.",
1568      "<LANG> flags used when CMAKE_BUILD_TYPE is Debug.",false,
1569      "Variables for Languages");
1570
1571   cm->DefineProperty
1572     ("CMAKE_<LANG>_FLAGS_MINSIZEREL", cmProperty::VARIABLE,
1573      "Flags for MinSizeRel build type or configuration.",
1574      "<LANG> flags used when CMAKE_BUILD_TYPE is MinSizeRel."
1575      "Short for minimum size release.",false,
1576      "Variables for Languages");
1577
1578   cm->DefineProperty
1579     ("CMAKE_<LANG>_FLAGS_RELEASE", cmProperty::VARIABLE,
1580      "Flags for Release build type or configuration.",
1581      "<LANG> flags used when CMAKE_BUILD_TYPE is Release",false,
1582      "Variables for Languages");
1583
1584   cm->DefineProperty
1585     ("CMAKE_<LANG>_FLAGS_RELWITHDEBINFO", cmProperty::VARIABLE,
1586      "Flags for RelWithDebInfo type or configuration.",
1587      "<LANG> flags used when CMAKE_BUILD_TYPE is RelWithDebInfo. "
1588      "Short for Release With Debug Information.",false,
1589      "Variables for Languages");
1590
1591   cm->DefineProperty
1592     ("CMAKE_<LANG>_COMPILE_OBJECT", cmProperty::VARIABLE,
1593      "Rule variable to compile a single object file.",
1594      "This is a rule variable that tells CMake how to "
1595      "compile a single object file for for the language <LANG>.",false,
1596      "Variables for Languages");
1597
1598   cm->DefineProperty
1599     ("CMAKE_<LANG>_CREATE_SHARED_LIBRARY", cmProperty::VARIABLE,
1600      "Rule variable to create a shared library.",
1601      "This is a rule variable that tells CMake how to "
1602      "create a shared library for the language <LANG>.",false,
1603      "Variables for Languages");
1604
1605   cm->DefineProperty
1606     ("CMAKE_<LANG>_CREATE_SHARED_MODULE", cmProperty::VARIABLE,
1607      "Rule variable to create a shared module.",
1608      "This is a rule variable that tells CMake how to "
1609      "create a shared library for the language <LANG>.",false,
1610      "Variables for Languages");
1611
1612   cm->DefineProperty
1613     ("CMAKE_<LANG>_CREATE_STATIC_LIBRARY", cmProperty::VARIABLE,
1614      "Rule variable to create a static library.",
1615      "This is a rule variable that tells CMake how "
1616      "to create a static library for the language <LANG>.",false,
1617      "Variables for Languages");
1618
1619   cm->DefineProperty
1620     ("CMAKE_<LANG>_ARCHIVE_CREATE", cmProperty::VARIABLE,
1621      "Rule variable to create a new static archive.",
1622      "This is a rule variable that tells CMake how to create a static "
1623      "archive.  It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY "
1624      "on some platforms in order to support large object counts.  "
1625      "See also CMAKE_<LANG>_ARCHIVE_APPEND and CMAKE_<LANG>_ARCHIVE_FINISH.",
1626      false, "Variables for Languages");
1627
1628   cm->DefineProperty
1629     ("CMAKE_<LANG>_ARCHIVE_APPEND", cmProperty::VARIABLE,
1630      "Rule variable to append to a static archive.",
1631      "This is a rule variable that tells CMake how to append to a static "
1632      "archive.  It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY "
1633      "on some platforms in order to support large object counts.  "
1634      "See also CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_FINISH.",
1635      false, "Variables for Languages");
1636
1637   cm->DefineProperty
1638     ("CMAKE_<LANG>_ARCHIVE_FINISH", cmProperty::VARIABLE,
1639      "Rule variable to finish an existing static archive.",
1640      "This is a rule variable that tells CMake how to finish a static "
1641      "archive.  It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY "
1642      "on some platforms in order to support large object counts.  "
1643      "See also CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_APPEND.",
1644      false, "Variables for Languages");
1645
1646   cm->DefineProperty
1647     ("CMAKE_<LANG>_IGNORE_EXTENSIONS", cmProperty::VARIABLE,
1648      "File extensions that should be ignored by the build.",
1649      "This is a list of file extensions that may be "
1650      "part of a project for a given language but are not compiled. ",false,
1651      "Variables for Languages");
1652
1653   cm->DefineProperty
1654     ("CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES", cmProperty::VARIABLE,
1655      "Directories implicitly searched by the compiler for header files.",
1656      "CMake does not explicitly specify these directories on compiler "
1657      "command lines for language <LANG>.  "
1658      "This prevents system include directories from being treated as user "
1659      "include directories on some compilers.", false,
1660      "Variables for Languages");
1661
1662   cm->DefineProperty
1663     ("CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES", cmProperty::VARIABLE,
1664      "Implicit linker search path detected for language <LANG>.",
1665      "Compilers typically pass directories containing language runtime "
1666      "libraries and default library search paths when they invoke a linker.  "
1667      "These paths are implicit linker search directories for the compiler's "
1668      "language.  "
1669      "CMake automatically detects these directories for each language and "
1670      "reports the results in this variable."
1671      "\n"
1672      "When a library in one of these directories is given by full path to "
1673      "target_link_libraries() CMake will generate the -l<name> form on "
1674      "link lines to ensure the linker searches its implicit directories "
1675      "for the library.  "
1676      "Note that some toolchains read implicit directories from an "
1677      "environment variable such as LIBRARY_PATH so keep its value "
1678      "consistent when operating in a given build tree.",false,
1679      "Variables for Languages");
1680
1681   cm->DefineProperty
1682     ("CMAKE_<LANG>_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES", cmProperty::VARIABLE,
1683      "Implicit linker framework search path detected for language <LANG>.",
1684      "These paths are implicit linker framework search directories for "
1685      "the compiler's language.  "
1686      "CMake automatically detects these directories for each language and "
1687      "reports the results in this variable.", false,
1688      "Variables for Languages");
1689
1690   cm->DefineProperty
1691     ("CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES", cmProperty::VARIABLE,
1692      "Implicit link libraries and flags detected for language <LANG>.",
1693      "Compilers typically pass language runtime library names and "
1694      "other flags when they invoke a linker.  "
1695      "These flags are implicit link options for the compiler's language.  "
1696      "CMake automatically detects these libraries and flags for each "
1697      "language and reports the results in this variable.", false,
1698      "Variables for Languages");
1699
1700   cm->DefineProperty
1701     ("CMAKE_<LANG>_LIBRARY_ARCHITECTURE", cmProperty::VARIABLE,
1702      "Target architecture library directory name detected for <lang>.",
1703      "If the <lang> compiler passes to the linker an architecture-specific "
1704      "system library search directory such as <prefix>/lib/<arch> this "
1705      "variable contains the <arch> name if/as detected by CMake.",false,
1706      "Variables for Languages");
1707
1708   cm->DefineProperty
1709     ("CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES", cmProperty::VARIABLE,
1710      "True if CMAKE_<LANG>_LINKER_PREFERENCE propagates across targets.",
1711      "This is used when CMake selects a linker language for a target.  "
1712      "Languages compiled directly into the target are always considered.  "
1713      "A language compiled into static libraries linked by the target is "
1714      "considered if this variable is true.", false,
1715      "Variables for Languages");
1716
1717   cm->DefineProperty
1718     ("CMAKE_<LANG>_LINKER_PREFERENCE", cmProperty::VARIABLE,
1719      "Preference value for linker language selection.",
1720      "The \"linker language\" for executable, shared library, and module "
1721      "targets is the language whose compiler will invoke the linker.  "
1722      "The LINKER_LANGUAGE target property sets the language explicitly.  "
1723      "Otherwise, the linker language is that whose linker preference value "
1724      "is highest among languages compiled and linked into the target.  "
1725      "See also the CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES variable.",
1726      false,
1727      "Variables for Languages");
1728
1729   cm->DefineProperty
1730     ("CMAKE_<LANG>_LINK_EXECUTABLE ", cmProperty::VARIABLE,
1731      "Rule variable to link and executable.",
1732      "Rule variable to link and executable for the given language.",false,
1733      "Variables for Languages");
1734
1735   cm->DefineProperty
1736     ("CMAKE_<LANG>_OUTPUT_EXTENSION", cmProperty::VARIABLE,
1737      "Extension for the output of a compile for a single file.",
1738      "This is the extension for an object file for "
1739      "the given <LANG>. For example .obj for C on Windows.",false,
1740      "Variables for Languages");
1741
1742   cm->DefineProperty
1743     ("CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS", cmProperty::VARIABLE,
1744      "Extensions of source files for the given language.",
1745      "This is the list of extensions for a "
1746      "given languages source files.",false,"Variables for Languages");
1747
1748   cm->DefineProperty(
1749     "CMAKE_<LANG>_COMPILER_LOADED", cmProperty::VARIABLE,
1750     "Defined to true if the language is enabled.",
1751     "When language <LANG> is enabled by project() or enable_language() "
1752     "this variable is defined to 1.",
1753     false,"Variables for Languages");
1754
1755   cm->DefineProperty(
1756     "CMAKE_Fortran_MODDIR_FLAG", cmProperty::VARIABLE,
1757     "Fortran flag for module output directory.",
1758     "This stores the flag needed to pass the value of the "
1759     "Fortran_MODULE_DIRECTORY target property to the compiler.",
1760     false,"Variables for Languages");
1761
1762   cm->DefineProperty(
1763     "CMAKE_Fortran_MODDIR_DEFAULT", cmProperty::VARIABLE,
1764     "Fortran default module output directory.",
1765     "Most Fortran compilers write .mod files to the current working "
1766     "directory.  "
1767     "For those that do not, this is set to \".\" and used when the "
1768     "Fortran_MODULE_DIRECTORY target property is not set.",
1769     false,"Variables for Languages");
1770
1771   cm->DefineProperty(
1772     "CMAKE_Fortran_MODOUT_FLAG", cmProperty::VARIABLE,
1773     "Fortran flag to enable module output.",
1774     "Most Fortran compilers write .mod files out by default.  "
1775     "For others, this stores the flag needed to enable module output.",
1776     false,"Variables for Languages");
1777
1778   // variables that are used by cmake but not to be documented
1779   cm->DefineProperty("CMAKE_MATCH_0", cmProperty::VARIABLE,0,0);
1780   cm->DefineProperty("CMAKE_MATCH_1", cmProperty::VARIABLE,0,0);
1781   cm->DefineProperty("CMAKE_MATCH_2", cmProperty::VARIABLE,0,0);
1782   cm->DefineProperty("CMAKE_MATCH_3", cmProperty::VARIABLE,0,0);
1783   cm->DefineProperty("CMAKE_MATCH_4", cmProperty::VARIABLE,0,0);
1784   cm->DefineProperty("CMAKE_MATCH_5", cmProperty::VARIABLE,0,0);
1785   cm->DefineProperty("CMAKE_MATCH_6", cmProperty::VARIABLE,0,0);
1786   cm->DefineProperty("CMAKE_MATCH_7", cmProperty::VARIABLE,0,0);
1787   cm->DefineProperty("CMAKE_MATCH_8", cmProperty::VARIABLE,0,0);
1788   cm->DefineProperty("CMAKE_MATCH_9", cmProperty::VARIABLE,0,0);
1789
1790   cm->DefineProperty("CMAKE_<LANG>_COMPILER_ARG1",
1791                      cmProperty::VARIABLE,0,0);
1792   cm->DefineProperty("CMAKE_<LANG>_COMPILER_ENV_VAR",
1793                      cmProperty::VARIABLE,0,0);
1794   cm->DefineProperty("CMAKE_<LANG>_COMPILER_ID_RUN",
1795                      cmProperty::VARIABLE,0,0);
1796   cm->DefineProperty("CMAKE_<LANG>_ABI_FILES",
1797                      cmProperty::VARIABLE,0,0);
1798   cm->DefineProperty("CMAKE_<LANG>_CREATE_ASSEMBLY_SOURCE",
1799                      cmProperty::VARIABLE,0,0);
1800   cm->DefineProperty("CMAKE_<LANG>_CREATE_PREPROCESSED_SOURCE",
1801                      cmProperty::VARIABLE,0,0);
1802   cm->DefineProperty("CMAKE_<LANG>_FLAGS",
1803                      cmProperty::VARIABLE,0,0);
1804   cm->DefineProperty("CMAKE_<LANG>_FLAGS_DEBUG_INIT",
1805                      cmProperty::VARIABLE,0,0);
1806   cm->DefineProperty("CMAKE_<LANG>_FLAGS_INIT",
1807                      cmProperty::VARIABLE,0,0);
1808   cm->DefineProperty("CMAKE_<LANG>_FLAGS_MINSIZEREL_INIT",
1809                      cmProperty::VARIABLE,0,0);
1810   cm->DefineProperty("CMAKE_<LANG>_FLAGS_RELEASE_INIT",
1811                      cmProperty::VARIABLE,0,0);
1812   cm->DefineProperty("CMAKE_<LANG>_FLAGS_RELWITHDEBINFO_INIT",
1813                      cmProperty::VARIABLE,0,0);
1814   cm->DefineProperty("CMAKE_<LANG>_INFORMATION_LOADED",
1815                      cmProperty::VARIABLE,0,0);
1816   cm->DefineProperty("CMAKE_<LANG>_LINK_EXECUTABLE",
1817                      cmProperty::VARIABLE,0,0);
1818   cm->DefineProperty("CMAKE_<LANG>_LINK_FLAGS",
1819                      cmProperty::VARIABLE,0,0);
1820   cm->DefineProperty("CMAKE_<LANG>_RESPONSE_FILE_LINK_FLAG",
1821                      cmProperty::VARIABLE,0,0);
1822   cm->DefineProperty("CMAKE_<LANG>_STANDARD_LIBRARIES",
1823                      cmProperty::VARIABLE,0,0);
1824   cm->DefineProperty("CMAKE_<LANG>_STANDARD_LIBRARIES_INIT",
1825                      cmProperty::VARIABLE,0,0);
1826   cm->DefineProperty("CMAKE_<LANG>_USE_RESPONSE_FILE_FOR_INCLUDES",
1827                      cmProperty::VARIABLE,0,0);
1828   cm->DefineProperty("CMAKE_<LANG>_USE_RESPONSE_FILE_FOR_OBJECTS",
1829                      cmProperty::VARIABLE,0,0);
1830   cm->DefineProperty("CMAKE_EXECUTABLE_SUFFIX_<LANG>",
1831                      cmProperty::VARIABLE,0,0);
1832   cm->DefineProperty("CMAKE_EXE_LINK_DYNAMIC_<LANG>_FLAGS",
1833                      cmProperty::VARIABLE,0,0);
1834   cm->DefineProperty("CMAKE_EXE_LINK_STATIC_<LANG>_FLAGS",
1835                      cmProperty::VARIABLE,0,0);
1836   cm->DefineProperty("CMAKE_GENERATOR_<LANG>",
1837                      cmProperty::VARIABLE,0,0);
1838   cm->DefineProperty("CMAKE_IMPORT_LIBRARY_PREFIX_<LANG>",
1839                      cmProperty::VARIABLE,0,0);
1840   cm->DefineProperty("CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG>",
1841                      cmProperty::VARIABLE,0,0);
1842   cm->DefineProperty("CMAKE_INCLUDE_FLAG_<LANG>",
1843                      cmProperty::VARIABLE,0,0);
1844   cm->DefineProperty("CMAKE_INCLUDE_FLAG_SEP_<LANG>",
1845                      cmProperty::VARIABLE,0,0);
1846   cm->DefineProperty("CMAKE_INCLUDE_SYSTEM_FLAG_<LANG>",
1847                      cmProperty::VARIABLE,0,0);
1848   cm->DefineProperty("CMAKE_NEEDS_REQUIRES_STEP_<LANG>_FLAG",
1849                      cmProperty::VARIABLE,0,0);
1850   cm->DefineProperty("CMAKE_SHARED_LIBRARY_CREATE_<LANG>_FLAGS",
1851                      cmProperty::VARIABLE,0,0);
1852   cm->DefineProperty("CMAKE_SHARED_LIBRARY_<LANG>_FLAGS",
1853                      cmProperty::VARIABLE,0,0);
1854   cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_<LANG>_FLAGS",
1855                      cmProperty::VARIABLE,0,0);
1856   cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_DYNAMIC_<LANG>_FLAGS",
1857                      cmProperty::VARIABLE,0,0);
1858   cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_STATIC_<LANG>_FLAGS",
1859                      cmProperty::VARIABLE,0,0);
1860   cm->DefineProperty("CMAKE_SHARED_LIBRARY_PREFIX_<LANG>",
1861                      cmProperty::VARIABLE,0,0);
1862   cm->DefineProperty("CMAKE_SHARED_LIBRARY_SUFFIX_<LANG>",
1863                      cmProperty::VARIABLE,0,0);
1864   cm->DefineProperty("CMAKE_SHARED_LIBRARY_RUNTIME_<LANG>_FLAG",
1865                      cmProperty::VARIABLE,0,0);
1866   cm->DefineProperty("CMAKE_SHARED_LIBRARY_RUNTIME_<LANG>_FLAG_SEP",
1867                      cmProperty::VARIABLE,0,0);
1868   cm->DefineProperty("CMAKE_SHARED_LIBRARY_RPATH_LINK_<LANG>_FLAG",
1869                      cmProperty::VARIABLE,0,0);
1870   cm->DefineProperty("CMAKE_EXECUTABLE_RUNTIME_<LANG>_FLAG",
1871                      cmProperty::VARIABLE,0,0);
1872   cm->DefineProperty("CMAKE_EXECUTABLE_RUNTIME_<LANG>_FLAG_SEP",
1873                      cmProperty::VARIABLE,0,0);
1874   cm->DefineProperty("CMAKE_EXECUTABLE_RPATH_LINK_<LANG>_FLAG",
1875                      cmProperty::VARIABLE,0,0);
1876   cm->DefineProperty("CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH",
1877                      cmProperty::VARIABLE,0,0);
1878   cm->DefineProperty(
1879     "CMAKE_<LANG>_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH",
1880     cmProperty::VARIABLE,0,0);
1881   cm->DefineProperty("CMAKE_SHARED_MODULE_CREATE_<LANG>_FLAGS",
1882                      cmProperty::VARIABLE,0,0);
1883   cm->DefineProperty("CMAKE_SHARED_MODULE_<LANG>_FLAGS",
1884                      cmProperty::VARIABLE,0,0);
1885   cm->DefineProperty("CMAKE_SHARED_MODULE_LINK_DYNAMIC_<LANG>_FLAGS",
1886                      cmProperty::VARIABLE,0,0);
1887   cm->DefineProperty("CMAKE_SHARED_MODULE_LINK_STATIC_<LANG>_FLAGS",
1888                      cmProperty::VARIABLE,0,0);
1889   cm->DefineProperty("CMAKE_SHARED_MODULE_PREFIX_<LANG>",
1890                      cmProperty::VARIABLE,0,0);
1891   cm->DefineProperty("CMAKE_SHARED_MODULE_SUFFIX_<LANG>",
1892                      cmProperty::VARIABLE,0,0);
1893   cm->DefineProperty("CMAKE_STATIC_LIBRARY_PREFIX_<LANG>",
1894                      cmProperty::VARIABLE,0,0);
1895   cm->DefineProperty("CMAKE_STATIC_LIBRARY_SUFFIX_<LANG>",
1896                      cmProperty::VARIABLE,0,0);
1897   cm->DefineProperty("CMAKE_LINK_DEPENDENT_LIBRARY_FILES",
1898                      cmProperty::VARIABLE,0,0);
1899   cm->DefineProperty("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS",
1900                      cmProperty::VARIABLE,0,0);
1901   cm->DefineProperty("CMAKE_MAKE_INCLUDE_FROM_ROOT",
1902                      cmProperty::VARIABLE,0,0);
1903 }