Drop builtin property documentation

Drop all DefineProperty calls for non-chained properties.  Drop the
documentation from the chained ones.  The documentation for all
properties is now in Help/prop_*/*.rst files.

18 files changed, 6 insertions, 4446 deletions

diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 3228f38..5b7df2d 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -160,10 +160,8 @@ set(SRCS
   cmDocumentation.cxx
   cmDocumentationFormatter.cxx
   cmDocumentationSection.cxx
-  cmDocumentCompileDefinitions.h
   cmDocumentGeneratorExpressions.h
   cmDocumentLocationUndefined.h
-  cmDocumentVariables.cxx
   cmDynamicLoader.cxx
   cmDynamicLoader.h
   ${ELF_SRCS}
@@ -494,7 +492,6 @@ set(CPACK_SRCS
   CPack/cmCPackTarBZip2Generator.cxx
   CPack/cmCPackTarCompressGenerator.cxx
   CPack/cmCPackZIPGenerator.cxx
-  CPack/cmCPackDocumentVariables.cxx
   )
 
 if(CYGWIN)
diff --git a/Source/CPack/cmCPackDocumentVariables.cxx b/Source/CPack/cmCPackDocumentVariables.cxx
deleted file mode 100644
index 8b16ae9..0000000
--- a/Source/CPack/cmCPackDocumentVariables.cxx
+++ /dev/null
@@ -1,122 +0,0 @@
-#include "cmCPackDocumentVariables.h"
-#include "cmake.h"
-
-void cmCPackDocumentVariables::DefineVariables(cmake* cm)
-{
-  // Subsection: variables defined/used by cpack,
-  // which are common to all CPack generators
-
-  cm->DefineProperty
-      ("CPACK_PACKAGING_INSTALL_PREFIX", cmProperty::VARIABLE,
-       "The prefix used in the built package.",
-       "Each CPack generator has a default value (like /usr)."
-       " This default value may"
-       " be overwritten from the CMakeLists.txt or the cpack command line"
-       " by setting an alternative value.\n"
-       "e.g. "
-       " set(CPACK_PACKAGING_INSTALL_PREFIX \"/opt\")\n"
-       "This is not the same purpose as CMAKE_INSTALL_PREFIX which"
-       " is used when installing from the build tree without building"
-       " a package."
-       "", false,
-       "Variables common to all CPack generators");
-
-  cm->DefineProperty
-        ("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", cmProperty::VARIABLE,
-         "Boolean toggle to include/exclude top level directory.",
-         "When preparing a package CPack installs the item under"
-         " the so-called top level directory. The purpose of"
-         " is to include (set to 1 or ON or TRUE) the top level directory"
-         " in the package or not (set to 0 or OFF or FALSE).\n"
-         "Each CPack generator has a built-in default value for this"
-         " variable. E.g. Archive generators (ZIP, TGZ, ...) includes"
-         " the top level whereas RPM or DEB don't. The user may override"
-         " the default value by setting this variable.\n"
-         "There is a similar variable "
-         "CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY "
-         "which may be used to override the behavior for the component"
-         " packaging case which may have different default value for"
-         " historical (now backward compatibility) reason.", false,
-         "Variables common to all CPack generators");
-
-  cm->DefineProperty
-          ("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY", cmProperty::VARIABLE,
-            "Boolean toggle to include/exclude top level directory "
-             "(component case).",
-            "Similar usage as CPACK_INCLUDE_TOPLEVEL_DIRECTORY"
-            " but for the component case. "
-            "See CPACK_INCLUDE_TOPLEVEL_DIRECTORY documentation for"
-            " the detail.", false,
-            "Variables common to all CPack generators");
-
-  cm->DefineProperty
-          ("CPACK_SET_DESTDIR", cmProperty::VARIABLE,
-           "Boolean toggle to make CPack use DESTDIR mechanism when"
-           " packaging.", "DESTDIR means DESTination DIRectory."
-           " It is commonly used by makefile "
-           "users in order to install software at non-default location. It "
-           "is a basic relocation mechanism that should not be used on"
-           " Windows (see CMAKE_INSTALL_PREFIX documentation). "
-           "It is usually invoked like this:\n"
-           " make DESTDIR=/home/john install\n"
-           "which will install the concerned software using the"
-           " installation prefix, e.g. \"/usr/local\" prepended with "
-           "the DESTDIR value which finally gives \"/home/john/usr/local\"."
-           " When preparing a package, CPack first installs the items to be "
-           "packaged in a local (to the build tree) directory by using the "
-           "same DESTDIR mechanism. Nevertheless, if "
-           "CPACK_SET_DESTDIR is set then CPack will set DESTDIR before"
-           " doing the local install. The most noticeable difference is"
-           " that without CPACK_SET_DESTDIR, CPack uses "
-           "CPACK_PACKAGING_INSTALL_PREFIX as a prefix whereas with "
-           "CPACK_SET_DESTDIR set, CPack will use CMAKE_INSTALL_PREFIX as"
-           " a prefix.\n"
-           "Manually setting CPACK_SET_DESTDIR may help (or simply be"
-           " necessary) if some install rules uses absolute "
-           "DESTINATION (see CMake INSTALL command)."
-           " However, starting with"
-           " CPack/CMake 2.8.3 RPM and DEB installers tries to handle DESTDIR"
-           " automatically so that it is seldom necessary for the user to set"
-           " it.", false,
-           "Variables common to all CPack generators");
-
-  cm->DefineProperty
-        ("CPACK_INSTALL_SCRIPT", cmProperty::VARIABLE,
-         "Extra CMake script provided by the user.",
-         "If set this CMake script will be executed by CPack "
-         "during its local [CPack-private] installation "
-         "which is done right before packaging the files."
-         " The script is not called by e.g.: make install.", false,
-         "Variables common to all CPack generators");
-
-  cm->DefineProperty
-        ("CPACK_ABSOLUTE_DESTINATION_FILES", cmProperty::VARIABLE,
-         "List of files which have been installed using "
-         " an ABSOLUTE DESTINATION path.",
-         "This variable is a Read-Only variable which is set internally"
-         " by CPack during installation and before packaging using"
-         " CMAKE_ABSOLUTE_DESTINATION_FILES defined in cmake_install.cmake "
-         "scripts. The value can be used within CPack project configuration"
-         " file and/or CPack<GEN>.cmake file of <GEN> generator.", false,
-         "Variables common to all CPack generators");
-
-  cm->DefineProperty
-        ("CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
-         "Ask CPack to warn each time a file with absolute INSTALL"
-         " DESTINATION is encountered.",
-         "This variable triggers the definition of "
-         "CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION when CPack runs"
-         " cmake_install.cmake scripts.", false,
-         "Variables common to all CPack generators");
-
-  cm->DefineProperty
-        ("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
-         "Ask CPack to error out as soon as a file with absolute INSTALL"
-         " DESTINATION is encountered.",
-         "The fatal error is emitted before the installation of "
-         "the offending file takes place. Some CPack generators, like NSIS,"
-         "enforce this internally. "
-         "This variable triggers the definition of"
-         "CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION when CPack runs"
-         "Variables common to all CPack generators");
-}
diff --git a/Source/CPack/cmCPackDocumentVariables.h b/Source/CPack/cmCPackDocumentVariables.h
deleted file mode 100644
index e7971be..0000000
--- a/Source/CPack/cmCPackDocumentVariables.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef cmCPackDocumentVariables_h
-#define cmCPackDocumentVariables_h
-class cmake;
-class cmCPackDocumentVariables
-{
-public:
-  static void DefineVariables(cmake* cm);
-};
-
-#endif
diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx
index 0a6d8b9..f8f6139 100644
--- a/Source/CPack/cpack.cxx
+++ b/Source/CPack/cpack.cxx
@@ -14,7 +14,6 @@
 // Need these for documentation support.
 #include "cmake.h"
 #include "cmDocumentation.h"
-#include "cmCPackDocumentVariables.h"
 #include "cmCPackGeneratorFactory.h"
 #include "cmCPackGenerator.h"
 #include "cmake.h"
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index ed09545..a2baa80 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -935,65 +935,3 @@ bool cmCacheManager::NeedCacheCompatibility(int major, int minor)
   return (actual_compat &&
           actual_compat <= CMake_VERSION_ENCODE(major, minor, 0));
 }
-
-//----------------------------------------------------------------------------
-void cmCacheManager::DefineProperties(cmake *cm)
-{
-  cm->DefineProperty
-    ("ADVANCED", cmProperty::CACHE,
-     "True if entry should be hidden by default in GUIs.",
-     "This is a boolean value indicating whether the entry is considered "
-     "interesting only for advanced configuration.  "
-     "The mark_as_advanced() command modifies this property."
-      );
-
-  cm->DefineProperty
-    ("HELPSTRING", cmProperty::CACHE,
-     "Help associated with entry in GUIs.",
-     "This string summarizes the purpose of an entry to help users set it "
-     "through a CMake GUI."
-      );
-
-  cm->DefineProperty
-    ("TYPE", cmProperty::CACHE,
-     "Widget type for entry in GUIs.",
-     "Cache entry values are always strings, but CMake GUIs present widgets "
-     "to help users set values.  "
-     "The GUIs use this property as a hint to determine the widget type.  "
-     "Valid TYPE values are:\n"
-     "  BOOL          = Boolean ON/OFF value.\n"
-     "  PATH          = Path to a directory.\n"
-     "  FILEPATH      = Path to a file.\n"
-     "  STRING        = Generic string value.\n"
-     "  INTERNAL      = Do not present in GUI at all.\n"
-     "  STATIC        = Value managed by CMake, do not change.\n"
-     "  UNINITIALIZED = Type not yet specified.\n"
-     "Generally the TYPE of a cache entry should be set by the command "
-     "which creates it (set, option, find_library, etc.)."
-      );
-
-  cm->DefineProperty
-    ("MODIFIED", cmProperty::CACHE,
-     "Internal management property.  Do not set or get.",
-     "This is an internal cache entry property managed by CMake to "
-     "track interactive user modification of entries.  Ignore it."
-      );
-
-  cm->DefineProperty
-    ("STRINGS", cmProperty::CACHE,
-     "Enumerate possible STRING entry values for GUI selection.",
-     "For cache entries with type STRING, this enumerates a set of values.  "
-     "CMake GUIs may use this to provide a selection widget instead of a "
-     "generic string entry field.  "
-     "This is for convenience only.  "
-     "CMake does not enforce that the value matches one of those listed."
-      );
-
-  cm->DefineProperty
-    ("VALUE", cmProperty::CACHE,
-     "Value of a cache entry.",
-     "This property maps to the actual value of a cache entry.  "
-     "Setting this property always sets the value without checking, so "
-     "use with care."
-      );
-}
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index a5e5eee..2eb440a 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -149,9 +149,6 @@ public:
   unsigned int GetCacheMinorVersion() { return this->CacheMinorVersion; }
   bool NeedCacheCompatibility(int major, int minor);
 
-  /** Define and document CACHE entry properties.  */
-  static void DefineProperties(cmake *cm);
-
 protected:
   ///! Add an entry into the cache
   void AddCacheEntry(const char* key, const char* value,
diff --git a/Source/cmDefinePropertyCommand.cxx b/Source/cmDefinePropertyCommand.cxx
index 5816829..1ad98af 100644
--- a/Source/cmDefinePropertyCommand.cxx
+++ b/Source/cmDefinePropertyCommand.cxx
@@ -12,7 +12,6 @@
 #include "cmDefinePropertyCommand.h"
 #include "cmake.h"
 
-// cmDefinePropertiesCommand
 bool cmDefinePropertyCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
diff --git a/Source/cmDocumentCompileDefinitions.h b/Source/cmDocumentCompileDefinitions.h
deleted file mode 100644
index d15bd6d..0000000
--- a/Source/cmDocumentCompileDefinitions.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef cmDocumentCompileDefinitions_h
-#define cmDocumentCompileDefinitions_h
-
-#define CM_DOCUMENT_COMPILE_DEFINITIONS_DISCLAIMER \
-  "Disclaimer: Most native build tools have poor support for escaping " \
-  "certain values.  CMake has work-arounds for many cases but some "    \
-  "values may just not be possible to pass correctly.  If a value "     \
-  "does not seem to be escaped correctly, do not attempt to "           \
-  "work-around the problem by adding escape sequences to the value.  "  \
-  "Your work-around may break in a future version of CMake that "       \
-  "has improved escape support.  Instead consider defining the macro "  \
-  "in a (configured) header file.  Then report the limitation.  "       \
-  "Known limitations include:\n"                                        \
-  "  #          - broken almost everywhere\n"                           \
-  "  ;          - broken in VS IDE 7.0 and Borland Makefiles\n"         \
-  "  ,          - broken in VS IDE\n"                                   \
-  "  %          - broken in some cases in NMake\n"                      \
-  "  & |        - broken in some cases on MinGW\n"                      \
-  "  ^ < > \\\"   - broken in most Make tools on Windows\n"             \
-  "CMake does not reject these values outright because they do work "   \
-  "in some cases.  Use with caution.  "
-
-#endif
diff --git a/Source/cmDocumentVariables.cxx b/Source/cmDocumentVariables.cxx
deleted file mode 100644
index dbe1b04..0000000
--- a/Source/cmDocumentVariables.cxx
+++ /dev/null
@@ -1,2069 +0,0 @@
-#include "cmDocumentVariables.h"
-#include "cmake.h"
-
-#include <cmsys/ios/sstream>
-
-void cmDocumentVariables::DefineVariables(cmake* cm)
-{
-  // Subsection: variables defined by cmake, that give
-  // information about the project, and cmake
-  cm->DefineProperty
-    ("CMAKE_AR", cmProperty::VARIABLE,
-     "Name of archiving tool for static libraries.",
-     "This specifies the name of the program that creates archive "
-     "or static libraries.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_COMMAND", cmProperty::VARIABLE,
-     "The full path to the cmake executable.",
-     "This is the full path to the CMake executable cmake which is "
-     "useful from custom commands that want to use the cmake -E "
-     "option for portable system commands.  "
-     "(e.g. /usr/local/bin/cmake", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_BINARY_DIR", cmProperty::VARIABLE,
-     "The path to the top level of the build tree.",
-     "This is the full path to the top level of the current CMake "
-     "build tree. For an in-source build, this would be the same "
-     "as CMAKE_SOURCE_DIR.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SOURCE_DIR", cmProperty::VARIABLE,
-     "The path to the top level of the source tree.",
-     "This is the full path to the top level of the current CMake "
-     "source tree. For an in-source build, this would be the same "
-     "as CMAKE_BINARY_DIR.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_CURRENT_BINARY_DIR", cmProperty::VARIABLE,
-     "The path to the binary directory currently being processed.",
-     "This the full path to the build directory that is currently "
-     "being processed by cmake.  Each directory added by "
-     "add_subdirectory will create a binary directory in the build "
-     "tree, and as it is being processed this variable will be set.  "
-     "For in-source builds this is the current source directory "
-     "being processed.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_CURRENT_SOURCE_DIR", cmProperty::VARIABLE,
-     "The path to the source directory currently being processed.",
-     "This the full path to the source directory that is currently "
-     "being processed by cmake.  ", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_CURRENT_LIST_FILE", cmProperty::VARIABLE,
-     "Full path to the listfile currently being processed.",
-     "As CMake processes the listfiles in your project this "
-     "variable will always be set to the one currently being "
-     "processed.  "
-     "The value has dynamic scope.  "
-     "When CMake starts processing commands in a source file "
-     "it sets this variable to the location of the file.  "
-     "When CMake finishes processing commands from the file it "
-     "restores the previous value.  "
-     "Therefore the value of the variable inside a macro or "
-     "function is the file invoking the bottom-most entry on "
-     "the call stack, not the file containing the macro or "
-     "function definition."
-     "\n"
-     "See also CMAKE_PARENT_LIST_FILE.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_CURRENT_LIST_LINE", cmProperty::VARIABLE,
-     "The line number of the current file being processed.",
-     "This is the line number of the file currently being"
-     " processed by cmake.", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_CURRENT_LIST_DIR", cmProperty::VARIABLE,
-     "Full directory of the listfile currently being processed.",
-     "As CMake processes the listfiles in your project this "
-     "variable will always be set to the directory where the listfile which "
-     "is currently being processed (CMAKE_CURRENT_LIST_FILE) is located.  "
-     "The value has dynamic scope.  "
-     "When CMake starts processing commands in a source file "
-     "it sets this variable to the directory where this file is located.  "
-     "When CMake finishes processing commands from the file it "
-     "restores the previous value.  "
-     "Therefore the value of the variable inside a macro or "
-     "function is the directory of the file invoking the bottom-most entry on "
-     "the call stack, not the directory of the file containing the macro or "
-     "function definition."
-     "\n"
-     "See also CMAKE_CURRENT_LIST_FILE.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_SCRIPT_MODE_FILE", cmProperty::VARIABLE,
-     "Full path to the -P script file currently being processed.",
-     "When run in -P script mode, CMake sets this variable to the full "
-     "path of the script file. When run to configure a CMakeLists.txt "
-     "file, this variable is not set.", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_ARGC", cmProperty::VARIABLE,
-     "Number of command line arguments passed to CMake in script mode.",
-     "When run in -P script mode, CMake sets this variable to the number "
-     "of command line arguments. See also CMAKE_ARGV0, 1, 2 ...", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_ARGV0", cmProperty::VARIABLE,
-     "Command line argument passed to CMake in script mode.",
-     "When run in -P script mode, CMake sets this variable to "
-     "the first command line argument. It then also sets CMAKE_ARGV1, "
-     "CMAKE_ARGV2, ... and so on, up to the number of command line arguments "
-     "given. See also CMAKE_ARGC.", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_BUILD_TOOL", cmProperty::VARIABLE,
-     "Tool used for the actual build process.",
-     "This variable is set to the program that will be"
-     " needed to build the output of CMake.   If the "
-     "generator selected was Visual Studio 6, the "
-     "CMAKE_BUILD_TOOL will be set to msdev, for "
-     "Unix Makefiles it will be set to make or gmake, "
-     "and for Visual Studio 7 it set to devenv.  For "
-     "NMake Makefiles the value is nmake. This can be "
-     "useful for adding special flags and commands based"
-     " on the final build environment.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_CROSSCOMPILING", cmProperty::VARIABLE,
-     "Is CMake currently cross compiling.",
-     "This variable will be set to true by CMake if CMake is cross "
-     "compiling. Specifically if the build platform is different "
-     "from the target platform.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_CACHEFILE_DIR", cmProperty::VARIABLE,
-     "The directory with the CMakeCache.txt file.",
-     "This is the full path to the directory that has the "
-     "CMakeCache.txt file in it.  This is the same as "
-     "CMAKE_BINARY_DIR.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_CACHE_MAJOR_VERSION", cmProperty::VARIABLE,
-     "Major version of CMake used to create the CMakeCache.txt file",
-     "This stores the major version of CMake used to "
-     "write a CMake cache file. It is only different when "
-     "a different version of CMake is run on a previously "
-     "created cache file.", false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_CACHE_MINOR_VERSION", cmProperty::VARIABLE,
-     "Minor version of CMake used to create the CMakeCache.txt file",
-     "This stores the minor version of CMake used to "
-     "write a CMake cache file. It is only different when "
-     "a different version of CMake is run on a previously "
-     "created cache file.", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_CACHE_PATCH_VERSION", cmProperty::VARIABLE,
-     "Patch version of CMake used to create the CMakeCache.txt file",
-     "This stores the patch version of CMake used to "
-     "write a CMake cache file. It is only different when "
-     "a different version of CMake is run on a previously "
-     "created cache file.", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_CFG_INTDIR", cmProperty::VARIABLE,
-     "Build-time reference to per-configuration output subdirectory.",
-     "For native build systems supporting multiple configurations "
-     "in the build tree (such as Visual Studio and Xcode), "
-     "the value is a reference to a build-time variable specifying "
-     "the name of the per-configuration output subdirectory.  "
-     "On Makefile generators this evaluates to \".\" because there "
-     "is only one configuration in a build tree.  "
-     "Example values:\n"
-     "  $(IntDir)        = Visual Studio 6\n"
-     "  $(OutDir)        = Visual Studio 7, 8, 9\n"
-     "  $(Configuration) = Visual Studio 10\n"
-     "  $(CONFIGURATION) = Xcode\n"
-     "  .                = Make-based tools\n"
-     "Since these values are evaluated by the native build system, this "
-     "variable is suitable only for use in command lines that will be "
-     "evaluated at build time.  "
-     "Example of intended usage:\n"
-     "  add_executable(mytool mytool.c)\n"
-     "  add_custom_command(\n"
-     "    OUTPUT out.txt\n"
-     "    COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool\n"
-     "            ${CMAKE_CURRENT_SOURCE_DIR}/in.txt out.txt\n"
-     "    DEPENDS mytool in.txt\n"
-     "    )\n"
-     "  add_custom_target(drive ALL DEPENDS out.txt)\n"
-     "Note that CMAKE_CFG_INTDIR is no longer necessary for this purpose "
-     "but has been left for compatibility with existing projects.  "
-     "Instead add_custom_command() recognizes executable target names in "
-     "its COMMAND option, so "
-     "\"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/mytool\" can be "
-     "replaced by just \"mytool\"."
-     "\n"
-     "This variable is read-only.  Setting it is undefined behavior.  "
-     "In multi-configuration build systems the value of this variable "
-     "is passed as the value of preprocessor symbol \"CMAKE_INTDIR\" to "
-     "the compilation of all source files.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_CTEST_COMMAND", cmProperty::VARIABLE,
-     "Full path to ctest command installed with cmake.",
-     "This is the full path to the CTest executable ctest "
-     "which is useful from custom commands that want "
-     "to use the cmake -E option for portable system "
-     "commands.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_DL_LIBS", cmProperty::VARIABLE,
-     "Name of library containing dlopen and dlcose.",
-     "The name of the library that has dlopen and "
-     "dlclose in it, usually -ldl on most UNIX machines.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_EDIT_COMMAND", cmProperty::VARIABLE,
-     "Full path to cmake-gui or ccmake.",
-     "This is the full path to the CMake executable "
-     "that can graphically edit the cache.  For example,"
-     " cmake-gui, ccmake, or cmake -i.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_GENERATOR", cmProperty::VARIABLE,
-     "The generator used to build the project.",
-     "The name of the generator that is being used to generate the "
-     "build files.  (e.g. \"Unix Makefiles\", "
-     "\"Visual Studio 6\", etc.)",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_EXTRA_GENERATOR", cmProperty::VARIABLE,
-     "The extra generator used to build the project.",
-     "When using the Eclipse, CodeBlocks or KDevelop generators, CMake "
-     "generates Makefiles (CMAKE_GENERATOR) and additionally project files "
-     "for the respective IDE. This IDE project file generator is stored in "
-     "CMAKE_EXTRA_GENERATOR (e.g. \"Eclipse CDT4\").",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_GENERATOR_TOOLSET", cmProperty::VARIABLE,
-     "Native build system toolset name specified by user.",
-     "Some CMake generators support a toolset name to be given to the "
-     "native build system to choose a compiler.  "
-     "If the user specifies a toolset name (e.g. via the cmake -T option) "
-     "the value will be available in this variable.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_HOME_DIRECTORY", cmProperty::VARIABLE,
-     "Path to top of source tree.",
-     "This is the path to the top level of the source tree.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_LINK_LIBRARY_SUFFIX", cmProperty::VARIABLE,
-     "The suffix for libraries that you link to.",
-     "The suffix to use for the end of a library filename, .lib on Windows."
-     ,false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_EXECUTABLE_SUFFIX", cmProperty::VARIABLE,
-     "The suffix for executables on this platform.",
-     "The suffix to use for the end of an executable filename if any, "
-     ".exe on Windows."
-     "\n"
-     "CMAKE_EXECUTABLE_SUFFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_MAJOR_VERSION", cmProperty::VARIABLE,
-     "The Major version of cmake (i.e. the 2 in 2.X.X)",
-     "This specifies the major version of the CMake executable"
-     " being run.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_MAKE_PROGRAM", cmProperty::VARIABLE,
-     "See CMAKE_BUILD_TOOL.",
-     "This variable is around for backwards compatibility, "
-     "see CMAKE_BUILD_TOOL.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_VS_PLATFORM_TOOLSET", cmProperty::VARIABLE,
-     "Visual Studio Platform Toolset name.",
-     "VS 10 and above use MSBuild under the hood and support multiple "
-     "compiler toolchains.  "
-     "CMake may specify a toolset explicitly, such as \"v110\" for "
-     "VS 11 or \"Windows7.1SDK\" for 64-bit support in VS 10 Express.  "
-     "CMake provides the name of the chosen toolset in this variable."
-     ,false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_XCODE_PLATFORM_TOOLSET", cmProperty::VARIABLE,
-     "Xcode compiler selection.",
-     "Xcode supports selection of a compiler from one of the installed "
-     "toolsets.  "
-     "CMake provides the name of the chosen toolset in this variable, "
-     "if any is explicitly selected (e.g. via the cmake -T option)."
-     ,false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_MINOR_VERSION", cmProperty::VARIABLE,
-     "The Minor version of cmake (i.e. the 4 in X.4.X).",
-     "This specifies the minor version of the CMake"
-     " executable being run.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_PATCH_VERSION", cmProperty::VARIABLE,
-     "The patch version of cmake (i.e. the 3 in X.X.3).",
-     "This specifies the patch version of the CMake"
-     " executable being run.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_TWEAK_VERSION", cmProperty::VARIABLE,
-     "The tweak version of cmake (i.e. the 1 in X.X.X.1).",
-     "This specifies the tweak version of the CMake executable being run.  "
-     "Releases use tweak < 20000000 and development versions use the date "
-     "format CCYYMMDD for the tweak level."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_VERSION", cmProperty::VARIABLE,
-     "The full version of cmake in major.minor.patch[.tweak[-id]] format.",
-     "This specifies the full version of the CMake executable being run.  "
-     "This variable is defined by versions 2.6.3 and higher.  "
-     "See variables CMAKE_MAJOR_VERSION, CMAKE_MINOR_VERSION, "
-     "CMAKE_PATCH_VERSION, and CMAKE_TWEAK_VERSION "
-     "for individual version components.  "
-     "The [-id] component appears in non-release versions "
-     "and may be arbitrary text.", false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_PARENT_LIST_FILE", cmProperty::VARIABLE,
-     "Full path to the CMake file that included the current one.",
-     "While processing a CMake file loaded by include() or find_package() "
-     "this variable contains the full path to the file including it.  "
-     "The top of the include stack is always the CMakeLists.txt for the "
-     "current directory.  "
-     "See also CMAKE_CURRENT_LIST_FILE.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_PROJECT_NAME", cmProperty::VARIABLE,
-     "The name of the current project.",
-     "This specifies name of the current project from"
-     " the closest inherited PROJECT command.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_RANLIB", cmProperty::VARIABLE,
-     "Name of randomizing tool for static libraries.",
-     "This specifies name of the program that randomizes "
-     "libraries on UNIX, not used on Windows, but may be present.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_ROOT", cmProperty::VARIABLE,
-     "Install directory for running cmake.",
-     "This is the install root for the running CMake and"
-     " the Modules directory can be found here. This is"
-     " commonly used in this format: ${CMAKE_ROOT}/Modules",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SIZEOF_VOID_P", cmProperty::VARIABLE,
-     "Size of a void pointer.",
-     "This is set to the size of a pointer on the machine, "
-     "and is determined by a try compile. If a 64 bit size "
-     "is found, then the library search path is modified to "
-     "look for 64 bit libraries first.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SKIP_RPATH", cmProperty::VARIABLE,
-     "If true, do not add run time path information.",
-     "If this is set to TRUE, then the rpath information "
-     "is not added to compiled executables.  The default "
-     "is to add rpath information if the platform supports it.  "
-     "This allows for easy running from the build tree.  To omit RPATH "
-     "in the install step, but not the build step, use "
-     "CMAKE_SKIP_INSTALL_RPATH instead.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SOURCE_DIR", cmProperty::VARIABLE,
-     "Source directory for project.",
-     "This is the top level source directory for the project.  "
-     "It corresponds to the source directory given to "
-     "cmake-gui or ccmake.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_STANDARD_LIBRARIES", cmProperty::VARIABLE,
-     "Libraries linked into every executable and shared library.",
-     "This is the list of libraries that are linked "
-     "into all executables and libraries.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_VERBOSE_MAKEFILE", cmProperty::VARIABLE,
-     "Create verbose makefiles if on.",
-     "This variable defaults to false. You can set "
-     "this variable to true to make CMake produce verbose "
-     "makefiles that show each command line as it is used.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("PROJECT_BINARY_DIR", cmProperty::VARIABLE,
-     "Full path to build directory for project.",
-     "This is the binary directory of the most recent "
-     "PROJECT command.",false,"Variables that Provide Information");
-  cm->DefineProperty
-    ("PROJECT_NAME", cmProperty::VARIABLE,
-     "Name of the project given to the project command.",
-     "This is the name given to the most "
-     "recent PROJECT command.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("PROJECT_SOURCE_DIR", cmProperty::VARIABLE,
-     "Top level source directory for the current project.",
-     "This is the source directory of the most recent "
-     "PROJECT command.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("<PROJECT-NAME>_BINARY_DIR", cmProperty::VARIABLE,
-     "Top level binary directory for the named project.",
-     "A variable is created with the name used in the PROJECT "
-     "command, and is the binary directory for the project.  "
-     " This can be useful when SUBDIR is used to connect "
-     "several projects.",false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("<PROJECT-NAME>_SOURCE_DIR", cmProperty::VARIABLE,
-     "Top level source directory for the named project.",
-     "A variable is created with the name used in the PROJECT "
-     "command, and is the source directory for the project."
-     "   This can be useful when add_subdirectory "
-     "is used to connect several projects.",false,
-     "Variables that Provide Information");
-
-  cm->DefineProperty
-    ("CMAKE_IMPORT_LIBRARY_PREFIX", cmProperty::VARIABLE,
-     "The prefix for import libraries that you link to.",
-     "The prefix to use for the name of an import library if used "
-     "on this platform."
-     "\n"
-     "CMAKE_IMPORT_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_IMPORT_LIBRARY_SUFFIX", cmProperty::VARIABLE,
-     "The suffix for import libraries that you link to.",
-     "The suffix to use for the end of an import library filename if used "
-     "on this platform."
-     "\n"
-     "CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SHARED_LIBRARY_PREFIX", cmProperty::VARIABLE,
-     "The prefix for shared libraries that you link to.",
-     "The prefix to use for the name of a shared library, lib on UNIX."
-     "\n"
-     "CMAKE_SHARED_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SHARED_LIBRARY_SUFFIX", cmProperty::VARIABLE,
-     "The suffix for shared libraries that you link to.",
-     "The suffix to use for the end of a shared library filename, "
-     ".dll on Windows."
-     "\n"
-     "CMAKE_SHARED_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SHARED_MODULE_PREFIX", cmProperty::VARIABLE,
-     "The prefix for loadable modules that you link to.",
-     "The prefix to use for the name of a loadable module on this platform."
-     "\n"
-     "CMAKE_SHARED_MODULE_PREFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_SHARED_MODULE_SUFFIX", cmProperty::VARIABLE,
-     "The suffix for shared libraries that you link to.",
-     "The suffix to use for the end of a loadable module filename "
-     "on this platform"
-     "\n"
-     "CMAKE_SHARED_MODULE_SUFFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_STATIC_LIBRARY_PREFIX", cmProperty::VARIABLE,
-     "The prefix for static libraries that you link to.",
-     "The prefix to use for the name of a static library, lib on UNIX."
-     "\n"
-     "CMAKE_STATIC_LIBRARY_PREFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_STATIC_LIBRARY_SUFFIX", cmProperty::VARIABLE,
-     "The suffix for static libraries that you link to.",
-     "The suffix to use for the end of a static library filename, "
-     ".lib on Windows."
-     "\n"
-     "CMAKE_STATIC_LIBRARY_SUFFIX_<LANG> overrides this for language <LANG>."
-     ,false, "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES", cmProperty::VARIABLE,
-     "Additional suffixes for shared libraries.",
-     "Extensions for shared libraries other than that specified by "
-     "CMAKE_SHARED_LIBRARY_SUFFIX, if any.  "
-     "CMake uses this to recognize external shared library files during "
-     "analysis of libraries linked by a target.",
-     false,
-     "Variables that Provide Information");
-  cm->DefineProperty
-    ("CMAKE_MINIMUM_REQUIRED_VERSION", cmProperty::VARIABLE,
-     "Version specified to cmake_minimum_required command",
-     "Variable containing the VERSION component specified in the "
-     "cmake_minimum_required command.",
-     false,
-     "Variables that Provide Information");
-
-
-  // Variables defined by cmake, that change the behavior
-  // of cmake
-
-  cm->DefineProperty
-    ("CMAKE_POLICY_DEFAULT_CMP<NNNN>",  cmProperty::VARIABLE,
-     "Default for CMake Policy CMP<NNNN> when it is otherwise left unset.",
-     "Commands cmake_minimum_required(VERSION) and cmake_policy(VERSION) "
-     "by default leave policies introduced after the given version unset.  "
-     "Set CMAKE_POLICY_DEFAULT_CMP<NNNN> to OLD or NEW to specify the "
-     "default for policy CMP<NNNN>, where <NNNN> is the policy number."
-     "\n"
-     "This variable should not be set by a project in CMake code; "
-     "use cmake_policy(SET) instead.  "
-     "Users running CMake may set this variable in the cache "
-     "(e.g. -DCMAKE_POLICY_DEFAULT_CMP<NNNN>=<OLD|NEW>) "
-     "to set a policy not otherwise set by the project.  "
-     "Set to OLD to quiet a policy warning while using old behavior "
-     "or to NEW to try building the project with new behavior.",
-     false,
-     "Variables That Change Behavior");
-
-    cm->DefineProperty
-    ("CMAKE_AUTOMOC_RELAXED_MODE",  cmProperty::VARIABLE,
-     "Switch between strict and relaxed automoc mode.",
-     "By default, automoc behaves exactly as described in the documentation "
-     "of the AUTOMOC target property.  "
-     "When set to TRUE, it accepts more input and tries to find the correct "
-     "input file for moc even if it differs from the documented behaviour.  "
-     "In this mode it e.g. also checks whether a header file is intended to "
-     "be processed by moc when a \"foo.moc\" file has been included.\n"
-     "Relaxed mode has to be enabled for KDE4 compatibility.",
-     false,
-     "Variables That Change Behavior");
-
-    cm->DefineProperty
-    ("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME",  cmProperty::VARIABLE,
-     "Default component used in install() commands.",
-     "If an install() command is used without the COMPONENT argument, "
-     "these files will be grouped into a default component. The name of this "
-     "default install component will be taken from this variable.  "
-     "It defaults to \"Unspecified\".",
-     false,
-     "Variables That Change Behavior");
-
-    cm->DefineProperty
-    ("CMAKE_FIND_LIBRARY_PREFIXES",  cmProperty::VARIABLE,
-     "Prefixes to prepend when looking for libraries.",
-     "This specifies what prefixes to add to library names when "
-     "the find_library command looks for libraries. On UNIX "
-     "systems this is typically lib, meaning that when trying "
-     "to find the foo library it will look for libfoo.",
-     false,
-     "Variables That Change Behavior");
-
-    cm->DefineProperty
-    ("CMAKE_FIND_LIBRARY_SUFFIXES",  cmProperty::VARIABLE,
-     "Suffixes to append when looking for libraries.",
-     "This specifies what suffixes to add to library names when "
-     "the find_library command looks for libraries. On Windows "
-     "systems this is typically .lib and .dll, meaning that when trying "
-     "to find the foo library it will look for foo.dll etc.",
-     false,
-     "Variables That Change Behavior");
-
-    cm->DefineProperty
-    ("CMAKE_CONFIGURATION_TYPES",  cmProperty::VARIABLE,
-     "Specifies the available build types on multi-config generators.",
-     "This specifies what build types (configurations) will be available "
-     "such as Debug, Release, RelWithDebInfo etc.  "
-     "This has reasonable defaults on most platforms, "
-     "but can be extended to provide other build types.  "
-     "See also CMAKE_BUILD_TYPE for details of managing configuration data, "
-     "and CMAKE_CFG_INTDIR."
-     ,false,
-     "Variables That Change Behavior");
-
-    cm->DefineProperty
-    ("CMAKE_BUILD_TYPE",  cmProperty::VARIABLE,
-     "Specifies the build type on single-configuration generators.",
-     "This statically specifies what build type (configuration) "
-     "will be built in this build tree. Possible values are "
-     "empty, Debug, Release, RelWithDebInfo and MinSizeRel.  "
-     "This variable is only meaningful to single-configuration generators "
-     "(such as make and Ninja) i.e. "
-     "those which choose a single configuration "
-     "when CMake runs to generate a build tree as opposed to "
-     "multi-configuration generators which offer selection of the build "
-     "configuration within the generated build environment.  "
-     "There are many per-config properties and variables "
-     "(usually following clean SOME_VAR_<CONFIG> order conventions), "
-     "such as CMAKE_C_FLAGS_<CONFIG>, specified as uppercase: "
-     "CMAKE_C_FLAGS_[DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL].  "
-     "For example, in a build tree configured "
-     "to build type Debug, CMake will see to having "
-     "CMAKE_C_FLAGS_DEBUG settings get added to the CMAKE_C_FLAGS settings.  "
-     "See also CMAKE_CONFIGURATION_TYPES."
-     ,false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_BACKWARDS_COMPATIBILITY", cmProperty::VARIABLE,
-     "Version of cmake required to build project",
-     "From the point of view of backwards compatibility, this "
-     "specifies what version of CMake should be supported. By "
-     "default this value is the version number of CMake that "
-     "you are running. You can set this to an older version of"
-     " CMake to support deprecated commands of CMake in projects"
-     " that were written to use older versions of CMake. This "
-     "can be set by the user or set at the beginning of a "
-     "CMakeLists file.",false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_INSTALL_PREFIX", cmProperty::VARIABLE,
-     "Install directory used by install.",
-     "If \"make install\" is invoked or INSTALL is built"
-     ", this directory is prepended onto all install "
-     "directories. This variable defaults to /usr/local"
-     " on UNIX and c:/Program Files on Windows.\n"
-     "On UNIX one can use the DESTDIR mechanism in order"
-     " to relocate the whole installation.  "
-     "DESTDIR means DESTination DIRectory. It is "
-     "commonly used by makefile users "
-     "in order to install software at non-default location.  "
-     "It is usually invoked like this:\n"
-     " make DESTDIR=/home/john install\n"
-     "which will install the concerned software using the"
-     " installation prefix, e.g. \"/usr/local\" prepended with "
-     "the DESTDIR value which finally gives \"/home/john/usr/local\".\n"
-     "WARNING: DESTDIR may not be used on Windows because installation"
-     " prefix usually contains a drive letter like in \"C:/Program Files\""
-     " which cannot be prepended with some other prefix."
-     "\n"
-     "The installation prefix is also added to CMAKE_SYSTEM_PREFIX_PATH "
-     "so that find_package, find_program, find_library, find_path, and "
-     "find_file will search the prefix for other software."
-     ,false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY", cmProperty::VARIABLE,
-     "Don't make the install target depend on the all target.",
-     "By default, the \"install\" target depends on the \"all\" target.  "
-     "This has the effect, that when \"make install\" is invoked or INSTALL "
-     "is built, first the \"all\" target is built, then the installation "
-     "starts.  "
-     "If CMAKE_SKIP_INSTALL_ALL_DEPENDENCY is set to TRUE, this dependency "
-     "is not created, so the installation process will start immediately, "
-     "independent from whether the project has been completely built or not."
-     ,false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_MODULE_PATH", cmProperty::VARIABLE,
-     "List of directories to search for CMake modules.",
-     "Commands like include() and find_package() search for files in "
-     "directories listed by this variable before checking the default "
-     "modules that come with CMake.",
-     false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_WARN_DEPRECATED", cmProperty::VARIABLE,
-     "Whether to issue deprecation warnings for macros and functions.",
-     "If TRUE, this can be used by macros and functions to issue "
-     "deprecation warnings.  This variable is FALSE by default.",
-     false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_ERROR_DEPRECATED", cmProperty::VARIABLE,
-     "Whether to issue deprecation errors for macros and functions.",
-     "If TRUE, this can be used by macros and functions to issue "
-     "fatal errors when deprecated macros or functions are used.  This "
-     "variable is FALSE by default.",
-     false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_PREFIX_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_XXX(), with appropriate suffixes added.",
-     "Specifies a path which will be used by the FIND_XXX() commands. It "
-     "contains the \"base\" directories, the FIND_XXX() commands append "
-     "appropriate subdirectories to the base directories. So FIND_PROGRAM() "
-     "adds /bin to each of the directories in the path, FIND_LIBRARY() "
-     "appends /lib to each of the directories, and FIND_PATH() and "
-     "FIND_FILE() append /include . By default it is empty, it is intended "
-     "to be set by the project. See also CMAKE_SYSTEM_PREFIX_PATH, "
-     "CMAKE_INCLUDE_PATH, CMAKE_LIBRARY_PATH, CMAKE_PROGRAM_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_INCLUDE_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_FILE() and FIND_PATH().",
-     "Specifies a path which will be used both by FIND_FILE() and "
-     "FIND_PATH(). Both commands will check each of the contained directories "
-     "for the existence of the file which is currently searched. By default "
-     "it is empty, it is intended to be set by the project. See also "
-     "CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_PREFIX_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_LIBRARY_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_LIBRARY().",
-     "Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() "
-     "will check each of the contained directories for the existence of the "
-     "library which is currently searched. By default it is empty, it is "
-     "intended to be set by the project. See also CMAKE_SYSTEM_LIBRARY_PATH, "
-     "CMAKE_PREFIX_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_PROGRAM_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_PROGRAM().",
-     "Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM() "
-     "will check each of the contained directories for the existence of the "
-     "program which is currently searched. By default it is empty, it is "
-     "intended to be set by the project. See also CMAKE_SYSTEM_PROGRAM_PATH, "
-     " CMAKE_PREFIX_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_PREFIX_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_XXX(), with appropriate suffixes added.",
-     "Specifies a path which will be used by the FIND_XXX() commands. It "
-     "contains the \"base\" directories, the FIND_XXX() commands append "
-     "appropriate subdirectories to the base directories. So FIND_PROGRAM() "
-     "adds /bin to each of the directories in the path, FIND_LIBRARY() "
-     "appends /lib to each of the directories, and FIND_PATH() and "
-     "FIND_FILE() append /include . By default this contains the standard "
-     "directories for the current system and the CMAKE_INSTALL_PREFIX.  "
-     "It is NOT intended "
-     "to be modified by the project, use CMAKE_PREFIX_PATH for this. See also "
-     "CMAKE_SYSTEM_INCLUDE_PATH, CMAKE_SYSTEM_LIBRARY_PATH, "
-     "CMAKE_SYSTEM_PROGRAM_PATH, and CMAKE_SYSTEM_IGNORE_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_IGNORE_PATH", cmProperty::VARIABLE,
-     "Path to be ignored by FIND_XXX() commands.",
-     "Specifies directories to be ignored by searches in FIND_XXX() "
-     "commands.  "
-     "This is useful in cross-compiled environments where some system "
-     "directories contain incompatible but possibly linkable libraries. For "
-     "example, on cross-compiled cluster environments, this allows a user to "
-     "ignore directories containing libraries meant for the front-end "
-     "machine that modules like FindX11 (and others) would normally search.  "
-     "By default this contains a list of directories containing incompatible "
-     "binaries for the host system.  "
-     "See also CMAKE_SYSTEM_PREFIX_PATH, CMAKE_SYSTEM_LIBRARY_PATH, "
-     "CMAKE_SYSTEM_INCLUDE_PATH, and CMAKE_SYSTEM_PROGRAM_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_IGNORE_PATH", cmProperty::VARIABLE,
-     "Path to be ignored by FIND_XXX() commands.",
-     "Specifies directories to be ignored by searches in FIND_XXX() "
-     "commands.  "
-     "This is useful in cross-compiled environments where some system "
-     "directories contain incompatible but possibly linkable libraries. For "
-     "example, on cross-compiled cluster environments, this allows a user to "
-     "ignore directories containing libraries meant for the front-end "
-     "machine that modules like FindX11 (and others) would normally search.  "
-     "By default this is empty; it is intended to be set by the project.  "
-     "Note that CMAKE_IGNORE_PATH takes a list of directory names, NOT a "
-     "list of prefixes. If you want to ignore paths under prefixes (bin, "
-     "include, lib, etc.), you'll need to specify them explicitly.  "
-     "See also CMAKE_PREFIX_PATH, CMAKE_LIBRARY_PATH, CMAKE_INCLUDE_PATH, "
-     "CMAKE_PROGRAM_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_INCLUDE_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_FILE() and FIND_PATH().",
-     "Specifies a path which will be used both by FIND_FILE() and "
-     "FIND_PATH(). Both commands will check each of the contained directories "
-     "for the existence of the file which is currently searched. By default "
-     "it contains the standard directories for the current system. It is "
-     "NOT intended to be modified by the project, use CMAKE_INCLUDE_PATH "
-     "for this. See also CMAKE_SYSTEM_PREFIX_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_LIBRARY_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_LIBRARY().",
-     "Specifies a path which will be used by FIND_LIBRARY(). FIND_LIBRARY() "
-     "will check each of the contained directories for the existence of the "
-     "library which is currently searched. By default it contains the "
-     "standard directories for the current system. It is NOT intended to be "
-     "modified by the project, use CMAKE_LIBRARY_PATH for this. See "
-     "also CMAKE_SYSTEM_PREFIX_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_PROGRAM_PATH", cmProperty::VARIABLE,
-     "Path used for searching by FIND_PROGRAM().",
-     "Specifies a path which will be used by FIND_PROGRAM(). FIND_PROGRAM() "
-     "will check each of the contained directories for the existence of the "
-     "program which is currently searched. By default it contains the "
-     "standard directories for the current system. It is NOT intended to be "
-     "modified by the project, use CMAKE_PROGRAM_PATH for this. See also "
-     "CMAKE_SYSTEM_PREFIX_PATH.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_DISABLE_FIND_PACKAGE_<PackageName>", cmProperty::VARIABLE,
-     "Variable for disabling find_package() calls.",
-     "Every non-REQUIRED find_package() call in a project can be disabled "
-     "by setting the variable CMAKE_DISABLE_FIND_PACKAGE_<PackageName> to "
-     "TRUE. This can be used to build a project without an optional package, "
-     "although that package is installed.\n"
-     "This switch should be used during the initial CMake run. Otherwise if "
-     "the package has already been found in a previous CMake run, the "
-     "variables which have been stored in the cache will still be there.  "
-     "In that case it is recommended to remove the cache variables for "
-     "this package from the cache using the cache editor or cmake -U", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_FIND_PACKAGE_WARN_NO_MODULE", cmProperty::VARIABLE,
-     "Tell find_package to warn if called without an explicit mode.",
-     "If find_package is called without an explicit mode option "
-     "(MODULE, CONFIG or NO_MODULE) and no Find<pkg>.cmake module is "
-     "in CMAKE_MODULE_PATH then CMake implicitly assumes that the "
-     "caller intends to search for a package configuration file.  "
-     "If no package configuration file is found then the wording "
-     "of the failure message must account for both the case that the "
-     "package is really missing and the case that the project has a "
-     "bug and failed to provide the intended Find module.  "
-     "If instead the caller specifies an explicit mode option then "
-     "the failure message can be more specific."
-     "\n"
-     "Set CMAKE_FIND_PACKAGE_WARN_NO_MODULE to TRUE to tell find_package "
-     "to warn when it implicitly assumes Config mode.  "
-     "This helps developers enforce use of an explicit mode in all calls "
-     "to find_package within a project.", false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_USER_MAKE_RULES_OVERRIDE", cmProperty::VARIABLE,
-     "Specify a CMake file that overrides platform information.",
-     "CMake loads the specified file while enabling support for each "
-     "language from either the project() or enable_language() commands.  "
-     "It is loaded after CMake's builtin compiler and platform information "
-     "modules have been loaded but before the information is used.  "
-     "The file may set platform information variables to override CMake's "
-     "defaults."
-     "\n"
-     "This feature is intended for use only in overriding information "
-     "variables that must be set before CMake builds its first test "
-     "project to check that the compiler for a language works.  "
-     "It should not be used to load a file in cases that a normal include() "
-     "will work.  "
-     "Use it only as a last resort for behavior that cannot be achieved "
-     "any other way.  "
-     "For example, one may set CMAKE_C_FLAGS_INIT to change the default "
-     "value used to initialize CMAKE_C_FLAGS before it is cached.  "
-     "The override file should NOT be used to set anything that could "
-     "be set after languages are enabled, such as variables like "
-     "CMAKE_RUNTIME_OUTPUT_DIRECTORY that affect the placement of binaries.  "
-     "Information set in the file will be used for try_compile and try_run "
-     "builds too."
-     ,false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("BUILD_SHARED_LIBS", cmProperty::VARIABLE,
-     "Global flag to cause add_library to create shared libraries if on.",
-     "If present and true, this will cause all libraries to be "
-     "built shared unless the library was explicitly added as a "
-     "static library.  This variable is often added to projects "
-     "as an OPTION so that each user of a project can decide if "
-     "they want to build the project using shared or static "
-     "libraries.",false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_NOT_USING_CONFIG_FLAGS", cmProperty::VARIABLE,
-     "Skip _BUILD_TYPE flags if true.",
-     "This is an internal flag used by the generators in "
-     "CMake to tell CMake to skip the _BUILD_TYPE flags.",false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_MFC_FLAG", cmProperty::VARIABLE,
-     "Tell cmake to use MFC for an executable or dll.",
-     "This can be set in a CMakeLists.txt file and will "
-     "enable MFC in the application.  It should be set "
-     "to 1 for the static MFC library, and 2 for "
-     "the shared MFC library.  This is used in Visual "
-     "Studio 6 and 7 project files.   The CMakeSetup "
-     "dialog used MFC and the CMakeLists.txt looks like this:\n"
-     "  add_definitions(-D_AFXDLL)\n"
-     "  set(CMAKE_MFC_FLAG 2)\n"
-     "  add_executable(CMakeSetup WIN32 ${SRCS})\n",false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_COLOR_MAKEFILE", cmProperty::VARIABLE,
-     "Enables color output when using the Makefile generator.",
-     "When enabled, the generated Makefiles will produce colored output.  "
-     "Default is ON.",false,
-     "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_ABSOLUTE_DESTINATION_FILES", cmProperty::VARIABLE,
-      "List of files which have been installed using "
-      " an ABSOLUTE DESTINATION path.",
-      "This variable is defined by CMake-generated cmake_install.cmake "
-      "scripts."
-      " It can be used (read-only) by programs or scripts that source those"
-      " install scripts. This is used by some CPack generators (e.g. RPM).",
-      false,
-      "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
-      "Ask cmake_install.cmake script to warn each time a file with "
-      "absolute INSTALL DESTINATION is encountered.",
-      "This variable is used by CMake-generated cmake_install.cmake"
-      " scripts. If one sets this variable to ON while running the"
-      " script, it may get warning messages from the script.", false,
-      "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
-      "Ask cmake_install.cmake script to error out as soon as "
-      "a file with absolute INSTALL DESTINATION is encountered.",
-      "The fatal error is emitted before the installation of "
-      "the offending file takes place."
-      " This variable is used by CMake-generated cmake_install.cmake"
-      " scripts. If one sets this variable to ON while running the"
-      " script, it may get fatal error messages from the script.",false,
-      "Variables That Change Behavior");
-
-  cm->DefineProperty
-    ("CMAKE_DEBUG_TARGET_PROPERTIES", cmProperty::VARIABLE,
-     "Enables tracing output for target properties.",
-     "This variable can be populated with a list of properties to generate "
-     "debug output for when evaluating target properties.  Currently it can "
-     "only be used when evaluating the INCLUDE_DIRECTORIES, "
-     "COMPILE_DEFINITIONS and COMPILE_OPTIONS target properties.  "
-     "In that case, it outputs a backtrace for each entry in the target "
-     "property.  Default is unset.", false, "Variables That Change Behavior");
-
-  // Variables defined by CMake that describe the system
-
-  cm->DefineProperty
-    ("CMAKE_SYSTEM", cmProperty::VARIABLE,
-     "Name of system cmake is compiling for.",
-     "This variable is the composite of CMAKE_SYSTEM_NAME "
-     "and CMAKE_SYSTEM_VERSION, like this "
-     "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}.  "
-     "If CMAKE_SYSTEM_VERSION is not set, then "
-     "CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_NAME", cmProperty::VARIABLE,
-     "Name of the OS CMake is building for.",
-     "This is the name of the operating system on "
-     "which CMake is targeting.   On systems that "
-     "have the uname command, this variable is set "
-     "to the output of uname -s.  Linux, Windows, "
-     " and Darwin for Mac OS X are the values found "
-     " on the big three operating systems."  ,false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_PROCESSOR", cmProperty::VARIABLE,
-     "The name of the CPU CMake is building for.",
-     "On systems that support uname, this variable is "
-     "set to the output of uname -p, on windows it is "
-     "set to the value of the environment variable "
-     "PROCESSOR_ARCHITECTURE",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_SYSTEM_VERSION", cmProperty::VARIABLE,
-     "OS version CMake is building for.",
-     "A numeric version string for the system, on "
-     "systems that support uname, this variable is "
-     "set to the output of uname -r. On other "
-     "systems this is set to major-minor version numbers.",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_LIBRARY_ARCHITECTURE", cmProperty::VARIABLE,
-     "Target architecture library directory name, if detected.",
-     "This is the value of CMAKE_<lang>_LIBRARY_ARCHITECTURE as "
-     "detected for one of the enabled languages.",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_LIBRARY_ARCHITECTURE_REGEX", cmProperty::VARIABLE,
-     "Regex matching possible target architecture library directory names.",
-     "This is used to detect CMAKE_<lang>_LIBRARY_ARCHITECTURE from the "
-     "implicit linker search path by matching the <arch> name.",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_HOST_SYSTEM", cmProperty::VARIABLE,
-     "Name of system cmake is being run on.",
-     "The same as CMAKE_SYSTEM but for the host system instead "
-     "of the target system when cross compiling.",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_HOST_SYSTEM_NAME", cmProperty::VARIABLE,
-     "Name of the OS CMake is running on.",
-     "The same as CMAKE_SYSTEM_NAME but for the host system instead "
-     "of the target system when cross compiling.",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_HOST_SYSTEM_PROCESSOR", cmProperty::VARIABLE,
-     "The name of the CPU CMake is running on.",
-     "The same as CMAKE_SYSTEM_PROCESSOR but for the host system instead "
-     "of the target system when cross compiling.",false,
-     "Variables That Describe the System");
-  cm->DefineProperty
-    ("CMAKE_HOST_SYSTEM_VERSION", cmProperty::VARIABLE,
-     "OS version CMake is running on.",
-     "The same as CMAKE_SYSTEM_VERSION but for the host system instead "
-     "of the target system when cross compiling.",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("APPLE", cmProperty::VARIABLE,
-     "True if running on Mac OS X.",
-     "Set to true on Mac OS X."
-     ,false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("BORLAND", cmProperty::VARIABLE,
-     "True if the Borland compiler is being used.",
-     "This is set to true if the Borland compiler is being used.",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CYGWIN", cmProperty::VARIABLE,
-     "True for Cygwin.",
-     "Set to true when using Cygwin."
-     ,false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("MSVC", cmProperty::VARIABLE,
-     "True when using Microsoft Visual C",
-     "Set to true when the compiler is some version of Microsoft Visual C.",
-     false,
-     "Variables That Describe the System");
-
-  int msvc_versions[] = { 60, 70, 71, 80, 90, 100, 110, 120, 0 };
-  for (int i = 0; msvc_versions[i] != 0; i ++)
-    {
-    const char minor = (char)('0' + (msvc_versions[i] % 10));
-    cmStdString varName = "MSVC";
-    cmsys_ios::ostringstream majorStr;
-
-    majorStr << (msvc_versions[i] / 10);
-    varName += majorStr.str();
-    if (msvc_versions[i] < 100)
-      {
-      varName += minor;
-      }
-
-    cmStdString verString = majorStr.str() + "." + minor;
-
-    cmStdString shortStr = "True when using Microsoft Visual C " + verString;
-    cmStdString fullStr = "Set to true when the compiler is version " +
-                          verString +
-                          " of Microsoft Visual C.";
-    cm->DefineProperty
-      (varName.c_str(), cmProperty::VARIABLE,
-       shortStr.c_str(),
-       fullStr.c_str(),
-       false,
-       "Variables That Describe the System");
-    }
-
-  cm->DefineProperty
-    ("MSVC_IDE", cmProperty::VARIABLE,
-     "True when using the Microsoft Visual C IDE",
-     "Set to true when the target platform is the Microsoft Visual C IDE, "
-     "as opposed to the command line compiler.",
-     false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("MSVC_VERSION", cmProperty::VARIABLE,
-     "The version of Microsoft Visual C/C++ being used if any.",
-     "Known version numbers are:\n"
-     "  1200 = VS  6.0\n"
-     "  1300 = VS  7.0\n"
-     "  1310 = VS  7.1\n"
-     "  1400 = VS  8.0\n"
-     "  1500 = VS  9.0\n"
-     "  1600 = VS 10.0\n"
-     "  1700 = VS 11.0\n"
-     "  1800 = VS 12.0\n"
-     "",
-     false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_CL_64", cmProperty::VARIABLE,
-     "Using the 64 bit compiler from Microsoft",
-     "Set to true when using the 64 bit cl compiler from Microsoft.",
-     false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_COMPILER_2005", cmProperty::VARIABLE,
-     "Using the Visual Studio 2005 compiler from Microsoft",
-     "Set to true when using the Visual Studio 2005 compiler "
-     "from Microsoft.",
-     false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("UNIX", cmProperty::VARIABLE,
-     "True for UNIX and UNIX like operating systems.",
-     "Set to true when the target system is UNIX or UNIX like "
-     "(i.e. APPLE and CYGWIN).",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("WIN32", cmProperty::VARIABLE,
-     "True on windows systems, including win64.",
-     "Set to true when the target system is Windows.",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("XCODE_VERSION", cmProperty::VARIABLE,
-     "Version of Xcode (Xcode generator only).",
-     "Under the Xcode generator, this is the version of Xcode as specified in "
-     "\"Xcode.app/Contents/version.plist\" (such as \"3.1.2\").",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_HOST_APPLE", cmProperty::VARIABLE,
-     "True for Apple OS X operating systems.",
-     "Set to true when the host system is Apple OS X.",
-     false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_HOST_UNIX", cmProperty::VARIABLE,
-     "True for UNIX and UNIX like operating systems.",
-     "Set to true when the host system is UNIX or UNIX like "
-     "(i.e. APPLE and CYGWIN).",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_HOST_WIN32", cmProperty::VARIABLE,
-     "True on windows systems, including win64.",
-     "Set to true when the host system is Windows and on Cygwin."
-     ,false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("CMAKE_OBJECT_PATH_MAX", cmProperty::VARIABLE,
-     "Maximum object file full-path length allowed by native build tools.",
-     "CMake computes for every source file an object file name that is "
-     "unique to the source file and deterministic with respect to the "
-     "full path to the source file.  "
-     "This allows multiple source files in a target to share the same name "
-     "if they lie in different directories without rebuilding when one is "
-     "added or removed.  "
-     "However, it can produce long full paths in a few cases, so CMake "
-     "shortens the path using a hashing scheme when the full path to an "
-     "object file exceeds a limit.  "
-     "CMake has a built-in limit for each platform that is sufficient for "
-     "common tools, but some native tools may have a lower limit.  "
-     "This variable may be set to specify the limit explicitly.  "
-     "The value must be an integer no less than 128.",false,
-     "Variables That Describe the System");
-
-  cm->DefineProperty
-    ("ENV", cmProperty::VARIABLE,
-     "Access environment variables.",
-     "Use the syntax $ENV{VAR} to read environment variable VAR.  "
-     "See also the set() command to set ENV{VAR}."
-     ,false,
-     "Variables That Describe the System");
-
-  // Variables that affect the building of object files and
-  // targets.
-  //
-  cm->DefineProperty
-    ("CMAKE_INCLUDE_CURRENT_DIR", cmProperty::VARIABLE,
-     "Automatically add the current source- and build directories "
-     "to the include path.",
-     "If this variable is enabled, CMake automatically adds in each "
-     "directory ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} "
-     "to the include path for this directory. These additional include "
-     "directories do not propagate down to subdirectories. This is useful "
-     "mainly for out-of-source builds, where files generated into the "
-     "build tree are included by files located in the source tree.\n"
-     "By default CMAKE_INCLUDE_CURRENT_DIR is OFF.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE", cmProperty::VARIABLE,
-     "Automatically add the current source- and build directories "
-     "to the INTERFACE_INCLUDE_DIRECTORIES.",
-     "If this variable is enabled, CMake automatically adds for each shared "
-     "library target, static library target, module target and executable "
-     "target, ${CMAKE_CURRENT_SOURCE_DIR} and ${CMAKE_CURRENT_BINARY_DIR} to "
-     "the INTERFACE_INCLUDE_DIRECTORIES."
-     "By default CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE is OFF.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_INSTALL_RPATH", cmProperty::VARIABLE,
-     "The rpath to use for installed targets.",
-     "A semicolon-separated list specifying the rpath "
-     "to use in installed targets (for platforms that support it).  "
-     "This is used to initialize the target property "
-     "INSTALL_RPATH for all targets.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_INSTALL_RPATH_USE_LINK_PATH", cmProperty::VARIABLE,
-     "Add paths to linker search and installed rpath.",
-     "CMAKE_INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true "
-     "will append directories in the linker search path and outside the "
-     "project to the INSTALL_RPATH.  "
-     "This is used to initialize the target property "
-     "INSTALL_RPATH_USE_LINK_PATH for all targets.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_INSTALL_NAME_DIR", cmProperty::VARIABLE,
-     "Mac OS X directory name for installed targets.",
-     "CMAKE_INSTALL_NAME_DIR is used to initialize the "
-     "INSTALL_NAME_DIR property on all targets. See that target "
-     "property for more information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_Fortran_FORMAT", cmProperty::VARIABLE,
-     "Set to FIXED or FREE to indicate the Fortran source layout.",
-     "This variable is used to initialize the Fortran_FORMAT "
-     "property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_Fortran_MODULE_DIRECTORY", cmProperty::VARIABLE,
-     "Fortran module output directory.",
-     "This variable is used to initialize the "
-     "Fortran_MODULE_DIRECTORY property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_LIBRARY_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
-     "Where to put all the LIBRARY targets when built.",
-     "This variable is used to initialize the "
-     "LIBRARY_OUTPUT_DIRECTORY property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_ARCHIVE_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
-     "Where to put all the ARCHIVE targets when built.",
-     "This variable is used to initialize the "
-     "ARCHIVE_OUTPUT_DIRECTORY property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_RUNTIME_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
-     "Where to put all the RUNTIME targets when built.",
-     "This variable is used to initialize the "
-     "RUNTIME_OUTPUT_DIRECTORY property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_PDB_OUTPUT_DIRECTORY", cmProperty::VARIABLE,
-     "Where to put all the MS debug symbol files from linker.",
-     "This variable is used to initialize the "
-     "PDB_OUTPUT_DIRECTORY property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_LINK_DEPENDS_NO_SHARED", cmProperty::VARIABLE,
-     "Whether to skip link dependencies on shared library files.",
-     "This variable initializes the LINK_DEPENDS_NO_SHARED "
-     "property on targets when they are created.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_AUTOMOC", cmProperty::VARIABLE,
-     "Whether to handle moc automatically for Qt targets.",
-     "This variable is used to initialize the "
-     "AUTOMOC property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_AUTOMOC_MOC_OPTIONS", cmProperty::VARIABLE,
-     "Additional options for moc when using automoc (see CMAKE_AUTOMOC).",
-     "This variable is used to initialize the "
-     "AUTOMOC_MOC_OPTIONS property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_GNUtoMS", cmProperty::VARIABLE,
-     "Convert GNU import libraries (.dll.a) to MS format (.lib).",
-     "This variable is used to initialize the GNUtoMS property on targets "
-     "when they are created.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_DEBUG_POSTFIX", cmProperty::VARIABLE,
-     "See variable CMAKE_<CONFIG>_POSTFIX.",
-     "This variable is a special case of the more-general "
-     "CMAKE_<CONFIG>_POSTFIX variable for the DEBUG configuration.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_<CONFIG>_POSTFIX", cmProperty::VARIABLE,
-     "Default filename postfix for libraries under configuration <CONFIG>.",
-     "When a non-executable target is created its <CONFIG>_POSTFIX "
-     "target property is initialized with the value of this variable "
-     "if it is set.",
-     false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_BUILD_WITH_INSTALL_RPATH", cmProperty::VARIABLE,
-     "Use the install path for the RPATH",
-     "Normally CMake uses the build tree for the RPATH when building "
-     "executables etc on systems that use RPATH. When the software "
-     "is installed the executables etc are relinked by CMake to have "
-     "the install RPATH. If this variable is set to true then the software "
-     "is always built with the install path for the RPATH and does not "
-     "need to be relinked when installed.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_NO_BUILTIN_CHRPATH", cmProperty::VARIABLE,
-     "Do not use the builtin ELF editor to fix RPATHs on installation.",
-     "When an ELF binary needs to have a different RPATH after installation "
-     "than it does in the build tree, CMake uses a builtin editor to change "
-     "the RPATH in the installed copy.  "
-     "If this variable is set to true then CMake will relink the binary "
-     "before installation instead of using its builtin editor.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_SKIP_BUILD_RPATH", cmProperty::VARIABLE,
-     "Do not include RPATHs in the build tree.",
-     "Normally CMake uses the build tree for the RPATH when building "
-     "executables etc on systems that use RPATH. When the software "
-     "is installed the executables etc are relinked by CMake to have "
-     "the install RPATH. If this variable is set to true then the software "
-     "is always built with no RPATH.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_SKIP_INSTALL_RPATH", cmProperty::VARIABLE,
-     "Do not include RPATHs in the install tree.",
-     "Normally CMake uses the build tree for the RPATH when building "
-     "executables etc on systems that use RPATH. When the software "
-     "is installed the executables etc are relinked by CMake to have "
-     "the install RPATH. If this variable is set to true then the software "
-     "is always installed without RPATH, even if RPATH is enabled when "
-     "building.  This can be useful for example to allow running tests from "
-     "the build directory with RPATH enabled before the installation step.  "
-     "To omit RPATH in both the build and install steps, use "
-     "CMAKE_SKIP_RPATH instead.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_EXE_LINKER_FLAGS", cmProperty::VARIABLE,
-     "Linker flags to be used to create executables.",
-     "These flags will be used by the linker when creating an executable."
-     ,false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_EXE_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
-     "Flags to be used when linking an executable.",
-     "Same as CMAKE_C_FLAGS_* but used by the linker "
-     "when creating executables.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_MODULE_LINKER_FLAGS", cmProperty::VARIABLE,
-     "Linker flags to be used to create modules.",
-     "These flags will be used by the linker when creating a module."
-     ,false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_MODULE_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
-     "Flags to be used when linking a module.",
-     "Same as CMAKE_C_FLAGS_* but used by the linker "
-     "when creating modules.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_SHARED_LINKER_FLAGS", cmProperty::VARIABLE,
-     "Linker flags to be used to create shared libraries.",
-     "These flags will be used by the linker when creating a shared library."
-     ,false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_SHARED_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
-     "Flags to be used when linking a shared library.",
-     "Same as CMAKE_C_FLAGS_* but used by the linker "
-     "when creating shared libraries.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_STATIC_LINKER_FLAGS", cmProperty::VARIABLE,
-     "Linker flags to be used to create static libraries.",
-     "These flags will be used by the linker when creating a static library."
-     ,false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_STATIC_LINKER_FLAGS_<CONFIG>", cmProperty::VARIABLE,
-     "Flags to be used when linking a static library.",
-     "Same as CMAKE_C_FLAGS_* but used by the linker "
-     "when creating static libraries.",false,
-     "Variables that Control the Build");
-
-  cm->DefineProperty
-    ("CMAKE_LIBRARY_PATH_FLAG", cmProperty::VARIABLE,
-     "The flag to be used to add a library search path to a compiler.",
-     "The flag will be used to specify a library directory to the compiler.  "
-     "On most compilers this is \"-L\".",false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_LINK_DEF_FILE_FLAG", cmProperty::VARIABLE,
-     "Linker flag to be used to specify a .def file for dll creation.",
-     "The flag will be used to add a .def file when creating "
-     "a dll on Windows; this is only defined on Windows."
-     ,false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_LINK_LIBRARY_FLAG", cmProperty::VARIABLE,
-     "Flag to be used to link a library into an executable.",
-     "The flag will be used to specify a library to link to an executable.  "
-     "On most compilers this is \"-l\".",false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_LINK_LIBRARY_FILE_FLAG", cmProperty::VARIABLE,
-     "Flag to be used to link a library specified by a path to its file.",
-     "The flag will be used before a library file path is given to the "
-     "linker.  "
-     "This is needed only on very few platforms.", false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_USE_RELATIVE_PATHS", cmProperty::VARIABLE,
-     "Use relative paths (May not work!).",
-     "If this is set to TRUE, then CMake will use "
-     "relative paths between the source and binary tree.  "
-     "This option does not work for more complicated "
-     "projects, and relative paths are used when possible.  "
-     "In general, it is not possible to move CMake generated"
-     " makefiles to a different location regardless "
-     "of the value of this variable.",false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("EXECUTABLE_OUTPUT_PATH", cmProperty::VARIABLE,
-     "Old executable location variable.",
-     "The target property RUNTIME_OUTPUT_DIRECTORY supercedes "
-     "this variable for a target if it is set.  "
-     "Executable targets are otherwise placed in this directory.",false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("LIBRARY_OUTPUT_PATH", cmProperty::VARIABLE,
-     "Old library location variable.",
-     "The target properties ARCHIVE_OUTPUT_DIRECTORY, "
-     "LIBRARY_OUTPUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY supercede "
-     "this variable for a target if they are set.  "
-     "Library targets are otherwise placed in this directory.",false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_TRY_COMPILE_CONFIGURATION", cmProperty::VARIABLE,
-     "Build configuration used for try_compile and try_run projects.",
-     "Projects built by try_compile and try_run are built "
-     "synchronously during the CMake configuration step.  "
-     "Therefore a specific build configuration must be chosen even "
-     "if the generated build system supports multiple configurations.",false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_LINK_INTERFACE_LIBRARIES", cmProperty::VARIABLE,
-     "Default value for LINK_INTERFACE_LIBRARIES of targets.",
-     "This variable is used to initialize the "
-     "LINK_INTERFACE_LIBRARIES property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_WIN32_EXECUTABLE", cmProperty::VARIABLE,
-     "Default value for WIN32_EXECUTABLE of targets.",
-     "This variable is used to initialize the "
-     "WIN32_EXECUTABLE property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_MACOSX_BUNDLE", cmProperty::VARIABLE,
-     "Default value for MACOSX_BUNDLE of targets.",
-     "This variable is used to initialize the "
-     "MACOSX_BUNDLE property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_POSITION_INDEPENDENT_CODE", cmProperty::VARIABLE,
-     "Default value for POSITION_INDEPENDENT_CODE of targets.",
-     "This variable is used to initialize the "
-     "POSITION_INDEPENDENT_CODE property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_NO_SYSTEM_FROM_IMPORTED", cmProperty::VARIABLE,
-     "Default value for NO_SYSTEM_FROM_IMPORTED of targets.",
-     "This variable is used to initialize the "
-     "NO_SYSTEM_FROM_IMPORTED property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_<LANG>_VISIBILITY_PRESET", cmProperty::VARIABLE,
-     "Default value for <LANG>_VISIBILITY_PRESET of targets.",
-     "This variable is used to initialize the "
-     "<LANG>_VISIBILITY_PRESET property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_VISIBILITY_INLINES_HIDDEN", cmProperty::VARIABLE,
-     "Default value for VISIBILITY_INLINES_HIDDEN of targets.",
-     "This variable is used to initialize the "
-     "VISIBILITY_INLINES_HIDDEN property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-  cm->DefineProperty
-    ("CMAKE_MAP_IMPORTED_CONFIG_<CONFIG>", cmProperty::VARIABLE,
-     "Default value for MAP_IMPORTED_CONFIG_<CONFIG> of targets.",
-     "This variable is used to initialize the "
-     "MAP_IMPORTED_CONFIG_<CONFIG> property on all the targets.  "
-     "See that target property for additional information.",
-     false,
-     "Variables that Control the Build");
-
-//   Variables defined when the a language is enabled These variables will
-// also be defined whenever CMake has loaded its support for compiling (LANG)
-// programs. This support will be loaded whenever CMake is used to compile
-// (LANG) files. C and CXX are examples of the most common values for (LANG).
-
-  cm->DefineProperty
-    ("CMAKE_USER_MAKE_RULES_OVERRIDE_<LANG>", cmProperty::VARIABLE,
-     "Specify a CMake file that overrides platform information for <LANG>.",
-     "This is a language-specific version of "
-     "CMAKE_USER_MAKE_RULES_OVERRIDE loaded only when enabling "
-     "language <LANG>.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_COMPILER", cmProperty::VARIABLE,
-     "The full path to the compiler for LANG.",
-     "This is the command that will be used as the <LANG> compiler.  "
-     "Once set, you can not change this variable.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_COMPILER_ID", cmProperty::VARIABLE,
-     "Compiler identification string.",
-     "A short string unique to the compiler vendor.  "
-     "Possible values include:\n"
-     "  Absoft = Absoft Fortran (absoft.com)\n"
-     "  ADSP = Analog VisualDSP++ (analog.com)\n"
-     "  AppleClang = Apple Clang (apple.com)\n"
-     "  Clang = LLVM Clang (clang.llvm.org)\n"
-     "  Cray = Cray Compiler (cray.com)\n"
-     "  Embarcadero, Borland = Embarcadero (embarcadero.com)\n"
-     "  G95 = G95 Fortran (g95.org)\n"
-     "  GNU = GNU Compiler Collection (gcc.gnu.org)\n"
-     "  HP = Hewlett-Packard Compiler (hp.com)\n"
-     "  Intel = Intel Compiler (intel.com)\n"
-     "  MIPSpro = SGI MIPSpro (sgi.com)\n"
-     "  MSVC = Microsoft Visual Studio (microsoft.com)\n"
-     "  PGI = The Portland Group (pgroup.com)\n"
-     "  PathScale = PathScale (pathscale.com)\n"
-     "  SDCC = Small Device C Compiler (sdcc.sourceforge.net)\n"
-     "  SunPro = Oracle Solaris Studio (oracle.com)\n"
-     "  TI = Texas Instruments (ti.com)\n"
-     "  TinyCC = Tiny C Compiler (tinycc.org)\n"
-     "  Watcom = Open Watcom (openwatcom.org)\n"
-     "  XL, VisualAge, zOS = IBM XL (ibm.com)\n"
-     "This variable is not guaranteed to be defined for all "
-     "compilers or languages.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_PLATFORM_ID", cmProperty::VARIABLE,
-     "An internal variable subject to change.",
-     "This is used in determining the platform and is subject to change.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_COMPILER_ABI", cmProperty::VARIABLE,
-     "An internal variable subject to change.",
-     "This is used in determining the compiler ABI and is subject to change.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_COMPILER_VERSION", cmProperty::VARIABLE,
-     "Compiler version string.",
-     "Compiler version in major[.minor[.patch[.tweak]]] format.  "
-     "This variable is not guaranteed to be defined for all "
-     "compilers or languages.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_INTERNAL_PLATFORM_ABI", cmProperty::VARIABLE,
-     "An internal variable subject to change.",
-     "This is used in determining the compiler ABI and is subject to change.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_SIMULATE_ID", cmProperty::VARIABLE,
-     "Identification string of \"simulated\" compiler.",
-     "Some compilers simulate other compilers to serve as drop-in "
-     "replacements.  "
-     "When CMake detects such a compiler it sets this variable to what "
-     "would have been the CMAKE_<LANG>_COMPILER_ID for the simulated "
-     "compiler.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_SIMULATE_VERSION", cmProperty::VARIABLE,
-     "Version string of \"simulated\" compiler.",
-     "Some compilers simulate other compilers to serve as drop-in "
-     "replacements.  "
-     "When CMake detects such a compiler it sets this variable to what "
-     "would have been the CMAKE_<LANG>_COMPILER_VERSION for the simulated "
-     "compiler.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_SIZEOF_DATA_PTR", cmProperty::VARIABLE,
-     "Size of pointer-to-data types for language <LANG>.",
-     "This holds the size (in bytes) of pointer-to-data types in the target "
-     "platform ABI.  "
-     "It is defined for languages C and CXX (C++).",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_COMPILER_IS_GNU<LANG>", cmProperty::VARIABLE,
-     "True if the compiler is GNU.",
-     "If the selected <LANG> compiler is the GNU "
-     "compiler then this is TRUE, if not it is FALSE.  "
-     "Unlike the other per-language variables, this uses the GNU syntax for "
-     "identifying languages instead of the CMake syntax. Recognized values of "
-     "the <LANG> suffix are:\n"
-     "  CC = C compiler\n"
-     "  CXX = C++ compiler\n"
-     "  G77 = Fortran compiler",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-     ("CMAKE_<LANG>_FLAGS", cmProperty::VARIABLE,
-      "Flags for all build types.",
-      "<LANG> flags used regardless of the value of CMAKE_BUILD_TYPE.",false,
-      "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_FLAGS_DEBUG", cmProperty::VARIABLE,
-     "Flags for Debug build type or configuration.",
-     "<LANG> flags used when CMAKE_BUILD_TYPE is Debug.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_FLAGS_MINSIZEREL", cmProperty::VARIABLE,
-     "Flags for MinSizeRel build type or configuration.",
-     "<LANG> flags used when CMAKE_BUILD_TYPE is MinSizeRel."
-     "Short for minimum size release.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_FLAGS_RELEASE", cmProperty::VARIABLE,
-     "Flags for Release build type or configuration.",
-     "<LANG> flags used when CMAKE_BUILD_TYPE is Release",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_FLAGS_RELWITHDEBINFO", cmProperty::VARIABLE,
-     "Flags for RelWithDebInfo type or configuration.",
-     "<LANG> flags used when CMAKE_BUILD_TYPE is RelWithDebInfo.  "
-     "Short for Release With Debug Information.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_COMPILE_OBJECT", cmProperty::VARIABLE,
-     "Rule variable to compile a single object file.",
-     "This is a rule variable that tells CMake how to "
-     "compile a single object file for the language <LANG>."
-     ,false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_CREATE_SHARED_LIBRARY", cmProperty::VARIABLE,
-     "Rule variable to create a shared library.",
-     "This is a rule variable that tells CMake how to "
-     "create a shared library for the language <LANG>.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_CREATE_SHARED_MODULE", cmProperty::VARIABLE,
-     "Rule variable to create a shared module.",
-     "This is a rule variable that tells CMake how to "
-     "create a shared library for the language <LANG>.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_CREATE_STATIC_LIBRARY", cmProperty::VARIABLE,
-     "Rule variable to create a static library.",
-     "This is a rule variable that tells CMake how "
-     "to create a static library for the language <LANG>.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_ARCHIVE_CREATE", cmProperty::VARIABLE,
-     "Rule variable to create a new static archive.",
-     "This is a rule variable that tells CMake how to create a static "
-     "archive.  It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY "
-     "on some platforms in order to support large object counts.  "
-     "See also CMAKE_<LANG>_ARCHIVE_APPEND and CMAKE_<LANG>_ARCHIVE_FINISH.",
-     false, "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_ARCHIVE_APPEND", cmProperty::VARIABLE,
-     "Rule variable to append to a static archive.",
-     "This is a rule variable that tells CMake how to append to a static "
-     "archive.  It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY "
-     "on some platforms in order to support large object counts.  "
-     "See also CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_FINISH.",
-     false, "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_ARCHIVE_FINISH", cmProperty::VARIABLE,
-     "Rule variable to finish an existing static archive.",
-     "This is a rule variable that tells CMake how to finish a static "
-     "archive.  It is used in place of CMAKE_<LANG>_CREATE_STATIC_LIBRARY "
-     "on some platforms in order to support large object counts.  "
-     "See also CMAKE_<LANG>_ARCHIVE_CREATE and CMAKE_<LANG>_ARCHIVE_APPEND.",
-     false, "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_IGNORE_EXTENSIONS", cmProperty::VARIABLE,
-     "File extensions that should be ignored by the build.",
-     "This is a list of file extensions that may be "
-     "part of a project for a given language but are not compiled.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_IMPLICIT_INCLUDE_DIRECTORIES", cmProperty::VARIABLE,
-     "Directories implicitly searched by the compiler for header files.",
-     "CMake does not explicitly specify these directories on compiler "
-     "command lines for language <LANG>.  "
-     "This prevents system include directories from being treated as user "
-     "include directories on some compilers.", false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES", cmProperty::VARIABLE,
-     "Implicit linker search path detected for language <LANG>.",
-     "Compilers typically pass directories containing language runtime "
-     "libraries and default library search paths when they invoke a linker.  "
-     "These paths are implicit linker search directories for the compiler's "
-     "language.  "
-     "CMake automatically detects these directories for each language and "
-     "reports the results in this variable."
-     "\n"
-     "When a library in one of these directories is given by full path to "
-     "target_link_libraries() CMake will generate the -l<name> form on "
-     "link lines to ensure the linker searches its implicit directories "
-     "for the library.  "
-     "Note that some toolchains read implicit directories from an "
-     "environment variable such as LIBRARY_PATH so keep its value "
-     "consistent when operating in a given build tree.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES", cmProperty::VARIABLE,
-     "Implicit linker framework search path detected for language <LANG>.",
-     "These paths are implicit linker framework search directories for "
-     "the compiler's language.  "
-     "CMake automatically detects these directories for each language and "
-     "reports the results in this variable.", false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_IMPLICIT_LINK_LIBRARIES", cmProperty::VARIABLE,
-     "Implicit link libraries and flags detected for language <LANG>.",
-     "Compilers typically pass language runtime library names and "
-     "other flags when they invoke a linker.  "
-     "These flags are implicit link options for the compiler's language.  "
-     "CMake automatically detects these libraries and flags for each "
-     "language and reports the results in this variable.", false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_LIBRARY_ARCHITECTURE", cmProperty::VARIABLE,
-     "Target architecture library directory name detected for <lang>.",
-     "If the <lang> compiler passes to the linker an architecture-specific "
-     "system library search directory such as <prefix>/lib/<arch> this "
-     "variable contains the <arch> name if/as detected by CMake.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES", cmProperty::VARIABLE,
-     "True if CMAKE_<LANG>_LINKER_PREFERENCE propagates across targets.",
-     "This is used when CMake selects a linker language for a target.  "
-     "Languages compiled directly into the target are always considered.  "
-     "A language compiled into static libraries linked by the target is "
-     "considered if this variable is true.", false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_LINKER_PREFERENCE", cmProperty::VARIABLE,
-     "Preference value for linker language selection.",
-     "The \"linker language\" for executable, shared library, and module "
-     "targets is the language whose compiler will invoke the linker.  "
-     "The LINKER_LANGUAGE target property sets the language explicitly.  "
-     "Otherwise, the linker language is that whose linker preference value "
-     "is highest among languages compiled and linked into the target.  "
-     "See also the CMAKE_<LANG>_LINKER_PREFERENCE_PROPAGATES variable.",
-     false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_LINK_EXECUTABLE", cmProperty::VARIABLE,
-     "Rule variable to link an executable.",
-     "Rule variable to link an executable for the given language."
-     ,false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_OUTPUT_EXTENSION", cmProperty::VARIABLE,
-     "Extension for the output of a compile for a single file.",
-     "This is the extension for an object file for "
-     "the given <LANG>. For example .obj for C on Windows.",false,
-     "Variables for Languages");
-
-  cm->DefineProperty
-    ("CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS", cmProperty::VARIABLE,
-     "Extensions of source files for the given language.",
-     "This is the list of extensions for a "
-     "given language's source files."
-     ,false,
-     "Variables for Languages");
-
-  cm->DefineProperty(
-    "CMAKE_<LANG>_COMPILER_LOADED", cmProperty::VARIABLE,
-    "Defined to true if the language is enabled.",
-    "When language <LANG> is enabled by project() or enable_language() "
-    "this variable is defined to 1.",
-    false,"Variables for Languages");
-
-  cm->DefineProperty(
-    "CMAKE_Fortran_MODDIR_FLAG", cmProperty::VARIABLE,
-    "Fortran flag for module output directory.",
-    "This stores the flag needed to pass the value of the "
-    "Fortran_MODULE_DIRECTORY target property to the compiler.",
-    false,"Variables for Languages");
-
-  cm->DefineProperty(
-    "CMAKE_Fortran_MODDIR_DEFAULT", cmProperty::VARIABLE,
-    "Fortran default module output directory.",
-    "Most Fortran compilers write .mod files to the current working "
-    "directory.  "
-    "For those that do not, this is set to \".\" and used when the "
-    "Fortran_MODULE_DIRECTORY target property is not set.",
-    false,"Variables for Languages");
-
-  cm->DefineProperty(
-    "CMAKE_Fortran_MODOUT_FLAG", cmProperty::VARIABLE,
-    "Fortran flag to enable module output.",
-    "Most Fortran compilers write .mod files out by default.  "
-    "For others, this stores the flag needed to enable module output.",
-    false,"Variables for Languages");
-
-  // variables that are used by cmake but not to be documented
-  cm->DefineProperty("CMAKE_MATCH_0", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_1", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_2", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_3", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_4", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_5", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_6", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_7", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_8", cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MATCH_9", cmProperty::VARIABLE,0,0);
-
-  cm->DefineProperty("CMAKE_<LANG>_COMPILER_ARG1",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_COMPILER_ENV_VAR",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_COMPILER_ID_RUN",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_ABI_FILES",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_CREATE_ASSEMBLY_SOURCE",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_CREATE_PREPROCESSED_SOURCE",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_FLAGS_DEBUG_INIT",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_FLAGS_INIT",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_FLAGS_MINSIZEREL_INIT",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_FLAGS_RELEASE_INIT",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_FLAGS_RELWITHDEBINFO_INIT",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_FRAMEWORK_SEARCH_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_INFORMATION_LOADED",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_LINK_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_RESPONSE_FILE_LINK_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_STANDARD_LIBRARIES",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_STANDARD_LIBRARIES_INIT",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_USE_RESPONSE_FILE_FOR_INCLUDES",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_<LANG>_USE_RESPONSE_FILE_FOR_OBJECTS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_EXECUTABLE_SUFFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_EXE_LINK_DYNAMIC_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_EXE_LINK_STATIC_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_GENERATOR_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_IMPORT_LIBRARY_PREFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_IMPORT_LIBRARY_SUFFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_INCLUDE_FLAG_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_INCLUDE_FLAG_SEP_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_INCLUDE_SYSTEM_FLAG_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_NEEDS_REQUIRES_STEP_<LANG>_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_CREATE_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_DYNAMIC_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_LINK_STATIC_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_PREFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_SUFFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_RUNTIME_<LANG>_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_RUNTIME_<LANG>_FLAG_SEP",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_LIBRARY_RPATH_LINK_<LANG>_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_EXECUTABLE_RUNTIME_<LANG>_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_EXECUTABLE_RUNTIME_<LANG>_FLAG_SEP",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_EXECUTABLE_RPATH_LINK_<LANG>_FLAG",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty(
-    "CMAKE_<LANG>_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH",
-    cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_MODULE_CREATE_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_MODULE_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_MODULE_LINK_DYNAMIC_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_MODULE_LINK_STATIC_<LANG>_FLAGS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_MODULE_PREFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_SHARED_MODULE_SUFFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_STATIC_LIBRARY_PREFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_STATIC_LIBRARY_SUFFIX_<LANG>",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_LINK_DEPENDENT_LIBRARY_FILES",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS",
-                     cmProperty::VARIABLE,0,0);
-  cm->DefineProperty("CMAKE_MAKE_INCLUDE_FROM_ROOT",
-                     cmProperty::VARIABLE,0,0);
-}
diff --git a/Source/cmDocumentVariables.h b/Source/cmDocumentVariables.h
deleted file mode 100644
index 1d59b24..0000000
--- a/Source/cmDocumentVariables.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef cmDocumentVariables_h
-#define cmDocumentVariables_h
-class cmake;
-class cmDocumentVariables
-{
-public:
-  static void DefineVariables(cmake* cm);
-};
-
-#endif
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 063d560..a390e06 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -21,9 +21,7 @@
 #include "cmCacheManager.h"
 #include "cmFunctionBlocker.h"
 #include "cmListFileCache.h"
-#include "cmDocumentGeneratorExpressions.h"
 #include "cmCommandArgumentParserHelper.h"
-#include "cmDocumentCompileDefinitions.h"
 #include "cmGeneratorExpression.h"
 #include "cmTest.h"
 #ifdef CMAKE_BUILD_WITH_CMAKE
@@ -4024,243 +4022,14 @@ void cmMakefile::RaiseScope(const char *var, const char *varDef)
 void cmMakefile::DefineProperties(cmake *cm)
 {
   cm->DefineProperty
-    ("ADDITIONAL_MAKE_CLEAN_FILES", cmProperty::DIRECTORY,
-     "Additional files to clean during the make clean stage.",
-     "A list of files that will be cleaned as a part of the "
-     "\"make clean\" stage. ");
-
-  cm->DefineProperty
-    ("CLEAN_NO_CUSTOM", cmProperty::DIRECTORY,
-     "Should the output of custom commands be left.",
-     "If this is true then the outputs of custom commands for this "
-     "directory will not be removed during the \"make clean\" stage. ");
-
-  cm->DefineProperty
-    ("LISTFILE_STACK", cmProperty::DIRECTORY,
-     "The current stack of listfiles being processed.",
-     "This property is mainly useful when trying to debug errors "
-     "in your CMake scripts. It returns a list of what list files "
-     "are currently being processed, in order. So if one listfile "
-     "does an INCLUDE command then that is effectively pushing "
-     "the included listfile onto the stack.", false);
-
-  cm->DefineProperty
-    ("TEST_INCLUDE_FILE", cmProperty::DIRECTORY,
-     "A cmake file that will be included when ctest is run.",
-     "If you specify TEST_INCLUDE_FILE, that file will be "
-     "included and processed when ctest is run on the directory.");
-
-  cm->DefineProperty
-    ("COMPILE_DEFINITIONS", cmProperty::DIRECTORY,
-     "Preprocessor definitions for compiling a directory's sources.",
-     "The COMPILE_DEFINITIONS property may be set to a "
-     "semicolon-separated list of preprocessor "
-     "definitions using the syntax VAR or VAR=value.  Function-style "
-     "definitions are not supported.  CMake will automatically escape "
-     "the value correctly for the native build system (note that CMake "
-     "language syntax may require escapes to specify some values).  "
-     "This property may be set on a per-configuration basis using the name "
-     "COMPILE_DEFINITIONS_<CONFIG> where <CONFIG> is an upper-case name "
-     "(ex. \"COMPILE_DEFINITIONS_DEBUG\").  "
-     "This property will be initialized in each directory by its value "
-     "in the directory's parent.\n"
-     "CMake will automatically drop some definitions that "
-     "are not supported by the native build tool.  "
-     "The VS6 IDE does not support definition values with spaces "
-     "(but NMake does).\n"
-     CM_DOCUMENT_COMPILE_DEFINITIONS_DISCLAIMER);
-
-  cm->DefineProperty
-    ("COMPILE_DEFINITIONS_<CONFIG>", cmProperty::DIRECTORY,
-     "Per-configuration preprocessor definitions in a directory.",
-     "This is the configuration-specific version of COMPILE_DEFINITIONS.  "
-     "This property will be initialized in each directory by its value "
-     "in the directory's parent.\n");
-
-  cm->DefineProperty
-    ("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM", cmProperty::DIRECTORY,
-     "Specify #include line transforms for dependencies in a directory.",
-     "This property specifies rules to transform macro-like #include lines "
-     "during implicit dependency scanning of C and C++ source files.  "
-     "The list of rules must be semicolon-separated with each entry of "
-     "the form \"A_MACRO(%)=value-with-%\" (the % must be literal).  "
-     "During dependency scanning occurrences of A_MACRO(...) on #include "
-     "lines will be replaced by the value given with the macro argument "
-     "substituted for '%'.  For example, the entry\n"
-     "  MYDIR(%)=<mydir/%>\n"
-     "will convert lines of the form\n"
-     "  #include MYDIR(myheader.h)\n"
-     "to\n"
-     "  #include <mydir/myheader.h>\n"
-     "allowing the dependency to be followed.\n"
-     "This property applies to sources in all targets within a directory.  "
-     "The property value is initialized in each directory by its value "
-     "in the directory's parent.");
-
-  cm->DefineProperty
-    ("EXCLUDE_FROM_ALL", cmProperty::DIRECTORY,
-     "Exclude the directory from the all target of its parent.",
-     "A property on a directory that indicates if its targets are excluded "
-     "from the default build target. If it is not, then with a Makefile "
-     "for example typing make will cause the targets to be built. "
-     "The same concept applies to the default build of other generators.",
-     false);
-
-  cm->DefineProperty
-    ("PARENT_DIRECTORY", cmProperty::DIRECTORY,
-     "Source directory that added current subdirectory.",
-     "This read-only property specifies the source directory that "
-     "added the current source directory as a subdirectory of the build.  "
-     "In the top-level directory the value is the empty-string.", false);
-
-  cm->DefineProperty
-    ("INCLUDE_REGULAR_EXPRESSION", cmProperty::DIRECTORY,
-     "Include file scanning regular expression.",
-     "This read-only property specifies the regular expression used "
-     "during dependency scanning to match include files that should "
-     "be followed.  See the include_regular_expression command.", false);
-
-  cm->DefineProperty
-    ("INTERPROCEDURAL_OPTIMIZATION", cmProperty::DIRECTORY,
-     "Enable interprocedural optimization for targets in a directory.",
-     "If set to true, enables interprocedural optimizations "
-     "if they are known to be supported by the compiler.");
-
-  cm->DefineProperty
-    ("INTERPROCEDURAL_OPTIMIZATION_<CONFIG>", cmProperty::DIRECTORY,
-     "Per-configuration interprocedural optimization for a directory.",
-     "This is a per-configuration version of INTERPROCEDURAL_OPTIMIZATION.  "
-     "If set, this property overrides the generic property "
-     "for the named configuration.");
-
-  cm->DefineProperty
-    ("VARIABLES", cmProperty::DIRECTORY,
-     "List of variables defined in the current directory.",
-     "This read-only property specifies the list of CMake variables "
-     "currently defined.  "
-     "It is intended for debugging purposes.", false);
-
-  cm->DefineProperty
-    ("CACHE_VARIABLES", cmProperty::DIRECTORY,
-     "List of cache variables available in the current directory.",
-     "This read-only property specifies the list of CMake cache "
-     "variables currently defined.  "
-     "It is intended for debugging purposes.", false);
-
-  cm->DefineProperty
-    ("MACROS", cmProperty::DIRECTORY,
-     "List of macro commands available in the current directory.",
-     "This read-only property specifies the list of CMake macros "
-     "currently defined.  "
-     "It is intended for debugging purposes.  "
-     "See the macro command.", false);
-
-  cm->DefineProperty
-    ("DEFINITIONS", cmProperty::DIRECTORY,
-     "For CMake 2.4 compatibility only.  Use COMPILE_DEFINITIONS instead.",
-     "This read-only property specifies the list of flags given so far "
-     "to the add_definitions command.  "
-     "It is intended for debugging purposes.  "
-     "Use the COMPILE_DEFINITIONS instead.", false);
-
-  cm->DefineProperty
-    ("INCLUDE_DIRECTORIES", cmProperty::DIRECTORY,
-     "List of preprocessor include file search directories.",
-     "This property specifies the list of directories given "
-     "so far to the include_directories command.  "
-     "This property exists on directories and targets.  "
-     "In addition to accepting values from the include_directories "
-     "command, values may be set directly on any directory or any "
-     "target using the set_property command.  "
-     "A target gets its initial value for this property from the value "
-     "of the directory property.  "
-     "A directory gets its initial value from its parent directory if "
-     "it has one.  "
-     "Both directory and target property values are adjusted by calls "
-     "to the include_directories command."
-     "\n"
-     "The target property values are used by the generators to set "
-     "the include paths for the compiler.  "
-     "See also the include_directories command.");
-
-  cm->DefineProperty
-    ("COMPILE_OPTIONS", cmProperty::DIRECTORY,
-     "List of options to pass to the compiler.",
-     "This property specifies the list of directories given "
-     "so far for this property.  "
-     "This property exists on directories and targets."
-     "\n"
-     "The target property values are used by the generators to set "
-     "the options for the compiler.\n"
-     "Contents of COMPILE_OPTIONS may use \"generator expressions\" with "
-     "the syntax \"$<...>\".  "
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("LINK_DIRECTORIES", cmProperty::DIRECTORY,
-     "List of linker search directories.",
-     "This read-only property specifies the list of directories given "
-     "so far to the link_directories command.  "
-     "It is intended for debugging purposes.", false);
-
-  cm->DefineProperty
     ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY,
-     "Specify a launcher for compile rules.",
-     "See the global property of the same name for details.  "
-     "This overrides the global property for a directory.",
-     true);
+     "", "", true);
   cm->DefineProperty
     ("RULE_LAUNCH_LINK", cmProperty::DIRECTORY,
-     "Specify a launcher for link rules.",
-     "See the global property of the same name for details.  "
-     "This overrides the global property for a directory.",
-     true);
+     "", "", true);
   cm->DefineProperty
     ("RULE_LAUNCH_CUSTOM", cmProperty::DIRECTORY,
-     "Specify a launcher for custom rules.",
-     "See the global property of the same name for details.  "
-     "This overrides the global property for a directory.",
-     true);
-
-  cm->DefineProperty
-    ("VS_GLOBAL_SECTION_PRE_<section>", cmProperty::DIRECTORY,
-     "Specify a preSolution global section in Visual Studio.",
-     "Setting a property like this generates an entry of the following form "
-     "in the solution file:\n"
-     "  GlobalSection(<section>) = preSolution\n"
-     "    <contents based on property value>\n"
-     "  EndGlobalSection\n"
-     "The property must be set to a semicolon-separated list of key=value "
-     "pairs. Each such pair will be transformed into an entry in the solution "
-     "global section. Whitespace around key and value is ignored. List "
-     "elements which do not contain an equal sign are skipped."
-     "\n"
-     "This property only works for Visual Studio 7 and above; it is ignored "
-     "on other generators. The property only applies when set on a directory "
-     "whose CMakeLists.txt contains a project() command.");
-  cm->DefineProperty
-    ("VS_GLOBAL_SECTION_POST_<section>", cmProperty::DIRECTORY,
-     "Specify a postSolution global section in Visual Studio.",
-     "Setting a property like this generates an entry of the following form "
-     "in the solution file:\n"
-     "  GlobalSection(<section>) = postSolution\n"
-     "    <contents based on property value>\n"
-     "  EndGlobalSection\n"
-     "The property must be set to a semicolon-separated list of key=value "
-     "pairs. Each such pair will be transformed into an entry in the solution "
-     "global section. Whitespace around key and value is ignored. List "
-     "elements which do not contain an equal sign are skipped."
-     "\n"
-     "This property only works for Visual Studio 7 and above; it is ignored "
-     "on other generators. The property only applies when set on a directory "
-     "whose CMakeLists.txt contains a project() command."
-     "\n"
-     "Note that CMake generates postSolution sections ExtensibilityGlobals "
-     "and ExtensibilityAddIns by default. If you set the corresponding "
-     "property, it will override the default section. For example, setting "
-     "VS_GLOBAL_SECTION_POST_ExtensibilityGlobals will override the default "
-     "contents of the ExtensibilityGlobals section, while keeping "
-     "ExtensibilityAddIns on its default.");
+     "", "", true);
 }
 
 //----------------------------------------------------------------------------
diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx
index 8bb7d96..d747309 100644
--- a/Source/cmSourceFile.cxx
+++ b/Source/cmSourceFile.cxx
@@ -16,7 +16,6 @@
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 #include "cmake.h"
-#include "cmDocumentCompileDefinitions.h"
 
 //----------------------------------------------------------------------------
 cmSourceFile::cmSourceFile(cmMakefile* mf, const char* name):
@@ -382,176 +381,3 @@ void cmSourceFile::SetCustomCommand(cmCustomCommand* cc)
   this->CustomCommand = cc;
   delete old;
 }
-
-//----------------------------------------------------------------------------
-void cmSourceFile::DefineProperties(cmake *cm)
-{
-  // define properties
-  cm->DefineProperty
-    ("ABSTRACT", cmProperty::SOURCE_FILE,
-     "Is this source file an abstract class.",
-     "A property on a source file that indicates if the source file "
-     "represents a class that is abstract. This only makes sense for "
-     "languages that have a notion of an abstract class and it is "
-     "only used by some tools that wrap classes into other languages.");
-
-  cm->DefineProperty
-    ("COMPILE_FLAGS", cmProperty::SOURCE_FILE,
-     "Additional flags to be added when compiling this source file.",
-     "These flags will be added to the list of compile flags when "
-     "this source file builds.  Use COMPILE_DEFINITIONS to pass additional "
-     "preprocessor definitions.");
-
-  cm->DefineProperty
-    ("COMPILE_DEFINITIONS", cmProperty::SOURCE_FILE,
-     "Preprocessor definitions for compiling a source file.",
-     "The COMPILE_DEFINITIONS property may be set to a "
-     "semicolon-separated list of preprocessor "
-     "definitions using the syntax VAR or VAR=value.  Function-style "
-     "definitions are not supported.  CMake will automatically escape "
-     "the value correctly for the native build system (note that CMake "
-     "language syntax may require escapes to specify some values).  "
-     "This property may be set on a per-configuration basis using the name "
-     "COMPILE_DEFINITIONS_<CONFIG> where <CONFIG> is an upper-case name "
-     "(ex. \"COMPILE_DEFINITIONS_DEBUG\").\n"
-     "CMake will automatically drop some definitions that "
-     "are not supported by the native build tool.  "
-     "The VS6 IDE does not support definition values with spaces "
-     "(but NMake does).  Xcode does not support per-configuration "
-     "definitions on source files.\n"
-     CM_DOCUMENT_COMPILE_DEFINITIONS_DISCLAIMER);
-
-  cm->DefineProperty
-    ("COMPILE_DEFINITIONS_<CONFIG>", cmProperty::SOURCE_FILE,
-     "Per-configuration preprocessor definitions on a source file.",
-     "This is the configuration-specific version of "
-     "COMPILE_DEFINITIONS.  Note that Xcode does not support "
-     "per-configuration source file flags so this property will "
-     "be ignored by the Xcode generator.");
-
-  cm->DefineProperty
-    ("EXTERNAL_OBJECT", cmProperty::SOURCE_FILE,
-     "If set to true then this is an object file.",
-     "If this property is set to true then the source file "
-     "is really an object file and should not be compiled.  "
-     "It will still be linked into the target though.");
-
-  cm->DefineProperty
-    ("Fortran_FORMAT", cmProperty::SOURCE_FILE,
-     "Set to FIXED or FREE to indicate the Fortran source layout.",
-     "This property tells CMake whether a given Fortran source file "
-     "uses fixed-format or free-format.  "
-     "CMake will pass the corresponding format flag to the compiler.  "
-     "Consider using the target-wide Fortran_FORMAT property if all "
-     "source files in a target share the same format.");
-
-  cm->DefineProperty
-    ("GENERATED", cmProperty::SOURCE_FILE,
-     "Is this source file generated as part of the build process.",
-     "If a source file is generated by the build process CMake will "
-     "handle it differently in terms of dependency checking etc. "
-     "Otherwise having a non-existent source file could create problems.");
-
-  cm->DefineProperty
-    ("HEADER_FILE_ONLY", cmProperty::SOURCE_FILE,
-     "Is this source file only a header file.",
-     "A property on a source file that indicates if the source file "
-     "is a header file with no associated implementation. This is "
-     "set automatically based on the file extension and is used by "
-     "CMake to determine if certain dependency information should be "
-     "computed.");
-
-  cm->DefineProperty
-    ("KEEP_EXTENSION", cmProperty::SOURCE_FILE,
-     "Make the output file have the same extension as the source file.",
-     "If this property is set then the file extension of the output "
-     "file will be the same as that of the source file. Normally "
-     "the output file extension is computed based on the language "
-     "of the source file, for example .cxx will go to a .o extension.");
-
-  cm->DefineProperty
-    ("LABELS", cmProperty::SOURCE_FILE,
-     "Specify a list of text labels associated with a source file.",
-     "This property has meaning only when the source file is listed in "
-     "a target whose LABELS property is also set.  "
-     "No other semantics are currently specified.");
-
-  cm->DefineProperty
-    ("LANGUAGE", cmProperty::SOURCE_FILE,
-     "What programming language is the file.",
-     "A property that can be set to indicate what programming language "
-     "the source file is. If it is not set the language is determined "
-     "based on the file extension. Typical values are CXX C etc. Setting "
-     "this property for a file means this file will be compiled. "
-     "Do not set this for headers or files that should not be compiled.");
-
-  cm->DefineProperty
-    ("LOCATION", cmProperty::SOURCE_FILE,
-     "The full path to a source file.",
-     "A read only property on a SOURCE FILE that contains the full path "
-     "to the source file.");
-
-  cm->DefineProperty
-    ("MACOSX_PACKAGE_LOCATION", cmProperty::SOURCE_FILE,
-     "Place a source file inside a Mac OS X bundle, CFBundle, or framework.",
-     "Executable targets with the MACOSX_BUNDLE property set are built "
-     "as Mac OS X application bundles on Apple platforms.  "
-     "Shared library targets with the FRAMEWORK property set are built "
-     "as Mac OS X frameworks on Apple platforms.  "
-     "Module library targets with the BUNDLE property set are built "
-     "as Mac OS X CFBundle bundles on Apple platforms.  "
-     "Source files listed in the target with this property set will "
-     "be copied to a directory inside the bundle or framework content "
-     "folder specified by the property value.  "
-     "For bundles the content folder is \"<name>.app/Contents\".  "
-     "For frameworks the content folder is "
-     "\"<name>.framework/Versions/<version>\".  "
-     "For cfbundles the content folder is "
-     "\"<name>.bundle/Contents\" (unless the extension is changed).  "
-     "See the PUBLIC_HEADER, PRIVATE_HEADER, and RESOURCE target "
-     "properties for specifying files meant for Headers, PrivateHeaders, "
-     "or Resources directories.");
-
-  cm->DefineProperty
-    ("OBJECT_DEPENDS", cmProperty::SOURCE_FILE,
-     "Additional files on which a compiled object file depends.",
-     "Specifies a semicolon-separated list of full-paths to files on which "
-     "any object files compiled from this source file depend.  "
-     "An object file will be recompiled if any of the named files is newer "
-     "than it.\n"
-     "This property need not be used to specify the dependency of a "
-     "source file on a generated header file that it includes.  "
-     "Although the property was originally introduced for this purpose, it "
-     "is no longer necessary.  "
-     "If the generated header file is created by a custom command in the "
-     "same target as the source file, the automatic dependency scanning "
-     "process will recognize the dependency.  "
-     "If the generated header file is created by another target, an "
-     "inter-target dependency should be created with the add_dependencies "
-     "command (if one does not already exist due to linking relationships).");
-
-  cm->DefineProperty
-    ("OBJECT_OUTPUTS", cmProperty::SOURCE_FILE,
-     "Additional outputs for a Makefile rule.",
-     "Additional outputs created by compilation of this source file. "
-     "If any of these outputs is missing the object will be recompiled. "
-     "This is supported only on Makefile generators and will be ignored "
-     "on other generators.");
-
-  cm->DefineProperty
-    ("SYMBOLIC", cmProperty::SOURCE_FILE,
-     "Is this just a name for a rule.",
-     "If SYMBOLIC (boolean) is set to true the build system will be "
-     "informed that the source file is not actually created on disk but "
-     "instead used as a symbolic name for a build rule.");
-
-  cm->DefineProperty
-    ("WRAP_EXCLUDE", cmProperty::SOURCE_FILE,
-     "Exclude this source file from any code wrapping techniques.",
-     "Some packages can wrap source files into alternate languages "
-     "to provide additional functionality. For example, C++ code "
-     "can be wrapped into Java or Python etc using SWIG etc. "
-     "If WRAP_EXCLUDE is set to true (1 etc) that indicates that "
-     "this source file should not be wrapped.");
-}
-
diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h
index 6c68b87..4440b05 100644
--- a/Source/cmSourceFile.h
+++ b/Source/cmSourceFile.h
@@ -90,9 +90,6 @@ public:
   // Get the properties
   cmPropertyMap &GetProperties() { return this->Properties; };
 
-  // Define the properties
-  static void DefineProperties(cmake *cm);
-
   /**
    * Check whether the given source file location could refer to this
    * source.
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index cf0cad5..5e10e25 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -16,9 +16,6 @@
 #include "cmLocalGenerator.h"
 #include "cmGlobalGenerator.h"
 #include "cmComputeLinkInformation.h"
-#include "cmDocumentCompileDefinitions.h"
-#include "cmDocumentGeneratorExpressions.h"
-#include "cmDocumentLocationUndefined.h"
 #include "cmListFileCache.h"
 #include "cmGeneratorExpression.h"
 #include "cmGeneratorExpressionDAGChecker.h"
@@ -219,1387 +216,14 @@ cmTarget::cmTarget()
 void cmTarget::DefineProperties(cmake *cm)
 {
   cm->DefineProperty
-    ("AUTOMOC", cmProperty::TARGET,
-     "Should the target be processed with automoc (for Qt projects).",
-     "AUTOMOC is a boolean specifying whether CMake will handle "
-     "the Qt moc preprocessor automatically, i.e. without having to use "
-     "the QT4_WRAP_CPP() or QT5_WRAP_CPP() macro. Currently Qt4 and Qt5 are "
-     "supported.  "
-     "When this property is set to TRUE, CMake will scan the source files "
-     "at build time and invoke moc accordingly. "
-     "If an #include statement like #include \"moc_foo.cpp\" is found, "
-     "the Q_OBJECT class declaration is expected in the header, and moc is "
-     "run on the header file. "
-     "If an #include statement like #include \"foo.moc\" is found, "
-     "then a Q_OBJECT is expected in the current source file and moc "
-     "is run on the file itself. "
-     "Additionally, all header files are parsed for Q_OBJECT macros, "
-     "and if found, moc is also executed on those files. The resulting "
-     "moc files, which are not included as shown above in any of the source "
-     "files are included in a generated <targetname>_automoc.cpp file, "
-     "which is compiled as part of the target."
-     "This property is initialized by the value of the variable "
-     "CMAKE_AUTOMOC if it is set when a target is created.\n"
-     "Additional command line options for moc can be set via the "
-     "AUTOMOC_MOC_OPTIONS property.\n"
-     "By setting the CMAKE_AUTOMOC_RELAXED_MODE variable to TRUE the rules "
-     "for searching the files which will be processed by moc can be relaxed. "
-     "See the documentation for this variable for more details.\n"
-     "The global property AUTOMOC_TARGETS_FOLDER can be used to group the "
-     "automoc targets together in an IDE, e.g. in MSVS.");
-
-  cm->DefineProperty
-    ("AUTOMOC_MOC_OPTIONS", cmProperty::TARGET,
-    "Additional options for moc when using automoc (see the AUTOMOC property)",
-     "This property is only used if the AUTOMOC property is set to TRUE for "
-     "this target. In this case, it holds additional command line options "
-     "which will be used when moc is executed during the build, i.e. it is "
-     "equivalent to the optional OPTIONS argument of the qt4_wrap_cpp() "
-     "macro.\n"
-     "By default it is empty.");
-
-  cm->DefineProperty
-    ("BUILD_WITH_INSTALL_RPATH", cmProperty::TARGET,
-     "Should build tree targets have install tree rpaths.",
-     "BUILD_WITH_INSTALL_RPATH is a boolean specifying whether to link "
-     "the target in the build tree with the INSTALL_RPATH.  This takes "
-     "precedence over SKIP_BUILD_RPATH and avoids the need for relinking "
-     "before installation.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_BUILD_WITH_INSTALL_RPATH if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("COMPILE_FLAGS", cmProperty::TARGET,
-     "Additional flags to use when compiling this target's sources.",
-     "The COMPILE_FLAGS property sets additional compiler flags used "
-     "to build sources within the target.  Use COMPILE_DEFINITIONS "
-     "to pass additional preprocessor definitions."
-     "\n"
-     "This property is deprecated. Use the COMPILE_OPTIONS property or the "
-     "target_compile_options command instead.");
-
-  cm->DefineProperty
-    ("COMPILE_DEFINITIONS", cmProperty::TARGET,
-     "Preprocessor definitions for compiling a target's sources.",
-     "The COMPILE_DEFINITIONS property may be set to a "
-     "semicolon-separated list of preprocessor "
-     "definitions using the syntax VAR or VAR=value.  Function-style "
-     "definitions are not supported.  CMake will automatically escape "
-     "the value correctly for the native build system (note that CMake "
-     "language syntax may require escapes to specify some values).  "
-     "This property may be set on a per-configuration basis using the name "
-     "COMPILE_DEFINITIONS_<CONFIG> where <CONFIG> is an upper-case name "
-     "(ex. \"COMPILE_DEFINITIONS_DEBUG\").\n"
-     "CMake will automatically drop some definitions that "
-     "are not supported by the native build tool.  "
-     "The VS6 IDE does not support definition values with spaces "
-     "(but NMake does).\n"
-     "Contents of COMPILE_DEFINITIONS may use \"generator expressions\" with "
-     "the syntax \"$<...>\".  "
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-     CM_DOCUMENT_COMPILE_DEFINITIONS_DISCLAIMER);
-
-  cm->DefineProperty
-    ("COMPILE_DEFINITIONS_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration preprocessor definitions on a target.",
-     "This is the configuration-specific version of COMPILE_DEFINITIONS.");
-
-  cm->DefineProperty
-    ("COMPILE_OPTIONS", cmProperty::TARGET,
-     "List of options to pass to the compiler.",
-     "This property specifies the list of options specified "
-     "so far for this property.  "
-     "This property exists on directories and targets."
-     "\n"
-     "The target property values are used by the generators to set "
-     "the options for the compiler.\n"
-     "Contents of COMPILE_OPTIONS may use \"generator expressions\" with "
-     "the syntax \"$<...>\".  "
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("INTERFACE_COMPILE_OPTIONS", cmProperty::TARGET,
-     "List of interface options to pass to the compiler.",
-     "Targets may populate this property to publish the compile options "
-     "required to compile against the headers for the target.  Consuming "
-     "targets can add entries to their own COMPILE_OPTIONS property such "
-     "as $<TARGET_PROPERTY:foo,INTERFACE_COMPILE_OPTIONS> to use the "
-     "compile options specified in the interface of 'foo'."
-     "\n"
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("DEFINE_SYMBOL", cmProperty::TARGET,
-     "Define a symbol when compiling this target's sources.",
-     "DEFINE_SYMBOL sets the name of the preprocessor symbol defined when "
-     "compiling sources in a shared library. "
-     "If not set here then it is set to target_EXPORTS by default "
-     "(with some substitutions if the target is not a valid C "
-     "identifier). This is useful for headers to know whether they are "
-     "being included from inside their library or outside to properly "
-     "setup dllexport/dllimport decorations. ");
-
-  cm->DefineProperty
-    ("DEBUG_POSTFIX", cmProperty::TARGET,
-     "See target property <CONFIG>_POSTFIX.",
-     "This property is a special case of the more-general <CONFIG>_POSTFIX "
-     "property for the DEBUG configuration.");
-
-  cm->DefineProperty
-    ("<CONFIG>_POSTFIX", cmProperty::TARGET,
-     "Postfix to append to the target file name for configuration <CONFIG>.",
-     "When building with configuration <CONFIG> the value of this property "
-     "is appended to the target file name built on disk.  "
-     "For non-executable targets, this property is initialized by the value "
-     "of the variable CMAKE_<CONFIG>_POSTFIX if it is set when a target is "
-     "created.  "
-     "This property is ignored on the Mac for Frameworks and App Bundles.");
-
-  cm->DefineProperty
-    ("EchoString", cmProperty::TARGET,
-     "A message to be displayed when the target is built.",
-     "A message to display on some generators (such as makefiles) when "
-     "the target is built.");
-
-  cm->DefineProperty
-    ("BUNDLE", cmProperty::TARGET,
-     "This target is a CFBundle on the Mac.",
-     "If a module library target has this property set to true it will "
-     "be built as a CFBundle when built on the mac. It will have the "
-     "directory structure required for a CFBundle and will be suitable "
-     "to be used for creating Browser Plugins or other application "
-     "resources.");
-
-  cm->DefineProperty
-    ("BUNDLE_EXTENSION", cmProperty::TARGET,
-     "The file extension used to name a BUNDLE target on the Mac.",
-     "The default value is \"bundle\" - you can also use \"plugin\" or "
-     "whatever file extension is required by the host app for your "
-     "bundle.");
-
-  cm->DefineProperty
-    ("EXCLUDE_FROM_DEFAULT_BUILD", cmProperty::TARGET,
-     "Exclude target from \"Build Solution\".",
-     "This property is only used by Visual Studio generators 7 and above. "
-     "When set to TRUE, the target will not be built when you press "
-     "\"Build Solution\".");
-
-  cm->DefineProperty
-    ("EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration version of target exclusion from \"Build Solution\". ",
-     "This is the configuration-specific version of "
-     "EXCLUDE_FROM_DEFAULT_BUILD. If the generic EXCLUDE_FROM_DEFAULT_BUILD "
-     "is also set on a target, EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG> takes "
-     "precedence in configurations for which it has a value.");
-
-  cm->DefineProperty
-    ("FRAMEWORK", cmProperty::TARGET,
-     "This target is a framework on the Mac.",
-     "If a shared library target has this property set to true it will "
-     "be built as a framework when built on the mac. It will have the "
-     "directory structure required for a framework and will be suitable "
-     "to be used with the -framework option");
-
-  cm->DefineProperty
-    ("HAS_CXX", cmProperty::TARGET,
-     "Link the target using the C++ linker tool (obsolete).",
-     "This is equivalent to setting the LINKER_LANGUAGE property to CXX.  "
-     "See that property's documentation for details.");
-
-  cm->DefineProperty
-    ("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM", cmProperty::TARGET,
-     "Specify #include line transforms for dependencies in a target.",
-     "This property specifies rules to transform macro-like #include lines "
-     "during implicit dependency scanning of C and C++ source files.  "
-     "The list of rules must be semicolon-separated with each entry of "
-     "the form \"A_MACRO(%)=value-with-%\" (the % must be literal).  "
-     "During dependency scanning occurrences of A_MACRO(...) on #include "
-     "lines will be replaced by the value given with the macro argument "
-     "substituted for '%'.  For example, the entry\n"
-     "  MYDIR(%)=<mydir/%>\n"
-     "will convert lines of the form\n"
-     "  #include MYDIR(myheader.h)\n"
-     "to\n"
-     "  #include <mydir/myheader.h>\n"
-     "allowing the dependency to be followed.\n"
-     "This property applies to sources in the target on which it is set.");
-
-  cm->DefineProperty
-    ("IMPORT_PREFIX", cmProperty::TARGET,
-     "What comes before the import library name.",
-     "Similar to the target property PREFIX, but used for import libraries "
-     "(typically corresponding to a DLL) instead of regular libraries. "
-     "A target property that can be set to override the prefix "
-     "(such as \"lib\") on an import library name.");
-
-  cm->DefineProperty
-    ("IMPORT_SUFFIX", cmProperty::TARGET,
-     "What comes after the import library name.",
-     "Similar to the target property SUFFIX, but used for import libraries "
-     "(typically corresponding to a DLL) instead of regular libraries. "
-     "A target property that can be set to override the suffix "
-     "(such as \".lib\") on an import library name.");
-
-  cm->DefineProperty
-    ("IMPORTED", cmProperty::TARGET,
-     "Read-only indication of whether a target is IMPORTED.",
-     "The boolean value of this property is true for targets created with "
-     "the IMPORTED option to add_executable or add_library.  "
-     "It is false for targets built within the project.");
-
-  cm->DefineProperty
-    ("IMPORTED_CONFIGURATIONS", cmProperty::TARGET,
-     "Configurations provided for an IMPORTED target.",
-     "Set this to the list of configuration names available for an "
-     "IMPORTED target.  "
-     "The names correspond to configurations defined in the project from "
-     "which the target is imported.  "
-     "If the importing project uses a different set of configurations "
-     "the names may be mapped using the MAP_IMPORTED_CONFIG_<CONFIG> "
-     "property.  "
-     "Ignored for non-imported targets.");
-
-  cm->DefineProperty
-    ("IMPORTED_IMPLIB", cmProperty::TARGET,
-     "Full path to the import library for an IMPORTED target.",
-     "Set this to the location of the \".lib\" part of a windows DLL.  "
-     "Ignored for non-imported targets.");
-
-  cm->DefineProperty
-    ("IMPORTED_IMPLIB_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_IMPLIB property.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_DEPENDENT_LIBRARIES", cmProperty::TARGET,
-     "Dependent shared libraries of an imported shared library.",
-     "Shared libraries may be linked to other shared libraries as part "
-     "of their implementation.  On some platforms the linker searches "
-     "for the dependent libraries of shared libraries they are including "
-     "in the link.  "
-     "Set this property to the list of dependent shared libraries of an "
-     "imported library.  "
-     "The list "
-     "should be disjoint from the list of interface libraries in the "
-     "INTERFACE_LINK_LIBRARIES property.  On platforms requiring "
-     "dependent shared libraries to be found at link time CMake uses this "
-     "list to add appropriate files or paths to the link command line.  "
-     "Ignored for non-imported targets.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_DEPENDENT_LIBRARIES_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_LINK_DEPENDENT_LIBRARIES.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.  "
-     "If set, this property completely overrides the generic property "
-     "for the named configuration.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_INTERFACE_LIBRARIES", cmProperty::TARGET,
-     "Transitive link interface of an IMPORTED target.",
-     "Set this to the list of libraries whose interface is included when "
-     "an IMPORTED library target is linked to another target.  "
-     "The libraries will be included on the link line for the target.  "
-     "Unlike the LINK_INTERFACE_LIBRARIES property, this property applies "
-     "to all imported target types, including STATIC libraries.  "
-     "This property is ignored for non-imported targets.\n"
-     "This property is ignored if the target also has a non-empty "
-     "INTERFACE_LINK_LIBRARIES property.\n"
-     "This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_INTERFACE_LIBRARIES_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_LINK_INTERFACE_LIBRARIES.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.  "
-     "If set, this property completely overrides the generic property "
-     "for the named configuration.\n"
-     "This property is ignored if the target also has a non-empty "
-     "INTERFACE_LINK_LIBRARIES property.\n"
-     "This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_INTERFACE_LANGUAGES", cmProperty::TARGET,
-     "Languages compiled into an IMPORTED static library.",
-     "Set this to the list of languages of source files compiled to "
-     "produce a STATIC IMPORTED library (such as \"C\" or \"CXX\").  "
-     "CMake accounts for these languages when computing how to link a "
-     "target to the imported library.  "
-     "For example, when a C executable links to an imported C++ static "
-     "library CMake chooses the C++ linker to satisfy language runtime "
-     "dependencies of the static library.  "
-     "\n"
-     "This property is ignored for targets that are not STATIC libraries.  "
-     "This property is ignored for non-imported targets.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_INTERFACE_LANGUAGES_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_LINK_INTERFACE_LANGUAGES.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.  "
-     "If set, this property completely overrides the generic property "
-     "for the named configuration.");
-
-  cm->DefineProperty
-    ("IMPORTED_LINK_INTERFACE_MULTIPLICITY", cmProperty::TARGET,
-     "Repetition count for cycles of IMPORTED static libraries.",
-     "This is LINK_INTERFACE_MULTIPLICITY for IMPORTED targets.");
-  cm->DefineProperty
-    ("IMPORTED_LINK_INTERFACE_MULTIPLICITY_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_LINK_INTERFACE_MULTIPLICITY.",
-     "If set, this property completely overrides the generic property "
-     "for the named configuration.");
-
-  cm->DefineProperty
-    ("IMPORTED_LOCATION", cmProperty::TARGET,
-     "Full path to the main file on disk for an IMPORTED target.",
-     "Set this to the location of an IMPORTED target file on disk.  "
-     "For executables this is the location of the executable file.  "
-     "For bundles on OS X this is the location of the executable file "
-     "inside Contents/MacOS under the application bundle folder.  "
-     "For static libraries and modules this is the location of the "
-     "library or module.  "
-     "For shared libraries on non-DLL platforms this is the location of "
-     "the shared library.  "
-     "For frameworks on OS X this is the location of the library file "
-     "symlink just inside the framework folder.  "
-     "For DLLs this is the location of the \".dll\" part of the library.  "
-     "For UNKNOWN libraries this is the location of the file to be linked.  "
-     "Ignored for non-imported targets."
-     "\n"
-     "Projects may skip IMPORTED_LOCATION if the configuration-specific "
-     "property IMPORTED_LOCATION_<CONFIG> is set.  "
-     "To get the location of an imported target read one of the "
-     "LOCATION or LOCATION_<CONFIG> properties.");
-
-  cm->DefineProperty
-    ("IMPORTED_LOCATION_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_LOCATION property.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.");
-
-  cm->DefineProperty
-    ("IMPORTED_SONAME", cmProperty::TARGET,
-     "The \"soname\" of an IMPORTED target of shared library type.",
-     "Set this to the \"soname\" embedded in an imported shared library.  "
-     "This is meaningful only on platforms supporting the feature.  "
-     "Ignored for non-imported targets.");
-
-  cm->DefineProperty
-    ("IMPORTED_SONAME_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_SONAME property.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.");
-
-  cm->DefineProperty
-    ("IMPORTED_NO_SONAME", cmProperty::TARGET,
-     "Specifies that an IMPORTED shared library target has no \"soname\".  ",
-     "Set this property to true for an imported shared library file that "
-     "has no \"soname\" field.  "
-     "CMake may adjust generated link commands for some platforms to prevent "
-     "the linker from using the path to the library in place of its missing "
-     "soname.  "
-     "Ignored for non-imported targets.");
-
-  cm->DefineProperty
-    ("IMPORTED_NO_SONAME_<CONFIG>", cmProperty::TARGET,
-     "<CONFIG>-specific version of IMPORTED_NO_SONAME property.",
-     "Configuration names correspond to those provided by the project "
-     "from which the target is imported.");
-
-  cm->DefineProperty
-    ("EXCLUDE_FROM_ALL", cmProperty::TARGET,
-     "Exclude the target from the all target.",
-     "A property on a target that indicates if the target is excluded "
-     "from the default build target. If it is not, then with a Makefile "
-     "for example typing make will cause this target to be built. "
-     "The same concept applies to the default build of other generators. "
-     "Installing a target with EXCLUDE_FROM_ALL set to true has "
-     "undefined behavior.");
-
-  cm->DefineProperty
-    ("LINK_LIBRARIES", cmProperty::TARGET,
-     "List of direct link dependencies.",
-     "This property specifies the list of libraries or targets which will be "
-     "used for linking. "
-     "In addition to accepting values from the target_link_libraries "
-     "command, values may be set directly on any target using the "
-     "set_property command. "
-     "\n"
-     "The target property values are used by the generators to set "
-     "the link libraries for the compiler.  "
-     "See also the target_link_libraries command.\n"
-     "Contents of LINK_LIBRARIES may use \"generator expressions\" with "
-     "the syntax \"$<...>\".  "
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("INCLUDE_DIRECTORIES", cmProperty::TARGET,
-     "List of preprocessor include file search directories.",
-     "This property specifies the list of directories given "
-     "so far to the include_directories command. "
-     "This property exists on directories and targets. "
-     "In addition to accepting values from the include_directories "
-     "command, values may be set directly on any directory or any "
-     "target using the set_property command. "
-     "A target gets its initial value for this property from the value "
-     "of the directory property. "
-     "A directory gets its initial value from its parent directory if "
-     "it has one. "
-     "Both directory and target property values are adjusted by calls "
-     "to the include_directories command."
-     "\n"
-     "The target property values are used by the generators to set "
-     "the include paths for the compiler.  "
-     "See also the include_directories command.\n"
-     "Contents of INCLUDE_DIRECTORIES may use \"generator expressions\" with "
-     "the syntax \"$<...>\".  "
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("INSTALL_NAME_DIR", cmProperty::TARGET,
-     "Mac OSX directory name for installed targets.",
-     "INSTALL_NAME_DIR is a string specifying the "
-     "directory portion of the \"install_name\" field of shared libraries "
-     "on Mac OSX to use in the installed targets. ");
-
-  cm->DefineProperty
-    ("INSTALL_RPATH", cmProperty::TARGET,
-     "The rpath to use for installed targets.",
-     "A semicolon-separated list specifying the rpath "
-     "to use in installed targets (for platforms that support it).  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_INSTALL_RPATH if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("INSTALL_RPATH_USE_LINK_PATH", cmProperty::TARGET,
-     "Add paths to linker search and installed rpath.",
-     "INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true will "
-     "append directories in the linker search path and outside the "
-     "project to the INSTALL_RPATH.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_INSTALL_RPATH_USE_LINK_PATH if it is set when a target is "
-     "created.");
-
-  cm->DefineProperty
-    ("INTERPROCEDURAL_OPTIMIZATION", cmProperty::TARGET,
-     "Enable interprocedural optimization for a target.",
-     "If set to true, enables interprocedural optimizations "
-     "if they are known to be supported by the compiler.");
-
-  cm->DefineProperty
-    ("INTERPROCEDURAL_OPTIMIZATION_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration interprocedural optimization for a target.",
-     "This is a per-configuration version of INTERPROCEDURAL_OPTIMIZATION.  "
-     "If set, this property overrides the generic property "
-     "for the named configuration.");
-
-  cm->DefineProperty
-    ("LABELS", cmProperty::TARGET,
-     "Specify a list of text labels associated with a target.",
-     "Target label semantics are currently unspecified.");
-
-  cm->DefineProperty
-    ("LINK_FLAGS", cmProperty::TARGET,
-     "Additional flags to use when linking this target.",
-     "The LINK_FLAGS property can be used to add extra flags to the "
-     "link step of a target. LINK_FLAGS_<CONFIG> will add to the "
-     "configuration <CONFIG>, "
-     "for example, DEBUG, RELEASE, MINSIZEREL, RELWITHDEBINFO. ");
-
-  cm->DefineProperty
-    ("LINK_FLAGS_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration linker flags for a target.",
-     "This is the configuration-specific version of LINK_FLAGS.");
-
-#define CM_LINK_SEARCH_SUMMARY \
-  "Some linkers support switches such as -Bstatic and -Bdynamic " \
-  "to determine whether to use static or shared libraries for -lXXX " \
-  "options.  CMake uses these options to set the link type for " \
-  "libraries whose full paths are not known or (in some cases) are in " \
-  "implicit link directories for the platform.  "
-
-  cm->DefineProperty
-    ("LINK_SEARCH_START_STATIC", cmProperty::TARGET,
-     "Assume the linker looks for static libraries by default.",
-     CM_LINK_SEARCH_SUMMARY
-     "By default the linker search type is assumed to be -Bdynamic at "
-     "the beginning of the library list.  This property switches the "
-     "assumption to -Bstatic.  It is intended for use when linking an "
-     "executable statically (e.g. with the GNU -static option).  "
-     "See also LINK_SEARCH_END_STATIC.");
-
-  cm->DefineProperty
-    ("LINK_SEARCH_END_STATIC", cmProperty::TARGET,
-     "End a link line such that static system libraries are used.",
-     CM_LINK_SEARCH_SUMMARY
-     "By default CMake adds an option at the end of the library list (if "
-     "necessary) to set the linker search type back to its starting type.  "
-     "This property switches the final linker search type to -Bstatic "
-     "regardless of how it started.  "
-     "See also LINK_SEARCH_START_STATIC.");
-
-  cm->DefineProperty
-    ("LINKER_LANGUAGE", cmProperty::TARGET,
-     "Specifies language whose compiler will invoke the linker.",
-     "For executables, shared libraries, and modules, this sets the "
-     "language whose compiler is used to link the target "
-     "(such as \"C\" or \"CXX\").  "
-     "A typical value for an executable is the language of the source "
-     "file providing the program entry point (main).  "
-     "If not set, the language with the highest linker preference "
-     "value is the default.  "
-     "See documentation of CMAKE_<LANG>_LINKER_PREFERENCE variables."
-     "\n"
-     "If this property is not set by the user, it will be calculated at "
-     "generate-time by CMake."
-    );
-
-  cm->DefineProperty
-    ("LOCATION", cmProperty::TARGET,
-     "Read-only location of a target on disk.",
-     "For an imported target, this read-only property returns the value of "
-     "the LOCATION_<CONFIG> property for an unspecified configuration "
-     "<CONFIG> provided by the target.\n"
-     "For a non-imported target, this property is provided for compatibility "
-     "with CMake 2.4 and below.  "
-     "It was meant to get the location of an executable target's output file "
-     "for use in add_custom_command.  "
-     "The path may contain a build-system-specific portion that "
-     "is replaced at build time with the configuration getting built "
-     "(such as \"$(ConfigurationName)\" in VS). "
-     "In CMake 2.6 and above add_custom_command automatically recognizes a "
-     "target name in its COMMAND and DEPENDS options and computes the "
-     "target location.  "
-     "In CMake 2.8.4 and above add_custom_command recognizes generator "
-     "expressions to refer to target locations anywhere in the command.  "
-     "Therefore this property is not needed for creating custom commands."
-     CM_LOCATION_UNDEFINED_BEHAVIOR("reading this property"));
-
-  cm->DefineProperty
-    ("LOCATION_<CONFIG>", cmProperty::TARGET,
-     "Read-only property providing a target location on disk.",
-     "A read-only property that indicates where a target's main file is "
-     "located on disk for the configuration <CONFIG>.  "
-     "The property is defined only for library and executable targets.  "
-     "An imported target may provide a set of configurations different "
-     "from that of the importing project.  "
-     "By default CMake looks for an exact-match but otherwise uses an "
-     "arbitrary available configuration.  "
-     "Use the MAP_IMPORTED_CONFIG_<CONFIG> property to map imported "
-     "configurations explicitly."
-     CM_LOCATION_UNDEFINED_BEHAVIOR("reading this property"));
-
-  cm->DefineProperty
-    ("LINK_DEPENDS", cmProperty::TARGET,
-     "Additional files on which a target binary depends for linking.",
-     "Specifies a semicolon-separated list of full-paths to files on which "
-     "the link rule for this target depends.  "
-     "The target binary will be linked if any of the named files is newer "
-     "than it."
-     "\n"
-     "This property is ignored by non-Makefile generators.  "
-     "It is intended to specify dependencies on \"linker scripts\" for "
-     "custom Makefile link rules.");
-
-  cm->DefineProperty
-    ("LINK_DEPENDS_NO_SHARED", cmProperty::TARGET,
-     "Do not depend on linked shared library files.",
-     "Set this property to true to tell CMake generators not to add "
-     "file-level dependencies on the shared library files linked by "
-     "this target.  "
-     "Modification to the shared libraries will not be sufficient to "
-     "re-link this target.  "
-     "Logical target-level dependencies will not be affected so the "
-     "linked shared libraries will still be brought up to date before "
-     "this target is built."
-     "\n"
-     "This property is initialized by the value of the variable "
-     "CMAKE_LINK_DEPENDS_NO_SHARED if it is set when a target is "
-     "created.");
-
-  cm->DefineProperty
-    ("LINK_INTERFACE_LIBRARIES", cmProperty::TARGET,
-     "List public interface libraries for a shared library or executable.",
-     "By default linking to a shared library target transitively "
-     "links to targets with which the library itself was linked.  "
-     "For an executable with exports (see the ENABLE_EXPORTS property) "
-     "no default transitive link dependencies are used.  "
-     "This property replaces the default transitive link dependencies with "
-     "an explicit list.  "
-     "When the target is linked into another target the libraries "
-     "listed (and recursively their link interface libraries) will be "
-     "provided to the other target also.  "
-     "If the list is empty then no transitive link dependencies will be "
-     "incorporated when this target is linked into another target even if "
-     "the default set is non-empty.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_LINK_INTERFACE_LIBRARIES if it is set when a target is "
-     "created.  "
-     "This property is ignored for STATIC libraries.\n"
-     "This property is overriden by the INTERFACE_LINK_LIBRARIES property if "
-     "policy CMP0022 is NEW.\n"
-     "This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.");
-
-  cm->DefineProperty
-    ("LINK_INTERFACE_LIBRARIES_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration list of public interface libraries for a target.",
-     "This is the configuration-specific version of "
-     "LINK_INTERFACE_LIBRARIES.  "
-     "If set, this property completely overrides the generic property "
-     "for the named configuration.\n"
-     "This property is overriden by the INTERFACE_LINK_LIBRARIES property if "
-     "policy CMP0022 is NEW.\n"
-     "This property is deprecated. Use INTERFACE_LINK_LIBRARIES instead.");
-
-  cm->DefineProperty
-    ("INTERFACE_LINK_LIBRARIES", cmProperty::TARGET,
-     "List public interface libraries for a shared library or executable.",
-     "This property contains the list of transitive link dependencies.  "
-     "When the target is linked into another target the libraries "
-     "listed (and recursively their link interface libraries) will be "
-     "provided to the other target also.  "
-     "This property is overriden by the LINK_INTERFACE_LIBRARIES or "
-     "LINK_INTERFACE_LIBRARIES_<CONFIG> property if "
-     "policy CMP0022 is OLD or unset.\n"
-     "\n"
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("INTERFACE_INCLUDE_DIRECTORIES", cmProperty::TARGET,
-     "List of public include directories for a library.",
-     "Targets may populate this property to publish the include directories "
-     "required to compile against the headers for the target.  Consuming "
-     "targets can add entries to their own INCLUDE_DIRECTORIES property such "
-     "as $<TARGET_PROPERTY:foo,INTERFACE_INCLUDE_DIRECTORIES> to use the "
-     "include directories specified in the interface of 'foo'."
-     "\n"
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", cmProperty::TARGET,
-     "List of public system include directories for a library.",
-     "Targets may populate this property to publish the include directories "
-     "which contain system headers, and therefore should not result in "
-     "compiler warnings.  Consuming targets will then mark the same include "
-     "directories as system headers."
-     "\n"
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("INTERFACE_COMPILE_DEFINITIONS", cmProperty::TARGET,
-     "List of public compile definitions for a library.",
-     "Targets may populate this property to publish the compile definitions "
-     "required to compile against the headers for the target.  Consuming "
-     "targets can add entries to their own COMPILE_DEFINITIONS property such "
-     "as $<TARGET_PROPERTY:foo,INTERFACE_COMPILE_DEFINITIONS> to use the "
-     "compile definitions specified in the interface of 'foo'."
-     "\n"
-     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS);
-
-  cm->DefineProperty
-    ("LINK_INTERFACE_MULTIPLICITY", cmProperty::TARGET,
-     "Repetition count for STATIC libraries with cyclic dependencies.",
-     "When linking to a STATIC library target with cyclic dependencies the "
-     "linker may need to scan more than once through the archives in the "
-     "strongly connected component of the dependency graph.  "
-     "CMake by default constructs the link line so that the linker will "
-     "scan through the component at least twice.  "
-     "This property specifies the minimum number of scans if it is larger "
-     "than the default.  "
-     "CMake uses the largest value specified by any target in a component.");
-  cm->DefineProperty
-    ("LINK_INTERFACE_MULTIPLICITY_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration repetition count for cycles of STATIC libraries.",
-     "This is the configuration-specific version of "
-     "LINK_INTERFACE_MULTIPLICITY.  "
-     "If set, this property completely overrides the generic property "
-     "for the named configuration.");
-
-  cm->DefineProperty
-    ("MAP_IMPORTED_CONFIG_<CONFIG>", cmProperty::TARGET,
-     "Map from project configuration to IMPORTED target's configuration.",
-     "Set this to the list of configurations of an imported target that "
-     "may be used for the current project's <CONFIG> configuration.  "
-     "Targets imported from another project may not provide the same set "
-     "of configuration names available in the current project.  "
-     "Setting this property tells CMake what imported configurations are "
-     "suitable for use when building the <CONFIG> configuration.  "
-     "The first configuration in the list found to be provided by the "
-     "imported target is selected.  If this property is set and no matching "
-     "configurations are available, then the imported target is considered "
-     "to be not found.  This property is ignored for non-imported targets.\n"
-     "This property is initialized by the value of the variable "
-     "CMAKE_MAP_IMPORTED_CONFIG_<CONFIG> if it is set when a target is "
-     "created.",
-     false /* TODO: make this chained */ );
-
-  cm->DefineProperty
-    ("NO_SYSTEM_FROM_IMPORTED", cmProperty::TARGET,
-     "Do not treat includes from IMPORTED target interfaces as SYSTEM.",
-     "The contents of the INTERFACE_INCLUDE_DIRECTORIES of IMPORTED targets "
-     "are treated as SYSTEM includes by default.  If this property is "
-     "enabled, the contents of the INTERFACE_INCLUDE_DIRECTORIES of IMPORTED "
-     "targets are not treated as system includes.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_NO_SYSTEM_FROM_IMPORTED if it is set when a target is "
-     "created.");
-
-  cm->DefineProperty
-    ("OSX_ARCHITECTURES", cmProperty::TARGET,
-     "Target specific architectures for OS X.",
-     "The OSX_ARCHITECTURES property sets the target binary architecture "
-     "for targets on OS X.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_OSX_ARCHITECTURES if it is set when a target is created.  "
-     "Use OSX_ARCHITECTURES_<CONFIG> to set the binary architectures on a "
-     "per-configuration basis.  "
-     "<CONFIG> is an upper-case name (ex: \"OSX_ARCHITECTURES_DEBUG\").");
-
-  cm->DefineProperty
-    ("OSX_ARCHITECTURES_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration OS X binary architectures for a target.",
-     "This property is the configuration-specific version of "
-     "OSX_ARCHITECTURES.");
-
-  cm->DefineProperty
-    ("NAME", cmProperty::TARGET,
-     "Logical name for the target.",
-     "Read-only logical name for the target as used by CMake.");
-
-  cm->DefineProperty
-    ("EXPORT_NAME", cmProperty::TARGET,
-     "Exported name for target files.",
-     "This sets the name for the IMPORTED target generated when it this "
-     "target is is exported.  "
-     "If not set, the logical target name is used by default.");
-
-  cm->DefineProperty
-    ("OUTPUT_NAME", cmProperty::TARGET,
-     "Output name for target files.",
-     "This sets the base name for output files created for an executable or "
-     "library target.  "
-     "If not set, the logical target name is used by default.");
-
-  cm->DefineProperty
-    ("OUTPUT_NAME_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration target file base name.",
-     "This is the configuration-specific version of OUTPUT_NAME.");
-
-  cm->DefineProperty
-    ("ALIASED_TARGET", cmProperty::TARGET,
-     "Name of target aliased by this target.",
-     "If this is an ALIAS target, this property contains the name of the "
-     "target aliased.");
-
-  cm->DefineProperty
-    ("<CONFIG>_OUTPUT_NAME", cmProperty::TARGET,
-     "Old per-configuration target file base name.",
-     "This is a configuration-specific version of OUTPUT_NAME.  "
-     "Use OUTPUT_NAME_<CONFIG> instead.");
-
-  cm->DefineProperty
-    ("PDB_NAME", cmProperty::TARGET,
-     "Output name for MS debug symbols .pdb file from linker.",
-     "Set the base name for debug symbols file created for an "
-     "executable or shared library target.  "
-     "If not set, the logical target name is used by default.  "
-     "\n"
-     "This property is not implemented by the Visual Studio 6 generator.");
-
-  cm->DefineProperty
-    ("PDB_NAME_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration name for MS debug symbols .pdb file.  ",
-     "This is the configuration-specific version of PDB_NAME.  "
-     "\n"
-     "This property is not implemented by the Visual Studio 6 generator.");
-
-  cm->DefineProperty
-    ("PRE_INSTALL_SCRIPT", cmProperty::TARGET,
-     "Deprecated install support.",
-     "The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the "
-     "old way to specify CMake scripts to run before and after "
-     "installing a target.  They are used only when the old "
-     "INSTALL_TARGETS command is used to install the target.  Use the "
-     "INSTALL command instead.");
-
-  cm->DefineProperty
-    ("PREFIX", cmProperty::TARGET,
-     "What comes before the library name.",
-     "A target property that can be set to override the prefix "
-     "(such as \"lib\") on a library name.");
-
-  cm->DefineProperty
-    ("<LANG>_VISIBILITY_PRESET", cmProperty::TARGET,
-     "Value for symbol visibility compile flags",
-     "The <LANG>_VISIBILITY_PRESET property determines the value passed in "
-     "a visibility related compile option, such as -fvisibility= for <LANG>.  "
-     "This property only has an affect for libraries and executables with "
-     "exports.  This property is initialized by the value of the variable "
-     "CMAKE_<LANG>_VISIBILITY_PRESET if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("VISIBILITY_INLINES_HIDDEN", cmProperty::TARGET,
-     "Whether to add a compile flag to hide symbols of inline functions",
-     "The VISIBILITY_INLINES_HIDDEN property determines whether a flag for "
-     "hiding symbols for inline functions. the value passed used in "
-     "a visibility related compile option, such as -fvisibility=.  This "
-     "property only has an affect for libraries and executables with "
-     "exports.  This property is initialized by the value of the variable "
-     "CMAKE_VISIBILITY_INLINES_HIDDEN if it is set when a target is "
-     "created.");
-
-  cm->DefineProperty
-    ("POSITION_INDEPENDENT_CODE", cmProperty::TARGET,
-     "Whether to create a position-independent target",
-     "The POSITION_INDEPENDENT_CODE property determines whether position "
-     "independent executables or shared libraries will be created.  "
-     "This property is true by default for SHARED and MODULE library "
-     "targets and false otherwise.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_POSITION_INDEPENDENT_CODE if it is set when a target is "
-     "created.");
-
-  cm->DefineProperty
-    ("INTERFACE_POSITION_INDEPENDENT_CODE", cmProperty::TARGET,
-     "Whether consumers need to create a position-independent target",
-     "The INTERFACE_POSITION_INDEPENDENT_CODE property informs consumers of "
-     "this target whether they must set their POSITION_INDEPENDENT_CODE "
-     "property to ON.  If this property is set to ON, then the "
-     "POSITION_INDEPENDENT_CODE property on all consumers will be set to "
-     "ON.  Similarly, if this property is set to OFF, then the "
-     "POSITION_INDEPENDENT_CODE property on all consumers will be set to "
-     "OFF.  If this property is undefined, then consumers will determine "
-     "their POSITION_INDEPENDENT_CODE property by other means.  Consumers "
-     "must ensure that the targets that they link to have a consistent "
-     "requirement for their INTERFACE_POSITION_INDEPENDENT_CODE property.");
-
-  cm->DefineProperty
-    ("COMPATIBLE_INTERFACE_BOOL", cmProperty::TARGET,
-     "Properties which must be compatible with their link interface",
-     "The COMPATIBLE_INTERFACE_BOOL property may contain a list of properties"
-     "for this target which must be consistent when evaluated as a boolean "
-     "in the INTERFACE of all linked dependees.  For example, if a "
-     "property \"FOO\" appears in the list, then for each dependee, the "
-     "\"INTERFACE_FOO\" property content in all of its dependencies must be "
-     "consistent with each other, and with the \"FOO\" property in the "
-     "dependee.  Consistency in this sense has the meaning that if the "
-     "property is set, then it must have the same boolean value as all "
-     "others, and if the property is not set, then it is ignored.  Note that "
-     "for each dependee, the set of properties from this property must not "
-     "intersect with the set of properties from the "
-     "COMPATIBLE_INTERFACE_STRING property.");
-
-  cm->DefineProperty
-    ("COMPATIBLE_INTERFACE_STRING", cmProperty::TARGET,
-     "Properties which must be string-compatible with their link interface",
-     "The COMPATIBLE_INTERFACE_STRING property may contain a list of "
-     "properties for this target which must be the same when evaluated as "
-     "a string in the INTERFACE of all linked dependees.  For example, "
-     "if a property \"FOO\" appears in the list, then for each dependee, the "
-     "\"INTERFACE_FOO\" property content in all of its dependencies must be "
-     "equal with each other, and with the \"FOO\" property in the dependee.  "
-     "If the property is not set, then it is ignored.  Note that for each "
-     "dependee, the set of properties from this property must not intersect "
-     "with the set of properties from the COMPATIBLE_INTERFACE_BOOL "
-     "property.");
-
-  cm->DefineProperty
-    ("POST_INSTALL_SCRIPT", cmProperty::TARGET,
-     "Deprecated install support.",
-     "The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the "
-     "old way to specify CMake scripts to run before and after "
-     "installing a target.  They are used only when the old "
-     "INSTALL_TARGETS command is used to install the target.  Use the "
-     "INSTALL command instead.");
-
-  cm->DefineProperty
-    ("PRIVATE_HEADER", cmProperty::TARGET,
-     "Specify private header files in a FRAMEWORK shared library target.",
-     "Shared library targets marked with the FRAMEWORK property generate "
-     "frameworks on OS X and normal shared libraries on other platforms.  "
-     "This property may be set to a list of header files to be placed "
-     "in the PrivateHeaders directory inside the framework folder.  "
-     "On non-Apple platforms these headers may be installed using the "
-     "PRIVATE_HEADER option to the install(TARGETS) command.");
-
-  cm->DefineProperty
-    ("PUBLIC_HEADER", cmProperty::TARGET,
-     "Specify public header files in a FRAMEWORK shared library target.",
-     "Shared library targets marked with the FRAMEWORK property generate "
-     "frameworks on OS X and normal shared libraries on other platforms.  "
-     "This property may be set to a list of header files to be placed "
-     "in the Headers directory inside the framework folder.  "
-     "On non-Apple platforms these headers may be installed using the "
-     "PUBLIC_HEADER option to the install(TARGETS) command.");
-
-  cm->DefineProperty
-    ("RESOURCE", cmProperty::TARGET,
-     "Specify resource files in a FRAMEWORK shared library target.",
-     "Shared library targets marked with the FRAMEWORK property generate "
-     "frameworks on OS X and normal shared libraries on other platforms.  "
-     "This property may be set to a list of files to be placed "
-     "in the Resources directory inside the framework folder.  "
-     "On non-Apple platforms these files may be installed using the "
-     "RESOURCE option to the install(TARGETS) command.");
-
-  cm->DefineProperty
     ("RULE_LAUNCH_COMPILE", cmProperty::TARGET,
-     "Specify a launcher for compile rules.",
-     "See the global property of the same name for details.  "
-     "This overrides the global and directory property for a target.",
-     true);
+     "", "", true);
   cm->DefineProperty
     ("RULE_LAUNCH_LINK", cmProperty::TARGET,
-     "Specify a launcher for link rules.",
-     "See the global property of the same name for details.  "
-     "This overrides the global and directory property for a target.",
-     true);
+     "", "", true);
   cm->DefineProperty
     ("RULE_LAUNCH_CUSTOM", cmProperty::TARGET,
-     "Specify a launcher for custom rules.",
-     "See the global property of the same name for details.  "
-     "This overrides the global and directory property for a target.",
-     true);
-
-  cm->DefineProperty
-    ("SKIP_BUILD_RPATH", cmProperty::TARGET,
-     "Should rpaths be used for the build tree.",
-     "SKIP_BUILD_RPATH is a boolean specifying whether to skip automatic "
-     "generation of an rpath allowing the target to run from the "
-     "build tree.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_SKIP_BUILD_RPATH if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("NO_SONAME", cmProperty::TARGET,
-     "Whether to set \"soname\" when linking a shared library or module.",
-     "Enable this boolean property if a generated shared library or module "
-     "should not have \"soname\" set. Default is to set \"soname\" on all "
-     "shared libraries and modules as long as the platform supports it. "
-     "Generally, use this property only for leaf private libraries or "
-     "plugins. If you use it on normal shared libraries which other targets "
-     "link against, on some platforms a linker will insert a full path to "
-     "the library (as specified at link time) into the dynamic section of "
-     "the dependent binary. Therefore, once installed, dynamic loader may "
-     "eventually fail to locate the library for the binary.");
-
-  cm->DefineProperty
-    ("SOVERSION", cmProperty::TARGET,
-     "What version number is this target.",
-     "For shared libraries VERSION and SOVERSION can be used to specify "
-     "the build version and API version respectively. When building or "
-     "installing appropriate symlinks are created if the platform "
-     "supports symlinks and the linker supports so-names. "
-     "If only one of both is specified the missing is assumed to have "
-     "the same version number. "
-     "SOVERSION is ignored if NO_SONAME property is set. "
-     "For shared libraries and executables on Windows the VERSION "
-     "attribute is parsed to extract a \"major.minor\" version number. "
-     "These numbers are used as the image version of the binary. ");
-
-  cm->DefineProperty
-    ("STATIC_LIBRARY_FLAGS", cmProperty::TARGET,
-     "Extra flags to use when linking static libraries.",
-     "Extra flags to use when linking a static library.");
-
-  cm->DefineProperty
-    ("STATIC_LIBRARY_FLAGS_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration flags for creating a static library.",
-     "This is the configuration-specific version of STATIC_LIBRARY_FLAGS.");
-
-  cm->DefineProperty
-    ("SUFFIX", cmProperty::TARGET,
-     "What comes after the target name.",
-     "A target property that can be set to override the suffix "
-     "(such as \".so\" or \".exe\") on the name of a library, module or "
-     "executable.");
-
-  cm->DefineProperty
-    ("TYPE", cmProperty::TARGET,
-     "The type of the target.",
-     "This read-only property can be used to test the type of the given "
-     "target. It will be one of STATIC_LIBRARY, MODULE_LIBRARY, "
-     "SHARED_LIBRARY, EXECUTABLE or one of the internal target types.");
-
-  cm->DefineProperty
-    ("VERSION", cmProperty::TARGET,
-     "What version number is this target.",
-     "For shared libraries VERSION and SOVERSION can be used to specify "
-     "the build version and API version respectively. When building or "
-     "installing appropriate symlinks are created if the platform "
-     "supports symlinks and the linker supports so-names. "
-     "If only one of both is specified the missing is assumed to have "
-     "the same version number. "
-     "For executables VERSION can be used to specify the build version. "
-     "When building or installing appropriate symlinks are created if "
-     "the platform supports symlinks. "
-     "For shared libraries and executables on Windows the VERSION "
-     "attribute is parsed to extract a \"major.minor\" version number. "
-     "These numbers are used as the image version of the binary. ");
-
-
-  cm->DefineProperty
-    ("WIN32_EXECUTABLE", cmProperty::TARGET,
-     "Build an executable with a WinMain entry point on windows.",
-     "When this property is set to true the executable when linked "
-     "on Windows will be created with a WinMain() entry point instead "
-     "of just main().  "
-     "This makes it a GUI executable instead of a console application.  "
-     "See the CMAKE_MFC_FLAG variable documentation to configure use "
-     "of MFC for WinMain executables.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_WIN32_EXECUTABLE if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("MACOSX_BUNDLE", cmProperty::TARGET,
-     "Build an executable as an application bundle on Mac OS X.",
-     "When this property is set to true the executable when built "
-     "on Mac OS X will be created as an application bundle.  "
-     "This makes it a GUI executable that can be launched from "
-     "the Finder.  "
-     "See the MACOSX_BUNDLE_INFO_PLIST target property for information "
-     "about creation of the Info.plist file for the application bundle.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_MACOSX_BUNDLE if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("MACOSX_BUNDLE_INFO_PLIST", cmProperty::TARGET,
-     "Specify a custom Info.plist template for a Mac OS X App Bundle.",
-     "An executable target with MACOSX_BUNDLE enabled will be built as an "
-     "application bundle on Mac OS X.  "
-     "By default its Info.plist file is created by configuring a template "
-     "called MacOSXBundleInfo.plist.in located in the CMAKE_MODULE_PATH.  "
-     "This property specifies an alternative template file name which "
-     "may be a full path.\n"
-     "The following target properties may be set to specify content to "
-     "be configured into the file:\n"
-     "  MACOSX_BUNDLE_INFO_STRING\n"
-     "  MACOSX_BUNDLE_ICON_FILE\n"
-     "  MACOSX_BUNDLE_GUI_IDENTIFIER\n"
-     "  MACOSX_BUNDLE_LONG_VERSION_STRING\n"
-     "  MACOSX_BUNDLE_BUNDLE_NAME\n"
-     "  MACOSX_BUNDLE_SHORT_VERSION_STRING\n"
-     "  MACOSX_BUNDLE_BUNDLE_VERSION\n"
-     "  MACOSX_BUNDLE_COPYRIGHT\n"
-     "CMake variables of the same name may be set to affect all targets "
-     "in a directory that do not have each specific property set.  "
-     "If a custom Info.plist is specified by this property it may of course "
-     "hard-code all the settings instead of using the target properties.");
-
-  cm->DefineProperty
-    ("MACOSX_FRAMEWORK_INFO_PLIST", cmProperty::TARGET,
-     "Specify a custom Info.plist template for a Mac OS X Framework.",
-     "A library target with FRAMEWORK enabled will be built as a "
-     "framework on Mac OS X.  "
-     "By default its Info.plist file is created by configuring a template "
-     "called MacOSXFrameworkInfo.plist.in located in the CMAKE_MODULE_PATH.  "
-     "This property specifies an alternative template file name which "
-     "may be a full path.\n"
-     "The following target properties may be set to specify content to "
-     "be configured into the file:\n"
-     "  MACOSX_FRAMEWORK_ICON_FILE\n"
-     "  MACOSX_FRAMEWORK_IDENTIFIER\n"
-     "  MACOSX_FRAMEWORK_SHORT_VERSION_STRING\n"
-     "  MACOSX_FRAMEWORK_BUNDLE_VERSION\n"
-     "CMake variables of the same name may be set to affect all targets "
-     "in a directory that do not have each specific property set.  "
-     "If a custom Info.plist is specified by this property it may of course "
-     "hard-code all the settings instead of using the target properties.");
-
-  cm->DefineProperty
-    ("MACOSX_RPATH", cmProperty::TARGET,
-     "Whether to use rpaths on Mac OS X.",
-     "When this property is set to true, the directory portion of the"
-     "\"install_name\" field of shared libraries will default to \"@rpath\"."
-     "Runtime paths will also be embedded in binaries using this target."
-     "This property is initialized by the value of the variable "
-     "CMAKE_MACOSX_RPATH if it is set when a target is created.");
-
-  cm->DefineProperty
-    ("ENABLE_EXPORTS", cmProperty::TARGET,
-     "Specify whether an executable exports symbols for loadable modules.",
-     "Normally an executable does not export any symbols because it is "
-     "the final program.  It is possible for an executable to export "
-     "symbols to be used by loadable modules.  When this property is "
-     "set to true CMake will allow other targets to \"link\" to the "
-     "executable with the TARGET_LINK_LIBRARIES command.  "
-     "On all platforms a target-level dependency on the executable is "
-     "created for targets that link to it.  "
-     "For DLL platforms an import library will be created for the "
-     "exported symbols and then used for linking.  "
-     "All Windows-based systems including Cygwin are DLL platforms.  "
-     "For non-DLL platforms that require all symbols to be resolved at "
-     "link time, such as Mac OS X, the module will \"link\" to the "
-     "executable using a flag like \"-bundle_loader\".  "
-     "For other non-DLL platforms the link rule is simply ignored since "
-     "the dynamic loader will automatically bind symbols when the "
-     "module is loaded.  "
-      );
-
-  cm->DefineProperty
-    ("Fortran_FORMAT", cmProperty::TARGET,
-     "Set to FIXED or FREE to indicate the Fortran source layout.",
-     "This property tells CMake whether the Fortran source files "
-     "in a target use fixed-format or free-format.  "
-     "CMake will pass the corresponding format flag to the compiler.  "
-     "Use the source-specific Fortran_FORMAT property to change the "
-     "format of a specific source file.  "
-     "If the variable CMAKE_Fortran_FORMAT is set when a target "
-     "is created its value is used to initialize this property.");
-
-  cm->DefineProperty
-    ("Fortran_MODULE_DIRECTORY", cmProperty::TARGET,
-     "Specify output directory for Fortran modules provided by the target.",
-     "If the target contains Fortran source files that provide modules "
-     "and the compiler supports a module output directory this specifies "
-     "the directory in which the modules will be placed.  "
-     "When this property is not set the modules will be placed in the "
-     "build directory corresponding to the target's source directory.  "
-     "If the variable CMAKE_Fortran_MODULE_DIRECTORY is set when a target "
-     "is created its value is used to initialize this property."
-     "\n"
-     "Note that some compilers will automatically search the module output "
-     "directory for modules USEd during compilation but others will not.  "
-     "If your sources USE modules their location must be specified by "
-     "INCLUDE_DIRECTORIES regardless of this property.");
-
-  cm->DefineProperty
-    ("GNUtoMS", cmProperty::TARGET,
-     "Convert GNU import library (.dll.a) to MS format (.lib).",
-     "When linking a shared library or executable that exports symbols "
-     "using GNU tools on Windows (MinGW/MSYS) with Visual Studio installed "
-     "convert the import library (.dll.a) from GNU to MS format (.lib).  "
-     "Both import libraries will be installed by install(TARGETS) and "
-     "exported by install(EXPORT) and export() to be linked by applications "
-     "with either GNU- or MS-compatible tools."
-     "\n"
-     "If the variable CMAKE_GNUtoMS is set when a target "
-     "is created its value is used to initialize this property.  "
-     "The variable must be set prior to the first command that enables "
-     "a language such as project() or enable_language().  "
-     "CMake provides the variable as an option to the user automatically "
-     "when configuring on Windows with GNU tools.");
-
-  cm->DefineProperty
-    ("XCODE_ATTRIBUTE_<an-attribute>", cmProperty::TARGET,
-     "Set Xcode target attributes directly.",
-     "Tell the Xcode generator to set '<an-attribute>' to a given value "
-     "in the generated Xcode project.  Ignored on other generators.");
-
-  cm->DefineProperty
-    ("GENERATOR_FILE_NAME", cmProperty::TARGET,
-     "Generator's file for this target.",
-     "An internal property used by some generators to record the name of the "
-     "project or dsp file associated with this target. Note that at configure "
-     "time, this property is only set for targets created by "
-     "include_external_msproject().");
-
-  cm->DefineProperty
-    ("SOURCES", cmProperty::TARGET,
-     "Source names specified for a target.",
-     "Read-only list of sources specified for a target.  "
-     "The names returned are suitable for passing to the "
-     "set_source_files_properties command.");
-
-  cm->DefineProperty
-    ("FOLDER", cmProperty::TARGET,
-     "Set the folder name. Use to organize targets in an IDE.",
-     "Targets with no FOLDER property will appear as top level "
-     "entities in IDEs like Visual Studio. Targets with the same "
-     "FOLDER property value will appear next to each other in a "
-     "folder of that name. To nest folders, use FOLDER values such "
-     "as 'GUI/Dialogs' with '/' characters separating folder levels.");
-
-  cm->DefineProperty
-    ("PROJECT_LABEL", cmProperty::TARGET,
-     "Change the name of a target in an IDE.",
-     "Can be used to change the name of the target in an IDE "
-     "like Visual Studio. ");
-  cm->DefineProperty
-    ("VS_KEYWORD", cmProperty::TARGET,
-     "Visual Studio project keyword.",
-     "Can be set to change the visual studio keyword, for example "
-     "Qt integration works better if this is set to Qt4VSv1.0. ");
-  cm->DefineProperty
-    ("VS_SCC_PROVIDER", cmProperty::TARGET,
-     "Visual Studio Source Code Control Provider.",
-     "Can be set to change the visual studio source code control "
-     "provider property.");
-  cm->DefineProperty
-    ("VS_SCC_LOCALPATH", cmProperty::TARGET,
-     "Visual Studio Source Code Control Local Path.",
-     "Can be set to change the visual studio source code control "
-     "local path property.");
-  cm->DefineProperty
-    ("VS_SCC_PROJECTNAME", cmProperty::TARGET,
-     "Visual Studio Source Code Control Project.",
-     "Can be set to change the visual studio source code control "
-     "project name property.");
-  cm->DefineProperty
-    ("VS_SCC_AUXPATH", cmProperty::TARGET,
-     "Visual Studio Source Code Control Aux Path.",
-     "Can be set to change the visual studio source code control "
-     "auxpath property.");
-  cm->DefineProperty
-    ("VS_GLOBAL_PROJECT_TYPES", cmProperty::TARGET,
-     "Visual Studio project type(s).",
-     "Can be set to one or more UUIDs recognized by Visual Studio "
-     "to indicate the type of project. This value is copied "
-     "verbatim into the generated project file. Example for a "
-     "managed C++ unit testing project:\n"
-     " {3AC096D0-A1C2-E12C-1390-A8335801FDAB};"
-     "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\n"
-     "UUIDs are semicolon-delimited.");
-  cm->DefineProperty
-    ("VS_GLOBAL_KEYWORD", cmProperty::TARGET,
-     "Visual Studio project keyword.",
-     "Sets the \"keyword\" attribute for a generated Visual Studio "
-     "project. Defaults to \"Win32Proj\". You may wish to override "
-     "this value with \"ManagedCProj\", for example, in a Visual "
-     "Studio managed C++ unit test project.");
-  cm->DefineProperty
-    ("VS_GLOBAL_ROOTNAMESPACE", cmProperty::TARGET,
-     "Visual Studio project root namespace.",
-     "Sets the \"RootNamespace\" attribute for a generated Visual Studio "
-     "project.  The attribute will be generated only if this is set.");
-  cm->DefineProperty
-    ("VS_DOTNET_TARGET_FRAMEWORK_VERSION", cmProperty::TARGET,
-     "Specify the .NET target framework version.",
-     "Used to specify the .NET target framework version for C++/CLI. "
-     "For example, \"v4.5\".");
-  cm->DefineProperty
-    ("VS_DOTNET_REFERENCES", cmProperty::TARGET,
-     "Visual Studio managed project .NET references",
-     "Adds one or more semicolon-delimited .NET references to a "
-     "generated Visual Studio project. For example, \"System;"
-     "System.Windows.Forms\".");
-  cm->DefineProperty
-    ("VS_WINRT_EXTENSIONS", cmProperty::TARGET,
-     "Visual Studio project C++/CX language extensions for Windows Runtime",
-     "Can be set to enable C++/CX language extensions.");
-  cm->DefineProperty
-    ("VS_WINRT_REFERENCES", cmProperty::TARGET,
-     "Visual Studio project Windows Runtime Metadata references",
-     "Adds one or more semicolon-delimited WinRT references to a "
-     "generated Visual Studio project. For example, \"Windows;"
-     "Windows.UI.Core\".");
-  cm->DefineProperty
-    ("VS_GLOBAL_<variable>", cmProperty::TARGET,
-     "Visual Studio project-specific global variable.",
-     "Tell the Visual Studio generator to set the global variable "
-     "'<variable>' to a given value in the generated Visual Studio "
-     "project. Ignored on other generators. Qt integration works "
-     "better if VS_GLOBAL_QtVersion is set to the version "
-     "FindQt4.cmake found. For example, \"4.7.3\"");
-
-#define CM_TARGET_FILE_TYPES_DOC                                            \
-     "There are three kinds of target files that may be built: "            \
-     "archive, library, and runtime.  "                                     \
-     "Executables are always treated as runtime targets. "                  \
-     "Static libraries are always treated as archive targets. "             \
-     "Module libraries are always treated as library targets. "             \
-     "For non-DLL platforms shared libraries are treated as library "       \
-     "targets. "                                                            \
-     "For DLL platforms the DLL part of a shared library is treated as "    \
-     "a runtime target and the corresponding import library is treated as " \
-     "an archive target. "                                                  \
-     "All Windows-based systems including Cygwin are DLL platforms."
-
-#define CM_TARGET_OUTDIR_DOC(TYPE, type)                                    \
-     "This property specifies the directory into which " #type " target "   \
-     "files should be built. "                                              \
-     "Multi-configuration generators (VS, Xcode) append "                   \
-     "a per-configuration subdirectory to the specified directory.  "       \
-     CM_TARGET_FILE_TYPES_DOC "  "                                          \
-     "This property is initialized by the value of the variable "           \
-     "CMAKE_" #TYPE "_OUTPUT_DIRECTORY if it is set when a target is created."
-
-#define CM_TARGET_OUTDIR_CONFIG_DOC(TYPE)                                   \
-     "This is a per-configuration version of " #TYPE "_OUTPUT_DIRECTORY, "  \
-     "but multi-configuration generators (VS, Xcode) do NOT append "        \
-     "a per-configuration subdirectory to the specified directory.  "       \
-     "This property is initialized by the value of the variable "           \
-     "CMAKE_" #TYPE "_OUTPUT_DIRECTORY_<CONFIG> "                           \
-     "if it is set when a target is created."
-
-  cm->DefineProperty
-    ("ARCHIVE_OUTPUT_DIRECTORY", cmProperty::TARGET,
-     "Output directory in which to build ARCHIVE target files.",
-     CM_TARGET_OUTDIR_DOC(ARCHIVE, archive));
-  cm->DefineProperty
-    ("ARCHIVE_OUTPUT_DIRECTORY_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output directory for ARCHIVE target files.",
-     CM_TARGET_OUTDIR_CONFIG_DOC(ARCHIVE));
-  cm->DefineProperty
-    ("LIBRARY_OUTPUT_DIRECTORY", cmProperty::TARGET,
-     "Output directory in which to build LIBRARY target files.",
-     CM_TARGET_OUTDIR_DOC(LIBRARY, library));
-  cm->DefineProperty
-    ("LIBRARY_OUTPUT_DIRECTORY_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output directory for LIBRARY target files.",
-     CM_TARGET_OUTDIR_CONFIG_DOC(LIBRARY));
-  cm->DefineProperty
-    ("RUNTIME_OUTPUT_DIRECTORY", cmProperty::TARGET,
-     "Output directory in which to build RUNTIME target files.",
-     CM_TARGET_OUTDIR_DOC(RUNTIME, runtime));
-  cm->DefineProperty
-    ("RUNTIME_OUTPUT_DIRECTORY_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output directory for RUNTIME target files.",
-     CM_TARGET_OUTDIR_CONFIG_DOC(RUNTIME));
-
-  cm->DefineProperty
-    ("PDB_OUTPUT_DIRECTORY", cmProperty::TARGET,
-     "Output directory for MS debug symbols .pdb file from linker.",
-     "This property specifies the directory into which the MS debug symbols "
-     "will be placed by the linker.  "
-     "This property is initialized by the value of the variable "
-     "CMAKE_PDB_OUTPUT_DIRECTORY if it is set when a target is created."
-     "\n"
-     "This property is not implemented by the Visual Studio 6 generator.");
-  cm->DefineProperty
-    ("PDB_OUTPUT_DIRECTORY_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output directory for MS debug symbols .pdb files.",
-     "This is a per-configuration version of PDB_OUTPUT_DIRECTORY, "
-     "but multi-configuration generators (VS, Xcode) do NOT append "
-     "a per-configuration subdirectory to the specified directory. "
-     "This property is initialized by the value of the variable "
-     "CMAKE_PDB_OUTPUT_DIRECTORY_<CONFIG> "
-     "if it is set when a target is created."
-     "\n"
-     "This property is not implemented by the Visual Studio 6 generator.");
-
-  cm->DefineProperty
-    ("ARCHIVE_OUTPUT_NAME", cmProperty::TARGET,
-     "Output name for ARCHIVE target files.",
-     "This property specifies the base name for archive target files. "
-     "It overrides OUTPUT_NAME and OUTPUT_NAME_<CONFIG> properties.  "
-     CM_TARGET_FILE_TYPES_DOC);
-  cm->DefineProperty
-    ("ARCHIVE_OUTPUT_NAME_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output name for ARCHIVE target files.",
-     "This is the configuration-specific version of ARCHIVE_OUTPUT_NAME.");
-  cm->DefineProperty
-    ("LIBRARY_OUTPUT_NAME", cmProperty::TARGET,
-     "Output name for LIBRARY target files.",
-     "This property specifies the base name for library target files. "
-     "It overrides OUTPUT_NAME and OUTPUT_NAME_<CONFIG> properties.  "
-     CM_TARGET_FILE_TYPES_DOC);
-  cm->DefineProperty
-    ("LIBRARY_OUTPUT_NAME_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output name for LIBRARY target files.",
-     "This is the configuration-specific version of LIBRARY_OUTPUT_NAME.");
-  cm->DefineProperty
-    ("RUNTIME_OUTPUT_NAME", cmProperty::TARGET,
-     "Output name for RUNTIME target files.",
-     "This property specifies the base name for runtime target files.  "
-     "It overrides OUTPUT_NAME and OUTPUT_NAME_<CONFIG> properties.  "
-     CM_TARGET_FILE_TYPES_DOC);
-  cm->DefineProperty
-    ("RUNTIME_OUTPUT_NAME_<CONFIG>", cmProperty::TARGET,
-     "Per-configuration output name for RUNTIME target files.",
-     "This is the configuration-specific version of RUNTIME_OUTPUT_NAME.");
+     "", "", true);
 }
 
 void cmTarget::SetType(TargetType type, const char* name)
diff --git a/Source/cmTest.cxx b/Source/cmTest.cxx
index 0904431..9cda978 100644
--- a/Source/cmTest.cxx
+++ b/Source/cmTest.cxx
@@ -92,114 +92,3 @@ void cmTest::AppendProperty(const char* prop, const char* value, bool asString)
     }
   this->Properties.AppendProperty(prop, value, cmProperty::TEST, asString);
 }
-
-//----------------------------------------------------------------------------
-void cmTest::DefineProperties(cmake *cm)
-{
-  cm->DefineProperty
-    ("ATTACHED_FILES", cmProperty::TEST,
-     "Attach a list of files to a dashboard submission.",
-     "Set this property to a list of files that will be encoded and "
-     "submitted to the dashboard as an addition to the test result.");
-
-  cm->DefineProperty
-    ("ATTACHED_FILES_ON_FAIL", cmProperty::TEST,
-     "Attach a list of files to a dashboard submission if the test fails.",
-     "Same as ATTACHED_FILES, but these files will only be included if the "
-     "test does not pass.");
-
-  cm->DefineProperty
-    ("COST", cmProperty::TEST,
-     "Set this to a floating point value. Tests in a test set will be "
-     "run in descending order of cost.", "This property describes the cost "
-     "of a test. You can explicitly set this value; tests with higher COST "
-     "values will run first.");
-
-  cm->DefineProperty
-    ("DEPENDS", cmProperty::TEST,
-     "Specifies that this test should only be run after the specified "
-     "list of tests.",
-     "Set this to a list of tests that must finish before this test is run.");
-
-  cm->DefineProperty
-    ("ENVIRONMENT", cmProperty::TEST,
-     "Specify environment variables that should be defined for running "
-     "a test.",
-     "If set to a list of environment variables and values of the form "
-     "MYVAR=value those environment variables will be defined while "
-     "running the test. The environment is restored to its previous state "
-     "after the test is done.");
-
-  cm->DefineProperty
-    ("FAIL_REGULAR_EXPRESSION", cmProperty::TEST,
-     "If the output matches this regular expression the test will fail.",
-     "If set, if the output matches one of "
-     "specified regular expressions, the test will fail."
-     "For example: FAIL_REGULAR_EXPRESSION \"[^a-z]Error;ERROR;Failed\"");
-
-  cm->DefineProperty
-    ("LABELS", cmProperty::TEST,
-     "Specify a list of text labels associated with a test.",
-     "The list is reported in dashboard submissions.");
-
-  cm->DefineProperty
-    ("RESOURCE_LOCK", cmProperty::TEST,
-    "Specify a list of resources that are locked by this test.",
-    "If multiple tests specify the same resource lock, they are guaranteed "
-    "not to run concurrently.");
-
-  cm->DefineProperty
-    ("MEASUREMENT", cmProperty::TEST,
-     "Specify a CDASH measurement and value to be reported for a test.",
-     "If set to a name then that name will be reported to CDASH as a "
-     "named measurement with a value of 1. You may also specify a value "
-     "by setting MEASUREMENT to \"measurement=value\".");
-
-  cm->DefineProperty
-    ("PASS_REGULAR_EXPRESSION", cmProperty::TEST,
-     "The output must match this regular expression for the test to pass.",
-     "If set, the test output will be checked "
-     "against the specified regular expressions and at least one of the"
-     " regular expressions has to match, otherwise the test will fail.");
-
-  cm->DefineProperty
-    ("PROCESSORS", cmProperty::TEST,
-     "How many process slots this test requires",
-     "Denotes the number of processors that this test will require. This is "
-     "typically used for MPI tests, and should be used in conjunction with "
-     "the ctest_test PARALLEL_LEVEL option.");
-
-  cm->DefineProperty
-    ("REQUIRED_FILES", cmProperty::TEST,
-     "List of files required to run the test.",
-     "If set to a list of files, the test will not be run unless all of the "
-     "files exist.");
-
-  cm->DefineProperty
-    ("RUN_SERIAL", cmProperty::TEST,
-     "Do not run this test in parallel with any other test.",
-     "Use this option in conjunction with the ctest_test PARALLEL_LEVEL "
-     "option to specify that this test should not be run in parallel with "
-     "any other tests.");
-
-  cm->DefineProperty
-    ("TIMEOUT", cmProperty::TEST,
-     "How many seconds to allow for this test.",
-     "This property if set will limit a test to not take more than "
-     "the specified number of seconds to run. If it exceeds that the "
-     "test process will be killed and ctest will move to the next test. "
-     "This setting takes precedence over "
-     "CTEST_TESTING_TIMEOUT.");
-
-  cm->DefineProperty
-    ("WILL_FAIL", cmProperty::TEST,
-     "If set to true, this will invert the pass/fail flag of the test.",
-     "This property can be used for tests that are expected to fail and "
-     "return a non zero return code.");
-
-  cm->DefineProperty
-    ("WORKING_DIRECTORY", cmProperty::TEST,
-     "The directory from which the test executable will be called.",
-     "If this is not set it is called from the directory the test executable "
-     "is located in.");
-}
diff --git a/Source/cmTest.h b/Source/cmTest.h
index 73ac133..1fe8fc0 100644
--- a/Source/cmTest.h
+++ b/Source/cmTest.h
@@ -52,9 +52,6 @@ public:
   bool GetPropertyAsBool(const char *prop) const;
   cmPropertyMap &GetProperties() { return this->Properties; };
 
-  // Define the properties
-  static void DefineProperties(cmake *cm);
-
   /** Get the cmMakefile instance that owns this test.  */
   cmMakefile *GetMakefile() { return this->Makefile;};
 
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index fcda886..2e3c36d 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -10,7 +10,6 @@
   See the License for more information.
 ============================================================================*/
 #include "cmake.h"
-#include "cmDocumentVariables.h"
 #include "cmCacheManager.h"
 #include "cmMakefile.h"
 #include "cmLocalGenerator.h"
@@ -219,12 +218,8 @@ void cmake::InitializeProperties()
   this->PropertyDefinitions.clear();
 
   // initialize properties
-  cmCacheManager::DefineProperties(this);
-  cmSourceFile::DefineProperties(this);
   cmTarget::DefineProperties(this);
   cmMakefile::DefineProperties(this);
-  cmTest::DefineProperties(this);
-  cmake::DefineProperties(this);
 }
 
 void cmake::CleanupCommandsAndMacros()
@@ -2378,203 +2373,6 @@ void cmake::GenerateGraphViz(const char* fileName) const
 #endif
 }
 
-void cmake::DefineProperties(cmake *cm)
-{
-  cm->DefineProperty
-    ("REPORT_UNDEFINED_PROPERTIES", cmProperty::GLOBAL,
-     "If set, report any undefined properties to this file.",
-     "If this property is set to a filename then when CMake runs "
-     "it will report any properties or variables that were accessed "
-     "but not defined into the filename specified in this property."
-     );
-
-  cm->DefineProperty
-    ("TARGET_SUPPORTS_SHARED_LIBS", cmProperty::GLOBAL,
-     "Does the target platform support shared libraries.",
-     "TARGET_SUPPORTS_SHARED_LIBS is a boolean specifying whether the target "
-     "platform supports shared libraries. Basically all current general "
-     "general purpose OS do so, the exception are usually embedded systems "
-     "with no or special OSs.");
-
-  cm->DefineProperty
-    ("TARGET_ARCHIVES_MAY_BE_SHARED_LIBS", cmProperty::GLOBAL,
-     "Set if shared libraries may be named like archives.",
-     "On AIX shared libraries may be named \"lib<name>.a\".  "
-     "This property is set to true on such platforms.");
-
-  cm->DefineProperty
-    ("FIND_LIBRARY_USE_LIB64_PATHS", cmProperty::GLOBAL,
-     "Whether FIND_LIBRARY should automatically search lib64 directories.",
-     "FIND_LIBRARY_USE_LIB64_PATHS is a boolean specifying whether the "
-     "FIND_LIBRARY command should automatically search the lib64 variant of "
-     "directories called lib in the search path when building 64-bit "
-     "binaries.");
-  cm->DefineProperty
-    ("FIND_LIBRARY_USE_OPENBSD_VERSIONING", cmProperty::GLOBAL,
-     "Whether FIND_LIBRARY should find OpenBSD-style shared libraries.",
-     "This property is a boolean specifying whether the FIND_LIBRARY "
-     "command should find shared libraries with OpenBSD-style versioned "
-     "extension: \".so.<major>.<minor>\".  "
-     "The property is set to true on OpenBSD and false on other platforms.");
-  cm->DefineProperty
-    ("ENABLED_FEATURES", cmProperty::GLOBAL,
-     "List of features which are enabled during the CMake run.",
-     "List of features which are enabled during the CMake run. By default "
-     "it contains the names of all packages which were found. This is "
-     "determined using the <NAME>_FOUND variables. Packages which are "
-     "searched QUIET are not listed. A project can add its own features to "
-     "this list. "
-     "This property is used by the macros in FeatureSummary.cmake.");
-  cm->DefineProperty
-    ("DISABLED_FEATURES", cmProperty::GLOBAL,
-     "List of features which are disabled during the CMake run.",
-     "List of features which are disabled during the CMake run. By default "
-     "it contains the names of all packages which were not found. This is "
-     "determined using the <NAME>_FOUND variables. Packages which are "
-     "searched QUIET are not listed. A project can add its own features to "
-     "this list. "
-     "This property is used by the macros in FeatureSummary.cmake.");
-  cm->DefineProperty
-    ("PACKAGES_FOUND", cmProperty::GLOBAL,
-     "List of packages which were found during the CMake run.",
-     "List of packages which were found during the CMake run. Whether a "
-     "package has been found is determined using the <NAME>_FOUND variables.");
-  cm->DefineProperty
-    ("PACKAGES_NOT_FOUND", cmProperty::GLOBAL,
-     "List of packages which were not found during the CMake run.",
-     "List of packages which were not found during the CMake run. Whether a "
-     "package has been found is determined using the <NAME>_FOUND variables.");
-
-  cm->DefineProperty(
-    "DEBUG_CONFIGURATIONS", cmProperty::GLOBAL,
-    "Specify which configurations are for debugging.",
-    "The value must be a semi-colon separated list of configuration names.  "
-    "Currently this property is used only by the target_link_libraries "
-    "command (see its documentation for details).  "
-    "Additional uses may be defined in the future.  "
-    "\n"
-    "This property must be set at the top level of the project and before "
-    "the first target_link_libraries command invocation.  "
-    "If any entry in the list does not match a valid configuration for "
-    "the project the behavior is undefined.");
-
-  cm->DefineProperty(
-    "GLOBAL_DEPENDS_DEBUG_MODE", cmProperty::GLOBAL,
-    "Enable global target dependency graph debug mode.",
-    "CMake automatically analyzes the global inter-target dependency graph "
-    "at the beginning of native build system generation.  "
-    "This property causes it to display details of its analysis to stderr.");
-
-  cm->DefineProperty(
-    "GLOBAL_DEPENDS_NO_CYCLES", cmProperty::GLOBAL,
-    "Disallow global target dependency graph cycles.",
-    "CMake automatically analyzes the global inter-target dependency graph "
-    "at the beginning of native build system generation.  "
-    "It reports an error if the dependency graph contains a cycle that "
-    "does not consist of all STATIC library targets.  "
-    "This property tells CMake to disallow all cycles completely, even "
-    "among static libraries.");
-
-  cm->DefineProperty(
-    "ALLOW_DUPLICATE_CUSTOM_TARGETS", cmProperty::GLOBAL,
-    "Allow duplicate custom targets to be created.",
-    "Normally CMake requires that all targets built in a project have "
-    "globally unique logical names (see policy CMP0002).  "
-    "This is necessary to generate meaningful project file names in "
-    "Xcode and VS IDE generators.  "
-    "It also allows the target names to be referenced unambiguously.\n"
-    "Makefile generators are capable of supporting duplicate custom target "
-    "names.  "
-    "For projects that care only about Makefile generators and do "
-    "not wish to support Xcode or VS IDE generators, one may set this "
-    "property to true to allow duplicate custom targets.  "
-    "The property allows multiple add_custom_target command calls in "
-    "different directories to specify the same target name.  "
-    "However, setting this property will cause non-Makefile generators "
-    "to produce an error and refuse to generate the project."
-    );
-
-  cm->DefineProperty
-    ("IN_TRY_COMPILE", cmProperty::GLOBAL,
-     "Read-only property that is true during a try-compile configuration.",
-     "True when building a project inside a TRY_COMPILE or TRY_RUN command.");
-  cm->DefineProperty
-    ("ENABLED_LANGUAGES", cmProperty::GLOBAL,
-     "Read-only property that contains the list of currently "
-     "enabled languages",
-     "Set to list of currently enabled languages.");
-
-  cm->DefineProperty
-    ("RULE_LAUNCH_COMPILE", cmProperty::GLOBAL,
-     "Specify a launcher for compile rules.",
-     "Makefile generators prefix compiler commands with the given "
-     "launcher command line.  "
-     "This is intended to allow launchers to intercept build problems "
-     "with high granularity.  "
-     "Non-Makefile generators currently ignore this property.");
-  cm->DefineProperty
-    ("RULE_LAUNCH_LINK", cmProperty::GLOBAL,
-     "Specify a launcher for link rules.",
-     "Makefile generators prefix link and archive commands with the given "
-     "launcher command line.  "
-     "This is intended to allow launchers to intercept build problems "
-     "with high granularity.  "
-     "Non-Makefile generators currently ignore this property.");
-  cm->DefineProperty
-    ("RULE_LAUNCH_CUSTOM", cmProperty::GLOBAL,
-     "Specify a launcher for custom rules.",
-     "Makefile generators prefix custom commands with the given "
-     "launcher command line.  "
-     "This is intended to allow launchers to intercept build problems "
-     "with high granularity.  "
-     "Non-Makefile generators currently ignore this property.");
-
-  cm->DefineProperty
-    ("RULE_MESSAGES", cmProperty::GLOBAL,
-     "Specify whether to report a message for each make rule.",
-     "This property specifies whether Makefile generators should add a "
-     "progress message describing what each build rule does.  "
-     "If the property is not set the default is ON.  "
-     "Set the property to OFF to disable granular messages and report only "
-     "as each target completes.  "
-     "This is intended to allow scripted builds to avoid the build time "
-     "cost of detailed reports.  "
-     "If a CMAKE_RULE_MESSAGES cache entry exists its value initializes "
-     "the value of this property.  "
-     "Non-Makefile generators currently ignore this property.");
-
-  cm->DefineProperty
-    ("USE_FOLDERS", cmProperty::GLOBAL,
-     "Use the FOLDER target property to organize targets into folders.",
-     "If not set, CMake treats this property as OFF by default. "
-     "CMake generators that are capable of organizing into a "
-     "hierarchy of folders use the values of the FOLDER target "
-     "property to name those folders. See also the documentation "
-     "for the FOLDER target property.");
-
-  cm->DefineProperty
-    ("AUTOMOC_TARGETS_FOLDER", cmProperty::GLOBAL,
-     "Name of FOLDER for *_automoc targets that are added automatically by "
-     "CMake for targets for which AUTOMOC is enabled.",
-     "If not set, CMake uses the FOLDER property of the parent target as a "
-     "default value for this property. See also the documentation for the "
-     "FOLDER target property and the AUTOMOC target property.");
-
-  cm->DefineProperty
-    ("PREDEFINED_TARGETS_FOLDER", cmProperty::GLOBAL,
-     "Name of FOLDER for targets that are added automatically by CMake.",
-     "If not set, CMake uses \"CMakePredefinedTargets\" as a default "
-     "value for this property. Targets such as INSTALL, PACKAGE and "
-     "RUN_TESTS will be organized into this FOLDER. See also the "
-     "documentation for the FOLDER target property.");
-
-  // ================================================================
-  // define variables as well
-  // ================================================================
-  cmDocumentVariables::DefineVariables(cm);
-}
-
-
 void cmake::DefineProperty(const char *name, cmProperty::ScopeType scope,
                            const char *ShortDescription,
                            const char *FullDescription,
diff --git a/Source/cmake.h b/Source/cmake.h
index 59461fe..f9bd74d 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -345,9 +345,6 @@ class cmake
       debugging configurations.*/
   std::vector<std::string> const& GetDebugConfigs();
 
-  // Define the properties
-  static void DefineProperties(cmake *cm);
-
   void SetCMakeEditCommand(const char* s)
     {
       this->CMakeEditCommand = s;