Source/cmDocumentVariables.cxx

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