diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 5b7df2d1e..71fae5808 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -160,8 +160,6 @@ set(SRCS
   cmDocumentation.cxx
   cmDocumentationFormatter.cxx
   cmDocumentationSection.cxx
-  cmDocumentGeneratorExpressions.h
-  cmDocumentLocationUndefined.h
   cmDynamicLoader.cxx
   cmDynamicLoader.h
   ${ELF_SRCS}
diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h
index cabc39b32..08887fe8e 100644
--- a/Source/CTest/cmCTestBuildCommand.h
+++ b/Source/CTest/cmCTestBuildCommand.h
@@ -45,34 +45,8 @@ public:
    */
   virtual const char* GetName() const { return "ctest_build";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Build the project.";
-    }
   virtual bool InitialPass(std::vector<std::string> const& args,
                            cmExecutionStatus &status);
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_build([BUILD build_dir] [TARGET target] [RETURN_VALUE res]\n"
-      "              [APPEND][NUMBER_ERRORS val] [NUMBER_WARNINGS val])\n"
-      "Builds the given build directory and stores results in Build.xml. "
-      "If no BUILD is given, the CTEST_BINARY_DIRECTORY variable is used.\n"
-      "The TARGET variable can be used to specify a build target.  If none "
-      "is specified, the \"all\" target will be built.\n"
-      "The RETURN_VALUE option specifies a variable in which to store the "
-      "return value of the native build tool. "
-      "The NUMBER_ERRORS and NUMBER_WARNINGS options specify variables in "
-      "which to store the number of build errors and warnings detected."
-      "\n"
-      CTEST_COMMAND_APPEND_OPTION_DOCS;
-    }
 
   cmTypeMacro(cmCTestBuildCommand, cmCTestHandlerCommand);
 
diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h
index b343fc1e9..b592c5a2c 100644
--- a/Source/CTest/cmCTestConfigureCommand.h
+++ b/Source/CTest/cmCTestConfigureCommand.h
@@ -40,34 +40,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_configure";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Configure the project build tree.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_configure([BUILD build_dir] [SOURCE source_dir] [APPEND]\n"
-      "                  [OPTIONS options] [RETURN_VALUE res])\n"
-      "Configures the given build directory and stores results in "
-      "Configure.xml. "
-      "If no BUILD is given, the CTEST_BINARY_DIRECTORY variable is used. "
-      "If no SOURCE is given, the CTEST_SOURCE_DIRECTORY variable is used. "
-      "The OPTIONS argument specifies command line arguments to pass to "
-      "the configuration tool. "
-      "The RETURN_VALUE option specifies a variable in which to store the "
-      "return value of the native build tool."
-      "\n"
-      CTEST_COMMAND_APPEND_OPTION_DOCS;
-    }
-
   cmTypeMacro(cmCTestConfigureCommand, cmCTestHandlerCommand);
 
 protected:
diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h
index 2fe762c45..11bb4112d 100644
--- a/Source/CTest/cmCTestCoverageCommand.h
+++ b/Source/CTest/cmCTestCoverageCommand.h
@@ -41,32 +41,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_coverage";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Collect coverage tool results.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_coverage([BUILD build_dir] [RETURN_VALUE res] [APPEND]\n"
-      "                 [LABELS label1 [label2 [...]]])\n"
-      "Perform the coverage of the given build directory and stores results "
-      "in Coverage.xml. The second argument is a variable that will hold "
-      "value."
-      "\n"
-      "The LABELS option filters the coverage report to include only "
-      "source files labeled with at least one of the labels specified."
-      "\n"
-      CTEST_COMMAND_APPEND_OPTION_DOCS;
-    }
-
   cmTypeMacro(cmCTestCoverageCommand, cmCTestHandlerCommand);
 
 protected:
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
index a763fe9e9..07e59a46c 100644
--- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
@@ -50,26 +50,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_empty_binary_directory";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "empties the binary directory";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_empty_binary_directory( directory )\n"
-      "Removes a binary directory. This command will perform some checks "
-      "prior to deleting the directory in an attempt to avoid malicious "
-      "or accidental directory deletion.";
-    }
-
   cmTypeMacro(cmCTestEmptyBinaryDirectoryCommand, cmCTestCommand);
 
 };
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
index 6db47aec8..b50170df1 100644
--- a/Source/CTest/cmCTestMemCheckCommand.h
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -43,40 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_memcheck";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Run tests with a dynamic analysis tool.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_memcheck([BUILD build_dir] [RETURN_VALUE res] [APPEND]\n"
-      "             [START start number] [END end number]\n"
-      "             [STRIDE stride number] [EXCLUDE exclude regex ]\n"
-      "             [INCLUDE include regex] \n"
-      "             [EXCLUDE_LABEL exclude regex] \n"
-      "             [INCLUDE_LABEL label regex] \n"
-      "             [PARALLEL_LEVEL level] )\n"
-      "Tests the given build directory and stores results in MemCheck.xml. "
-      "The second argument is a variable that will hold value. Optionally, "
-      "you can specify the starting test number START, the ending test number "
-      "END, the number of tests to skip between each test STRIDE, a regular "
-      "expression for tests to run INCLUDE, or a regular expression for tests "
-      "not to run EXCLUDE. EXCLUDE_LABEL and INCLUDE_LABEL are regular "
-      "expressions for tests to be included or excluded by the test "
-      "property LABEL. PARALLEL_LEVEL should be set to a positive number "
-      "representing the number of tests to be run in parallel."
-      "\n"
-      CTEST_COMMAND_APPEND_OPTION_DOCS;
-    }
-
   cmTypeMacro(cmCTestMemCheckCommand, cmCTestTestCommand);
 
 protected:
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.h b/Source/CTest/cmCTestReadCustomFilesCommand.h
index b984c84e9..9c0af8198 100644
--- a/Source/CTest/cmCTestReadCustomFilesCommand.h
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.h
@@ -48,25 +48,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_read_custom_files";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "read CTestCustom files.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_read_custom_files( directory ... )\n"
-      "Read all the CTestCustom.ctest or CTestCustom.cmake files from "
-      "the given directory.";
-    }
-
   cmTypeMacro(cmCTestReadCustomFilesCommand, cmCTestCommand);
 
 };
diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h
index 05e78991a..f34bd133c 100644
--- a/Source/CTest/cmCTestRunScriptCommand.h
+++ b/Source/CTest/cmCTestRunScriptCommand.h
@@ -49,30 +49,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_run_script";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "runs a ctest -S script";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_run_script([NEW_PROCESS] script_file_name script_file_name1 \n"
-      "              script_file_name2 ... [RETURN_VALUE var])\n"
-      "Runs a script or scripts much like if it was run from ctest -S. "
-      "If no argument is provided then the current script is run using "
-      "the current settings of the variables. If NEW_PROCESS is specified "
-      "then each script will be run in a separate process."
-      "If RETURN_VALUE is specified the return value of the last script "
-      "run will be put into var.";
-    }
-
   cmTypeMacro(cmCTestRunScriptCommand, cmCTestCommand);
 };
 
diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h
index 0f51ddfeb..c6baf1c57 100644
--- a/Source/CTest/cmCTestSleepCommand.h
+++ b/Source/CTest/cmCTestSleepCommand.h
@@ -49,26 +49,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_sleep";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "sleeps for some amount of time";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_sleep(<seconds>)\n"
-      "Sleep for given number of seconds.\n"
-      "  ctest_sleep(<time1> <duration> <time2>)\n"
-      "Sleep for t=(time1 + duration - time2) seconds if t > 0.";
-    }
-
   cmTypeMacro(cmCTestSleepCommand, cmCTestCommand);
 
 };
diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h
index 6be47703e..e5535c110 100644
--- a/Source/CTest/cmCTestStartCommand.h
+++ b/Source/CTest/cmCTestStartCommand.h
@@ -57,30 +57,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_start";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Starts the testing for a given model";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_start(Model [TRACK <track>] [APPEND] [source [binary]])\n"
-      "Starts the testing for a given model. The command should be called "
-      "after the binary directory is initialized. If the 'source' and "
-      "'binary' directory are not specified, it reads the "
-      "CTEST_SOURCE_DIRECTORY and CTEST_BINARY_DIRECTORY. If the track is "
-      "specified, the submissions will go to the specified track. "
-      "If APPEND is used, the existing TAG is used rather than "
-      "creating a new one based on the current time stamp.";
-    }
-
   cmTypeMacro(cmCTestStartCommand, cmCTestCommand);
 
 private:
diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h
index 53ee8754e..64c6cae26 100644
--- a/Source/CTest/cmCTestSubmitCommand.h
+++ b/Source/CTest/cmCTestSubmitCommand.h
@@ -50,44 +50,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_submit";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Submit results to a dashboard server.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_submit([PARTS ...] [FILES ...] [RETRY_COUNT count] "
-      "               [RETRY_DELAY delay][RETURN_VALUE res])\n"
-      "By default all available parts are submitted if no PARTS or FILES "
-      "are specified.  "
-      "The PARTS option lists a subset of parts to be submitted.  "
-      "Valid part names are:\n"
-      "  Start      = nothing\n"
-      "  Update     = ctest_update results, in Update.xml\n"
-      "  Configure  = ctest_configure results, in Configure.xml\n"
-      "  Build      = ctest_build results, in Build.xml\n"
-      "  Test       = ctest_test results, in Test.xml\n"
-      "  Coverage   = ctest_coverage results, in Coverage.xml\n"
-      "  MemCheck   = ctest_memcheck results, in DynamicAnalysis.xml\n"
-      "  Notes      = Files listed by CTEST_NOTES_FILES, in Notes.xml\n"
-      "  ExtraFiles = Files listed by CTEST_EXTRA_SUBMIT_FILES\n"
-      "  Submit     = nothing\n"
-      "The FILES option explicitly lists specific files to be submitted.  "
-      "Each individual file must exist at the time of the call.\n"
-      "The RETRY_DELAY option specifies how long in seconds to wait after "
-      "a timed-out submission before attempting to re-submit.\n"
-      "The RETRY_COUNT option specifies how many times to retry a timed-out "
-      "submission.\n";
-    }
-
   cmTypeMacro(cmCTestSubmitCommand, cmCTestHandlerCommand);
 
 protected:
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index 130cb6973..451ac99ff 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -41,45 +41,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_test";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Run tests in the project build tree.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_test([BUILD build_dir] [APPEND]\n"
-      "             [START start number] [END end number]\n"
-      "             [STRIDE stride number] [EXCLUDE exclude regex ]\n"
-      "             [INCLUDE include regex] [RETURN_VALUE res] \n"
-      "             [EXCLUDE_LABEL exclude regex] \n"
-      "             [INCLUDE_LABEL label regex] \n"
-      "             [PARALLEL_LEVEL level] \n"
-      "             [SCHEDULE_RANDOM on] \n"
-      "             [STOP_TIME time of day]) \n"
-      "Tests the given build directory and stores results in Test.xml. The "
-      "second argument is a variable that will hold value. Optionally, "
-      "you can specify the starting test number START, the ending test number "
-      "END, the number of tests to skip between each test STRIDE, a regular "
-      "expression for tests to run INCLUDE, or a regular expression for tests "
-      "to not run EXCLUDE. EXCLUDE_LABEL and INCLUDE_LABEL are regular "
-      "expression for test to be included or excluded by the test "
-      "property LABEL. PARALLEL_LEVEL should be set to a positive number "
-      "representing the number of tests to be run in parallel. "
-      "SCHEDULE_RANDOM will launch tests in a random order, and is "
-      "typically used to detect implicit test dependencies. STOP_TIME is the "
-      "time of day at which the tests should all stop running."
-      "\n"
-      CTEST_COMMAND_APPEND_OPTION_DOCS;
-    }
-
   cmTypeMacro(cmCTestTestCommand, cmCTestHandlerCommand);
 
 protected:
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index 09d343d7b..da24ae44d 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -61,10 +61,6 @@ public:
    */
   virtual const char* GetName() const { return "subdirs";}
 
-  // Unused methods
-  virtual const char* GetTerseDocumentation() const { return ""; }
-  virtual const char* GetFullDocumentation() const { return ""; }
-
   cmTypeMacro(cmCTestSubdirCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
@@ -162,10 +158,6 @@ public:
    */
   virtual const char* GetName() const { return "add_subdirectory";}
 
-  // Unused methods
-  virtual const char* GetTerseDocumentation() const { return ""; }
-  virtual const char* GetFullDocumentation() const { return ""; }
-
   cmTypeMacro(cmCTestAddSubdirectoryCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
@@ -252,10 +244,6 @@ public:
    */
   virtual const char* GetName() const { return "add_test";}
 
-  // Unused methods
-  virtual const char* GetTerseDocumentation() const { return ""; }
-  virtual const char* GetFullDocumentation() const { return ""; }
-
   cmTypeMacro(cmCTestAddTestCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
@@ -300,10 +288,6 @@ public:
    */
   virtual const char* GetName() const { return "set_tests_properties";}
 
-  // Unused methods
-  virtual const char* GetTerseDocumentation() const { return ""; }
-  virtual const char* GetFullDocumentation() const { return ""; }
-
   cmTypeMacro(cmCTestSetTestsPropertiesCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h
index c578fff6f..a785bd860 100644
--- a/Source/CTest/cmCTestUpdateCommand.h
+++ b/Source/CTest/cmCTestUpdateCommand.h
@@ -41,28 +41,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_update";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Update the work tree from version control.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_update([SOURCE source] [RETURN_VALUE res])\n"
-      "Updates the given source directory and stores results in Update.xml. "
-      "If no SOURCE is given, the CTEST_SOURCE_DIRECTORY variable is used. "
-      "The RETURN_VALUE option specifies a variable in which to store the "
-      "result, which is the number of files updated or -1 on error."
-      ;
-    }
-
   cmTypeMacro(cmCTestUpdateCommand, cmCTestHandlerCommand);
 
 protected:
diff --git a/Source/CTest/cmCTestUploadCommand.h b/Source/CTest/cmCTestUploadCommand.h
index 62f379f6d..e867fb687 100644
--- a/Source/CTest/cmCTestUploadCommand.h
+++ b/Source/CTest/cmCTestUploadCommand.h
@@ -45,25 +45,6 @@ public:
    */
   virtual const char* GetName() const { return "ctest_upload";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Upload files to a dashboard server.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  ctest_upload(FILES ...)\n"
-      "Pass a list of files to be sent along with the build results to "
-      "the dashboard server.\n";
-    }
-
   cmTypeMacro(cmCTestUploadCommand, cmCTestHandlerCommand);
 
 protected:
diff --git a/Source/cmAddCompileOptionsCommand.h b/Source/cmAddCompileOptionsCommand.h
index e9bbf2816..38ed2089f 100644
--- a/Source/cmAddCompileOptionsCommand.h
+++ b/Source/cmAddCompileOptionsCommand.h
@@ -13,7 +13,6 @@
 #define cmAddCompileOptionsCommand_h
 
 #include "cmCommand.h"
-#include "cmDocumentGeneratorExpressions.h"
 
 class cmAddCompileOptionsCommand : public cmCommand
 {
@@ -38,33 +37,6 @@ public:
    */
   virtual const char* GetName() const {return "add_compile_options";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Adds options to the compilation of source files.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_compile_options(<option> ...)\n"
-      "Adds options to the compiler command line for sources in the "
-      "current directory and below.  This command can be used to add any "
-      "options, but alternative commands exist to add preprocessor "
-      "definitions or include directories.  "
-      "See documentation of the directory and target COMPILE_OPTIONS "
-      "properties for details.  "
-      "Arguments to add_compile_options may use \"generator "
-      "expressions\" with the syntax \"$<...>\".  "
-      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      ;
-    }
-
   cmTypeMacro(cmAddCompileOptionsCommand, cmCommand);
 };
 
diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h
index 2504185b0..114957f18 100644
--- a/Source/cmAddCustomCommandCommand.h
+++ b/Source/cmAddCustomCommandCommand.h
@@ -13,7 +13,6 @@
 #define cmAddCustomCommandCommand_h
 
 #include "cmCommand.h"
-#include "cmDocumentGeneratorExpressions.h"
 
 /** \class cmAddCustomCommandCommand
  * \brief cmAddCustomCommandCommand defines a new command (rule) that can
@@ -44,141 +43,6 @@ public:
    */
   virtual const char* GetName() const {return "add_custom_command";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add a custom build rule to the generated build system.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "There are two main signatures for add_custom_command "
-      "The first signature is for adding a custom command "
-      "to produce an output.\n"
-      "  add_custom_command(OUTPUT output1 [output2 ...]\n"
-      "                     COMMAND command1 [ARGS] [args1...]\n"
-      "                     [COMMAND command2 [ARGS] [args2...] ...]\n"
-      "                     [MAIN_DEPENDENCY depend]\n"
-      "                     [DEPENDS [depends...]]\n"
-      "                     [IMPLICIT_DEPENDS <lang1> depend1\n"
-      "                                      [<lang2> depend2] ...]\n"
-      "                     [WORKING_DIRECTORY dir]\n"
-      "                     [COMMENT comment] [VERBATIM] [APPEND])\n"
-      "This defines a command to generate specified OUTPUT file(s).  "
-      "A target created in the same directory (CMakeLists.txt file) that "
-      "specifies any output of the custom command as a source file is given "
-      "a rule to generate the file using the command at build time.  "
-      "Do not list the output in more than one independent target that may "
-      "build in parallel or the two instances of the rule may conflict "
-      "(instead use add_custom_target to drive the command and make the "
-      "other targets depend on that one).  "
-      "If an output name is a relative path it will be interpreted "
-      "relative to the build tree directory corresponding to the current "
-      "source directory. "
-      "Note that MAIN_DEPENDENCY is completely optional and is "
-      "used as a suggestion to visual studio about where to hang the "
-      "custom command. In makefile terms this creates a new target in the "
-      "following form:\n"
-      "  OUTPUT: MAIN_DEPENDENCY DEPENDS\n"
-      "          COMMAND\n"
-      "If more than one command is specified they will be executed in order. "
-      "The optional ARGS argument is for backward compatibility and will be "
-      "ignored.\n"
-      "The second signature adds a custom command to a target "
-      "such as a library or executable. This is useful for "
-      "performing an operation before or after building the target. "
-      "The command becomes part of the target and will only execute "
-      "when the target itself is built.  If the target is already built,"
-      " the command will not execute.\n"
-      "  add_custom_command(TARGET target\n"
-      "                     PRE_BUILD | PRE_LINK | POST_BUILD\n"
-      "                     COMMAND command1 [ARGS] [args1...]\n"
-      "                     [COMMAND command2 [ARGS] [args2...] ...]\n"
-      "                     [WORKING_DIRECTORY dir]\n"
-      "                     [COMMENT comment] [VERBATIM])\n"
-      "This defines a new command that will be associated with "
-      "building the specified target. When the command will "
-      "happen is determined by which of the following is specified:\n"
-      "  PRE_BUILD - run before all other dependencies\n"
-      "  PRE_LINK - run after other dependencies\n"
-      "  POST_BUILD - run after the target has been built\n"
-      "Note that the PRE_BUILD option is only supported on Visual "
-      "Studio 7 or later. For all other generators PRE_BUILD "
-      "will be treated as PRE_LINK.\n"
-      "If WORKING_DIRECTORY is specified the command will be executed "
-      "in the directory given. "
-      "If it is a relative path it will be interpreted relative to the "
-      "build tree directory corresponding to the current source directory. "
-      "If COMMENT is set, the value will be displayed as a "
-      "message before the commands are executed at build time. "
-      "If APPEND is specified the COMMAND and DEPENDS option values "
-      "are appended to the custom command for the first output specified. "
-      "There must have already been a previous call to this command with "
-      "the same output. The COMMENT, WORKING_DIRECTORY, and MAIN_DEPENDENCY "
-      "options are currently ignored when APPEND is given, "
-      "but may be used in the future."
-      "\n"
-      "If VERBATIM is given then all arguments to the commands will be "
-      "escaped properly for the build tool so that the invoked command "
-      "receives each argument unchanged.  "
-      "Note that one level of escapes is still used by the CMake language "
-      "processor before add_custom_command even sees the arguments. "
-      "Use of VERBATIM is recommended as it enables correct behavior. "
-      "When VERBATIM is not given the behavior is platform specific because "
-      "there is no protection of tool-specific special characters."
-      "\n"
-      "If the output of the custom command is not actually "
-      "created as a file on disk it should be marked as SYMBOLIC with "
-      "SET_SOURCE_FILES_PROPERTIES.\n"
-
-      "The IMPLICIT_DEPENDS option requests scanning of implicit "
-      "dependencies of an input file.  The language given specifies the "
-      "programming language whose corresponding dependency scanner should "
-      "be used.  Currently only C and CXX language scanners are supported. "
-      "The language has to be specified for every file in the "
-      "IMPLICIT_DEPENDS list. "
-      "Dependencies discovered from the scanning are added to those of "
-      "the custom command at build time.  Note that the IMPLICIT_DEPENDS "
-      "option is currently supported only for Makefile generators and "
-      "will be ignored by other generators."
-      "\n"
-      "If COMMAND specifies an executable target (created by "
-      "ADD_EXECUTABLE) it will automatically be replaced by the location "
-      "of the executable created at build time.  Additionally a "
-      "target-level dependency will be added so that the executable target "
-      "will be built before any target using this custom command.  However "
-      "this does NOT add a file-level dependency that would cause the "
-      "custom command to re-run whenever the executable is recompiled."
-      "\n"
-      "Arguments to COMMAND may use \"generator expressions\" with the "
-      "syntax \"$<...>\".  "
-      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      "References to target names in generator expressions imply "
-      "target-level dependencies, but NOT file-level dependencies.  "
-      "List target names with the DEPENDS option to add file dependencies."
-      "\n"
-      "The DEPENDS option specifies files on which the command depends.  "
-      "If any dependency is an OUTPUT of another custom command in the "
-      "same directory (CMakeLists.txt file) CMake automatically brings the "
-      "other custom command into the target in which this command is built.  "
-      "If DEPENDS is not specified the command will run whenever the OUTPUT "
-      "is missing; if the command does not actually create the OUTPUT then "
-      "the rule will always run.  "
-      "If DEPENDS specifies any target (created by an ADD_* command) "
-      "a target-level dependency is created to make sure the target is "
-      "built before any target using this custom command.  Additionally, "
-      "if the target is an executable or library a file-level dependency "
-      "is created to cause the custom command to re-run whenever the target "
-      "is recompiled.\n"
-      ;
-    }
-
   cmTypeMacro(cmAddCustomCommandCommand, cmCommand);
 protected:
   bool CheckOutputs(const std::vector<std::string>& outputs);
diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h
index d4ed450f0..d0fcdad77 100644
--- a/Source/cmAddCustomTargetCommand.h
+++ b/Source/cmAddCustomTargetCommand.h
@@ -45,63 +45,6 @@ public:
   virtual const char* GetName() const
     {return "add_custom_target";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add a target with no output so it will always be built.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_custom_target(Name [ALL] [command1 [args1...]]\n"
-      "                    [COMMAND command2 [args2...] ...]\n"
-      "                    [DEPENDS depend depend depend ... ]\n"
-      "                    [WORKING_DIRECTORY dir]\n"
-      "                    [COMMENT comment] [VERBATIM]\n"
-      "                    [SOURCES src1 [src2...]])\n"
-      "Adds a target with the given name that executes the given commands. "
-      "The target has no output file and is ALWAYS CONSIDERED OUT OF DATE "
-      "even if the commands try to create a file with the name of the "
-      "target. Use ADD_CUSTOM_COMMAND to generate a file with dependencies. "
-      "By default nothing depends on the custom target. Use "
-      "ADD_DEPENDENCIES to add dependencies to or from other targets. "
-      "If the ALL option is specified "
-      "it indicates that this target should be added to the default build "
-      "target so that it will be run every time "
-      "(the command cannot be called ALL). "
-      "The command and arguments are optional and if not specified an "
-      "empty target will be created. "
-      "If WORKING_DIRECTORY is set, then the command will be run in that "
-      "directory. "
-      "If it is a relative path it will be interpreted relative to the "
-      "build tree directory corresponding to the current source directory. "
-      "If COMMENT is set, the value will be displayed as a "
-      "message before the commands are executed at build time. "
-      "Dependencies listed with the DEPENDS argument may reference files "
-      "and outputs of custom commands created with add_custom_command() in "
-      "the same directory (CMakeLists.txt file).\n"
-      "If VERBATIM is given then all arguments to the commands will be "
-      "escaped properly for the build tool so that the invoked command "
-      "receives each argument unchanged.  "
-      "Note that one level of escapes is still used by the CMake language "
-      "processor before add_custom_target even sees the arguments. "
-      "Use of VERBATIM is recommended as it enables correct behavior. "
-      "When VERBATIM is not given the behavior is platform specific because "
-      "there is no protection of tool-specific special characters."
-      "\n"
-      "The SOURCES option specifies additional source files to be included "
-      "in the custom target.  "
-      "Specified source files will be added to IDE project files for "
-      "convenience in editing even if they have not build rules."
-      ;
-    }
-
   cmTypeMacro(cmAddCustomTargetCommand, cmCommand);
 };
 
diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h
index ff2c4a038..d05f1875e 100644
--- a/Source/cmAddDefinitionsCommand.h
+++ b/Source/cmAddDefinitionsCommand.h
@@ -43,35 +43,6 @@ public:
    */
   virtual const char* GetName() const {return "add_definitions";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Adds -D define flags to the compilation of source files.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_definitions(-DFOO -DBAR ...)\n"
-      "Adds flags to the compiler command line for sources in the current "
-      "directory and below.  This command can be used to add any flags, "
-      "but it was originally intended to add preprocessor definitions.  "
-      "Flags beginning in -D or /D that look like preprocessor definitions "
-      "are automatically added to the COMPILE_DEFINITIONS property for "
-      "the current directory.  Definitions with non-trivial values may be "
-      "left in the set of flags instead of being converted for reasons of "
-      "backwards compatibility.  See documentation of the directory, "
-      "target, and source file COMPILE_DEFINITIONS properties for details "
-      "on adding preprocessor definitions to specific scopes and "
-      "configurations."
-      ;
-    }
-
   cmTypeMacro(cmAddDefinitionsCommand, cmCommand);
 };
 
diff --git a/Source/cmAddDependenciesCommand.h b/Source/cmAddDependenciesCommand.h
index 148fd99de..247cc5465 100644
--- a/Source/cmAddDependenciesCommand.h
+++ b/Source/cmAddDependenciesCommand.h
@@ -42,35 +42,6 @@ public:
    */
   virtual const char* GetName() const { return "add_dependencies";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add a dependency between top-level targets.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_dependencies(<target> [<target-dependency>]...)\n"
-      "Make a top-level <target> depend on other top-level targets to "
-      "ensure that they build before <target> does.  "
-      "A top-level target is one created by ADD_EXECUTABLE, ADD_LIBRARY, "
-      "or ADD_CUSTOM_TARGET.  "
-      "Dependencies added to an IMPORTED target are followed transitively "
-      "in its place since the target itself does not build.  "
-      "\n"
-      "See the DEPENDS option of ADD_CUSTOM_TARGET "
-      "and ADD_CUSTOM_COMMAND for adding file-level dependencies in custom "
-      "rules.  See the OBJECT_DEPENDS option in "
-      "SET_SOURCE_FILES_PROPERTIES to add file-level dependencies to object "
-      "files.";
-    }
-
   cmTypeMacro(cmAddDependenciesCommand, cmCommand);
 };
 
diff --git a/Source/cmAddExecutableCommand.h b/Source/cmAddExecutableCommand.h
index 2774ce841..30ecce3df 100644
--- a/Source/cmAddExecutableCommand.h
+++ b/Source/cmAddExecutableCommand.h
@@ -43,86 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "add_executable";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Add an executable to the project using the specified source files.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_executable(<name> [WIN32] [MACOSX_BUNDLE]\n"
-      "                 [EXCLUDE_FROM_ALL]\n"
-      "                 source1 source2 ... sourceN)\n"
-      "Adds an executable target called <name> to be built from the "
-      "source files listed in the command invocation.  "
-      "The <name> corresponds to the logical target name and must be "
-      "globally unique within a project.  "
-      "The actual file name of the executable built is constructed based on "
-      "conventions of the native platform "
-      "(such as <name>.exe or just <name>).  "
-      "\n"
-      "By default the executable file will be created in the build tree "
-      "directory corresponding to the source tree directory in which "
-      "the command was invoked.  "
-      "See documentation of the RUNTIME_OUTPUT_DIRECTORY "
-      "target property to change this location.  "
-      "See documentation of the OUTPUT_NAME target property to change "
-      "the <name> part of the final file name.  "
-      "\n"
-      "If WIN32 is given the property WIN32_EXECUTABLE will be set on the "
-      "target created.  "
-      "See documentation of that target property for details."
-      "\n"
-      "If MACOSX_BUNDLE is given the corresponding property will be "
-      "set on the created target.  "
-      "See documentation of the MACOSX_BUNDLE target property for details."
-      "\n"
-      "If EXCLUDE_FROM_ALL is given the corresponding property will be "
-      "set on the created target.  "
-      "See documentation of the EXCLUDE_FROM_ALL target property for "
-      "details."
-      "\n"
-      "The add_executable command can also create IMPORTED executable "
-      "targets using this signature:\n"
-      "  add_executable(<name> IMPORTED [GLOBAL])\n"
-      "An IMPORTED executable target references an executable file located "
-      "outside the project.  "
-      "No rules are generated to build it.  "
-      "The target name has scope in the directory in which it is created "
-      "and below, but the GLOBAL option extends visibility.  "
-      "It may be referenced like any target built within the project.  "
-      "IMPORTED executables are useful for convenient reference from "
-      "commands like add_custom_command.  "
-      "Details about the imported executable are specified by setting "
-      "properties whose names begin in \"IMPORTED_\".  "
-      "The most important such property is IMPORTED_LOCATION "
-      "(and its per-configuration version IMPORTED_LOCATION_<CONFIG>) "
-      "which specifies the location of the main executable file on disk.  "
-      "See documentation of the IMPORTED_* properties for more information."
-      "\n"
-      "The signature\n"
-      "  add_executable(<name> ALIAS <target>)\n"
-      "creates an alias, such that <name> can be used to refer to <target> "
-      "in subsequent commands.  The <name> does not appear in the generated "
-      "buildsystem as a make target.  The <target> may not be an IMPORTED "
-      "target or an ALIAS.  Alias targets can be used as linkable targets, "
-      "targets to read properties from, executables for custom commands and "
-      "custom targets.  They can also be tested for existance with the "
-      "regular if(TARGET) subcommand.  The <name> may not be used to modify "
-      "properties of <target>, that is, it may not be used as the operand of "
-      "set_property, set_target_properties, target_link_libraries etc.  An "
-      "ALIAS target may not be installed of exported."
-      ;
-    }
-
   cmTypeMacro(cmAddExecutableCommand, cmCommand);
 };
 
diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h
index 64d048b27..10010439f 100644
--- a/Source/cmAddLibraryCommand.h
+++ b/Source/cmAddLibraryCommand.h
@@ -43,127 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "add_library";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add a library to the project using the specified source files.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_library(<name> [STATIC | SHARED | MODULE]\n"
-      "              [EXCLUDE_FROM_ALL]\n"
-      "              source1 source2 ... sourceN)\n"
-      "Adds a library target called <name> to be built from the "
-      "source files listed in the command invocation.  "
-      "The <name> corresponds to the logical target name and must be "
-      "globally unique within a project.  "
-      "The actual file name of the library built is constructed based on "
-      "conventions of the native platform "
-      "(such as lib<name>.a or <name>.lib)."
-      "\n"
-      "STATIC, SHARED, or MODULE may be given to specify the type of library "
-      "to be created.  "
-      "STATIC libraries are archives of object files for use when linking "
-      "other targets.  "
-      "SHARED libraries are linked dynamically and loaded at runtime.  "
-      "MODULE libraries are plugins that are not linked into other targets "
-      "but may be loaded dynamically at runtime using dlopen-like "
-      "functionality.  "
-      "If no type is given explicitly the type is STATIC or SHARED based "
-      "on whether the current value of the variable BUILD_SHARED_LIBS is "
-      "true.  "
-      "For SHARED and MODULE libraries the POSITION_INDEPENDENT_CODE "
-      "target property is set to TRUE automatically."
-      "\n"
-      "By default the library file will be created in the build tree "
-      "directory corresponding to the source tree directory in which "
-      "the command was invoked.  "
-      "See documentation of the ARCHIVE_OUTPUT_DIRECTORY, "
-      "LIBRARY_OUTPUT_DIRECTORY, and RUNTIME_OUTPUT_DIRECTORY "
-      "target properties to change this location.  "
-      "See documentation of the OUTPUT_NAME target property to change "
-      "the <name> part of the final file name.  "
-      "\n"
-      "If EXCLUDE_FROM_ALL is given the corresponding property will be "
-      "set on the created target.  "
-      "See documentation of the EXCLUDE_FROM_ALL target property for "
-      "details."
-      "\n"
-      "The add_library command can also create IMPORTED library "
-      "targets using this signature:\n"
-      "  add_library(<name> <SHARED|STATIC|MODULE|UNKNOWN> IMPORTED\n"
-      "              [GLOBAL])\n"
-      "An IMPORTED library target references a library file located "
-      "outside the project.  "
-      "No rules are generated to build it.  "
-      "The target name has scope in the directory in which it is created "
-      "and below, but the GLOBAL option extends visibility.  "
-      "It may be referenced like any target built within the project.  "
-      "IMPORTED libraries are useful for convenient reference from "
-      "commands like target_link_libraries.  "
-      "Details about the imported library are specified by setting "
-      "properties whose names begin in \"IMPORTED_\".  "
-      "The most important such property is IMPORTED_LOCATION "
-      "(and its per-configuration version IMPORTED_LOCATION_<CONFIG>) "
-      "which specifies the location of the main library file on disk.  "
-      "See documentation of the IMPORTED_* properties for more information."
-      "\n"
-      "The signature\n"
-      "  add_library(<name> OBJECT <src>...)\n"
-      "creates a special \"object library\" target.  "
-      "An object library compiles source files but does not archive or link "
-      "their object files into a library.  "
-      "Instead other targets created by add_library or add_executable may "
-      "reference the objects using an expression of the form "
-      "$<TARGET_OBJECTS:objlib> as a source, where \"objlib\" is the "
-      "object library name.  "
-      "For example:\n"
-      "  add_library(... $<TARGET_OBJECTS:objlib> ...)\n"
-      "  add_executable(... $<TARGET_OBJECTS:objlib> ...)\n"
-      "will include objlib's object files in a library and an executable "
-      "along with those compiled from their own sources.  "
-      "Object libraries may contain only sources (and headers) that compile "
-      "to object files.  "
-      "They may contain custom commands generating such sources, but not "
-      "PRE_BUILD, PRE_LINK, or POST_BUILD commands.  "
-      "Object libraries cannot be imported, exported, installed, or linked."
-      "  "
-      "Some native build systems may not like targets that have only "
-      "object files, so consider adding at least one real source file "
-      "to any target that references $<TARGET_OBJECTS:objlib>."
-      "\n"
-      "The signature\n"
-      "  add_library(<name> ALIAS <target>)\n"
-      "creates an alias, such that <name> can be used to refer to <target> "
-      "in subsequent commands.  The <name> does not appear in the generated "
-      "buildsystem as a make target.  The <target> may not be an IMPORTED "
-      "target or an ALIAS.  Alias targets can be used as linkable targets, "
-      "targets to read properties from.  They can also be tested for "
-      "existance with the "
-      "regular if(TARGET) subcommand.  The <name> may not be used to modify "
-      "properties of <target>, that is, it may not be used as the operand of "
-      "set_property, set_target_properties, target_link_libraries etc.  An "
-      "ALIAS target may not be installed of exported."
-      "\n"
-      "The signature\n"
-      "  add_library(<name> INTERFACE)\n"
-      "creates an interface target. An interface target does not directly "
-      "create build output, though it may have properties set on it and it "
-      "may be installed, exported and imported.  Typically the INTERFACE_* "
-      "properties are populated on the interface target using the "
-      "set_property(), target_link_libraries(), target_include_directories() "
-      "and target_compile_defintions() commands, and then it is used as an "
-      "argument to target_link_libraries() like any other target."
-      ;
-    }
-
   cmTypeMacro(cmAddLibraryCommand, cmCommand);
 };
 
diff --git a/Source/cmAddSubDirectoryCommand.h b/Source/cmAddSubDirectoryCommand.h
index e7f907c3f..1e5b1abdd 100644
--- a/Source/cmAddSubDirectoryCommand.h
+++ b/Source/cmAddSubDirectoryCommand.h
@@ -44,53 +44,6 @@ public:
    */
   virtual const char* GetName() const { return "add_subdirectory";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add a subdirectory to the build.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_subdirectory(source_dir [binary_dir] \n"
-      "                   [EXCLUDE_FROM_ALL])\n"
-      "Add a subdirectory to the build. The source_dir specifies the "
-      "directory in which the source CMakeLists.txt and code files are "
-      "located. If it is a relative "
-      "path it will be evaluated with respect to the current "
-      "directory (the typical usage), but it may also be an absolute path. "
-      "The binary_dir specifies the directory in which to place the output "
-      "files. If it is a relative path it will be evaluated with respect "
-      "to the current output directory, but it may also be an absolute "
-      "path. If binary_dir is not specified, the value of source_dir, "
-      "before expanding any relative path, will be used (the typical usage). "
-      "The CMakeLists.txt file in the specified source directory will "
-      "be processed immediately by CMake before processing in the current "
-      "input file continues beyond this command.\n"
-
-      "If the EXCLUDE_FROM_ALL argument is provided then targets in the "
-      "subdirectory will not be included in the ALL target of the parent "
-      "directory by default, and will be excluded from IDE project files.  "
-      "Users must explicitly build targets in the subdirectory.  "
-      "This is meant for use when the subdirectory contains a separate part "
-      "of the project that is useful but not necessary, such as a set of "
-      "examples.  "
-      "Typically the subdirectory should contain its own project() command "
-      "invocation so that a full build system will be generated in the "
-      "subdirectory (such as a VS IDE solution file).  "
-      "Note that inter-target dependencies supercede this exclusion.  "
-      "If a target built by the parent project depends on a target in the "
-      "subdirectory, the dependee target will be included in the parent "
-      "project build system to satisfy the dependency."
-      ;
-    }
-
   cmTypeMacro(cmAddSubDirectoryCommand, cmCommand);
 };
 
diff --git a/Source/cmAddTestCommand.h b/Source/cmAddTestCommand.h
index ce98aaad5..9173454dc 100644
--- a/Source/cmAddTestCommand.h
+++ b/Source/cmAddTestCommand.h
@@ -13,7 +13,6 @@
 #define cmAddTestCommand_h
 
 #include "cmCommand.h"
-#include "cmDocumentGeneratorExpressions.h"
 
 /** \class cmAddTestCommand
  * \brief Add a test to the lists of tests to run.
@@ -43,59 +42,6 @@ public:
    */
   virtual const char* GetName() const { return "add_test";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add a test to the project with the specified arguments.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  add_test(testname Exename arg1 arg2 ... )\n"
-      "If the ENABLE_TESTING command has been run, this command adds a "
-      "test target to the current directory. If ENABLE_TESTING has not "
-      "been run, this command does nothing.  "
-      "The tests are run by the testing subsystem by executing Exename "
-      "with the specified arguments.  Exename can be either an executable "
-      "built by this project or an arbitrary executable on the "
-      "system (like tclsh).  The test will be run with the current working "
-      "directory set to the CMakeList.txt files corresponding directory "
-      "in the binary tree.  Tests added using this signature do not support "
-      "generator expressions.\n"
-      "\n"
-      "  add_test(NAME <name> [CONFIGURATIONS [Debug|Release|...]]\n"
-      "           [WORKING_DIRECTORY dir]\n"
-      "           COMMAND <command> [arg1 [arg2 ...]])\n"
-      "Add a test called <name>.  "
-      "The test name may not contain spaces, quotes, or other characters "
-      "special in CMake syntax.  "
-      "If COMMAND specifies an executable target (created by "
-      "add_executable) it will automatically be replaced by the location "
-      "of the executable created at build time.  "
-      "If a CONFIGURATIONS option is given then the test will be executed "
-      "only when testing under one of the named configurations.  "
-      "If a WORKING_DIRECTORY option is given then the test will be executed "
-      "in the given directory."
-      "\n"
-      "Arguments after COMMAND may use \"generator expressions\" with the "
-      "syntax \"$<...>\".  "
-      CM_DOCUMENT_ADD_TEST_GENERATOR_EXPRESSIONS
-      "Example usage:\n"
-      "  add_test(NAME mytest\n"
-      "           COMMAND testDriver --config $<CONFIGURATION>\n"
-      "                              --exe $<TARGET_FILE:myexe>)\n"
-      "This creates a test \"mytest\" whose command runs a testDriver "
-      "tool passing the configuration name and the full path to the "
-      "executable file produced by target \"myexe\"."
-      ;
-    }
-
   cmTypeMacro(cmAddTestCommand, cmCommand);
 private:
   bool HandleNameMode(std::vector<std::string> const& args);
diff --git a/Source/cmAuxSourceDirectoryCommand.h b/Source/cmAuxSourceDirectoryCommand.h
index 8a70f19cb..8b5fa8ab1 100644
--- a/Source/cmAuxSourceDirectoryCommand.h
+++ b/Source/cmAuxSourceDirectoryCommand.h
@@ -46,38 +46,6 @@ public:
    */
   virtual const char* GetName() const { return "aux_source_directory";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Find all source files in a directory.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  aux_source_directory(<dir> <variable>)\n"
-      "Collects the names of all the source files in the specified "
-      "directory and stores the list in the <variable> provided.  This "
-      "command is intended to be used by projects that use explicit "
-      "template instantiation.  Template instantiation files can be "
-      "stored in a \"Templates\" subdirectory and collected automatically "
-      "using this command to avoid manually listing all instantiations.\n"
-      "It is tempting to use this command to avoid writing the list of "
-      "source files for a library or executable target.  While this seems "
-      "to work, there is no way for CMake to generate a build system that "
-      "knows when a new source file has been added.  Normally the "
-      "generated build system knows when it needs to rerun CMake because "
-      "the CMakeLists.txt file is modified to add a new source.  When the "
-      "source is just added to the directory without modifying this file, "
-      "one would have to manually rerun CMake to generate a build system "
-      "incorporating the new file.";
-    }
-
   cmTypeMacro(cmAuxSourceDirectoryCommand, cmCommand);
 };
 
diff --git a/Source/cmBreakCommand.h b/Source/cmBreakCommand.h
index 17f57cfa1..52f0e9c47 100644
--- a/Source/cmBreakCommand.h
+++ b/Source/cmBreakCommand.h
@@ -47,24 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "break";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Break from an enclosing foreach or while loop.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  break()\n"
-      "Breaks from an enclosing foreach loop or while loop";
-    }
-
   cmTypeMacro(cmBreakCommand, cmCommand);
 };
 
diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h
index 1bab4536e..21606555e 100644
--- a/Source/cmBuildCommand.h
+++ b/Source/cmBuildCommand.h
@@ -52,45 +52,6 @@ public:
    */
   virtual const char* GetName() const {return "build_command";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get the command line to build this project.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  build_command(<variable>\n"
-      "                [CONFIGURATION <config>]\n"
-      "                [PROJECT_NAME <projname>]\n"
-      "                [TARGET <target>])\n"
-      "Sets the given <variable> to a string containing the command line "
-      "for building one configuration of a target in a project using the "
-      "build tool appropriate for the current CMAKE_GENERATOR.\n"
-      "If CONFIGURATION is omitted, CMake chooses a reasonable default "
-      "value  for multi-configuration generators.  CONFIGURATION is "
-      "ignored for single-configuration generators.\n"
-      "If PROJECT_NAME is omitted, the resulting command line will build "
-      "the top level PROJECT in the current build tree.\n"
-      "If TARGET is omitted, the resulting command line will build "
-      "everything, effectively using build target 'all' or 'ALL_BUILD'.\n"
-      "  build_command(<cachevariable> <makecommand>)\n"
-      "This second signature is deprecated, but still available for "
-      "backwards compatibility. Use the first signature instead.\n"
-      "Sets the given <cachevariable> to a string containing the command "
-      "to build this project from the root of the build tree using "
-      "the build tool given by <makecommand>.  <makecommand> should be "
-      "the full path to msdev, devenv, nmake, make or one of the end "
-      "user build tools."
-      ;
-    }
-
   cmTypeMacro(cmBuildCommand, cmCommand);
 };
 
diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h
index 26505a260..faeb3c0eb 100644
--- a/Source/cmBuildNameCommand.h
+++ b/Source/cmBuildNameCommand.h
@@ -47,27 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "build_name";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Deprecated.  Use ${CMAKE_SYSTEM} and ${CMAKE_CXX_COMPILER} instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  build_name(variable)\n"
-      "Sets the specified variable to a string representing the platform "
-      "and compiler settings.  These values are now available through the "
-      "CMAKE_SYSTEM and CMAKE_CXX_COMPILER variables.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmCMakeHostSystemInformationCommand.h b/Source/cmCMakeHostSystemInformationCommand.h
index d1b8700ff..27ba638e8 100644
--- a/Source/cmCMakeHostSystemInformationCommand.h
+++ b/Source/cmCMakeHostSystemInformationCommand.h
@@ -53,41 +53,6 @@ public:
     return "cmake_host_system_information";
     }
 
-   /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Query host system specific information.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-    "  cmake_host_system_information(RESULT <variable> QUERY <key> ...)\n"
-    "Queries system information of the host system on which cmake runs. "
-    "One or more <key> can be provided to "
-    "select the information to be queried. "
-    "The list of queried values is stored in <variable>.\n"
-    "<key> can be one of the following values:\n"
-    "  NUMBER_OF_LOGICAL_CORES   = Number of logical cores.\n"
-    "  NUMBER_OF_PHYSICAL_CORES  = Number of physical cores.\n"
-    "  HOSTNAME                  = Hostname.\n"
-    "  FQDN                      = Fully qualified domain name.\n"
-    "  TOTAL_VIRTUAL_MEMORY      = "
-      "Total virtual memory in megabytes.\n"
-    "  AVAILABLE_VIRTUAL_MEMORY  = "
-      "Available virtual memory in megabytes.\n"
-    "  TOTAL_PHYSICAL_MEMORY     = "
-      "Total physical memory in megabytes.\n"
-    "  AVAILABLE_PHYSICAL_MEMORY = "
-      "Available physical memory in megabytes.\n"
-    ;
-    }
-
   cmTypeMacro(cmCMakeHostSystemInformationCommand, cmCommand);
 
 private:
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
index acf28298b..0cdd4c523 100644
--- a/Source/cmCMakeMinimumRequired.h
+++ b/Source/cmCMakeMinimumRequired.h
@@ -47,37 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "cmake_minimum_required";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set the minimum required version of cmake for a project.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  cmake_minimum_required(VERSION major[.minor[.patch[.tweak]]]\n"
-      "                         [FATAL_ERROR])\n"
-      "If the current version of CMake is lower than that required "
-      "it will stop processing the project and report an error.  "
-      "When a version higher than 2.4 is specified the command implicitly "
-      "invokes\n"
-      "  cmake_policy(VERSION major[.minor[.patch[.tweak]]])\n"
-      "which sets the cmake policy version level to the version specified.  "
-      "When version 2.4 or lower is given the command implicitly invokes\n"
-      "  cmake_policy(VERSION 2.4)\n"
-      "which enables compatibility features for CMake 2.4 and lower.\n"
-      "The FATAL_ERROR option is accepted but ignored by CMake 2.6 "
-      "and higher.  "
-      "It should be specified so CMake versions 2.4 and lower fail with an "
-      "error instead of just a warning.";
-    }
-
   cmTypeMacro(cmCMakeMinimumRequired, cmCommand);
 
 private:
diff --git a/Source/cmCMakePolicyCommand.h b/Source/cmCMakePolicyCommand.h
index 4f9faa168..7e3f4e6e2 100644
--- a/Source/cmCMakePolicyCommand.h
+++ b/Source/cmCMakePolicyCommand.h
@@ -48,88 +48,6 @@ public:
    */
   virtual const char* GetName() const {return "cmake_policy";}
 
- /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Manage CMake Policy settings.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "As CMake evolves it is sometimes necessary to change existing "
-      "behavior in order to fix bugs or improve implementations of "
-      "existing features.  "
-      "The CMake Policy mechanism is designed to help keep existing projects "
-      "building as new versions of CMake introduce changes in behavior.  "
-      "Each new policy (behavioral change) is given an identifier of "
-      "the form \"CMP<NNNN>\" where \"<NNNN>\" is an integer index.  "
-      "Documentation associated with each policy describes the OLD and NEW "
-      "behavior and the reason the policy was introduced.  "
-      "Projects may set each policy to select the desired behavior.  "
-      "When CMake needs to know which behavior to use it checks for "
-      "a setting specified by the project.  "
-      "If no setting is available the OLD behavior is assumed and a warning "
-      "is produced requesting that the policy be set.\n"
-      "The cmake_policy command is used to set policies to OLD or NEW "
-      "behavior.  "
-      "While setting policies individually is supported, we encourage "
-      "projects to set policies based on CMake versions.\n"
-      "  cmake_policy(VERSION major.minor[.patch[.tweak]])\n"
-      "Specify that the current CMake list file is written for the "
-      "given version of CMake.  "
-      "All policies introduced in the specified version or earlier "
-      "will be set to use NEW behavior.  "
-      "All policies introduced after the specified version will be unset "
-      "(unless variable CMAKE_POLICY_DEFAULT_CMP<NNNN> sets a default).  "
-      "This effectively requests behavior preferred as of a given CMake "
-      "version and tells newer CMake versions to warn about their new "
-      "policies.  "
-      "The policy version specified must be at least 2.4 or the command "
-      "will report an error.  "
-      "In order to get compatibility features supporting versions earlier "
-      "than 2.4 see documentation of policy CMP0001."
-      "\n"
-      "  cmake_policy(SET CMP<NNNN> NEW)\n"
-      "  cmake_policy(SET CMP<NNNN> OLD)\n"
-      "Tell CMake to use the OLD or NEW behavior for a given policy.  "
-      "Projects depending on the old behavior of a given policy may "
-      "silence a policy warning by setting the policy state to OLD.  "
-      "Alternatively one may fix the project to work with the new behavior "
-      "and set the policy state to NEW."
-      "\n"
-      "  cmake_policy(GET CMP<NNNN> <variable>)\n"
-      "Check whether a given policy is set to OLD or NEW behavior.  "
-      "The output variable value will be \"OLD\" or \"NEW\" if the "
-      "policy is set, and empty otherwise."
-      "\n"
-      "CMake keeps policy settings on a stack, so changes made by the "
-      "cmake_policy command affect only the top of the stack.  "
-      "A new entry on the policy stack is managed automatically for each "
-      "subdirectory to protect its parents and siblings.  "
-      "CMake also manages a new entry for scripts loaded by include() and "
-      "find_package() commands except when invoked with the NO_POLICY_SCOPE "
-      "option (see also policy CMP0011).  "
-      "The cmake_policy command provides an interface to manage custom "
-      "entries on the policy stack:\n"
-      "  cmake_policy(PUSH)\n"
-      "  cmake_policy(POP)\n"
-      "Each PUSH must have a matching POP to erase any changes.  "
-      "This is useful to make temporary changes to policy settings."
-      "\n"
-      "Functions and macros record policy settings when they are created "
-      "and use the pre-record policies when they are invoked.  "
-      "If the function or macro implementation sets policies, the changes "
-      "automatically propagate up through callers until they reach the "
-      "closest nested policy stack entry."
-      ;
-    }
-
   cmTypeMacro(cmCMakePolicyCommand, cmCommand);
 private:
   bool HandleSetMode(std::vector<std::string> const& args);
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index 49f451b58..83184a0e4 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -126,16 +126,6 @@ public:
    */
   virtual const char* GetName() const = 0;
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const = 0;
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const = 0;
-
   /**
    * Enable the command.
    */
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
index 0393ecfa9..605b58b03 100644
--- a/Source/cmConfigureFileCommand.h
+++ b/Source/cmConfigureFileCommand.h
@@ -41,61 +41,6 @@ public:
    */
   virtual bool IsScriptable() const { return true; }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Copy a file to another location and modify its contents.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  configure_file(<input> <output>\n"
-        "                 [COPYONLY] [ESCAPE_QUOTES] [@ONLY] \n"
-        "                 [NEWLINE_STYLE [UNIX|DOS|WIN32|LF|CRLF] ])\n"
-        "Copies a file <input> to file <output> and substitutes variable "
-        "values referenced in the file content.  "
-        "If <input> is a relative path it is evaluated with respect to "
-        "the current source directory.  "
-        "The <input> must be a file, not a directory.  "
-        "If <output> is a relative path it is evaluated with respect to "
-        "the current binary directory.  "
-        "If <output> names an existing directory the input file is placed "
-        "in that directory with its original name.  "
-        "\n"
-        "If the <input> file is modified the build system will re-run CMake "
-        "to re-configure the file and generate the build system again."
-        "\n"
-        "This command replaces any variables in the input file referenced as "
-        "${VAR} or @VAR@ with their values as determined by CMake.  If a "
-        "variable is not defined, it will be replaced with nothing.  "
-        "If COPYONLY is specified, then no variable expansion will take "
-        "place.  If ESCAPE_QUOTES is specified then any substituted quotes "
-        "will be C-style escaped.  "
-        "The file will be configured with the current values of CMake "
-        "variables. If @ONLY is specified, only variables "
-        "of the form @VAR@ will be replaced and ${VAR} will be ignored.  "
-        "This is useful for configuring scripts that use ${VAR}."
-        "\n"
-        "Input file lines of the form \"#cmakedefine VAR ...\" "
-        "will be replaced with either \"#define VAR ...\" or "
-        "\"/* #undef VAR */\" depending on whether VAR is set in CMake to "
-        "any value not considered a false constant by the if() command. "
-        "(Content of \"...\", if any, is processed as above.) "
-        "Input file lines of the form \"#cmakedefine01 VAR\" "
-        "will be replaced with either \"#define VAR 1\" or "
-        "\"#define VAR 0\" similarly."
-        "\n"
-        "With NEWLINE_STYLE the line ending could be adjusted: \n"
-        "    'UNIX' or 'LF' for \\n, 'DOS', 'WIN32' or 'CRLF' for \\r\\n.\n"
-        "COPYONLY must not be used with NEWLINE_STYLE.\n";
-    }
-
   virtual void FinalPass();
   virtual bool HasFinalPass() const { return !this->Immediate; }
 
diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h
index b9c634113..8b1e4deaf 100644
--- a/Source/cmCreateTestSourceList.h
+++ b/Source/cmCreateTestSourceList.h
@@ -42,46 +42,6 @@ public:
    */
   virtual const char* GetName() const {return "create_test_sourcelist";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Create a test driver and source list for building test programs.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  create_test_sourcelist(sourceListName driverName\n"
-      "                         test1 test2 test3\n"
-      "                         EXTRA_INCLUDE include.h\n"
-      "                         FUNCTION function)\n"
-      "A test driver is a program that links together many small tests into "
-      "a single executable.  This is useful when building static executables "
-      "with large libraries to shrink the total required size.  "
-      "The list of source files "
-      "needed to build the test driver will be in sourceListName.  "
-      "DriverName is the name of the test driver program.  The rest of "
-      "the arguments consist of a list of test source files, can be "
-      "semicolon separated.  Each test source file should have a function in "
-      "it that is the same name as the file with no extension (foo.cxx "
-      "should have int foo(int, char*[]);) DriverName will be able to "
-      "call each of the "
-      "tests by name on the command line. If EXTRA_INCLUDE is specified, "
-      "then the next argument is included into the generated file. If "
-      "FUNCTION is specified, then the next argument is taken as a function "
-      "name that is passed a pointer to ac and av.  This can be used to add "
-      "extra command line processing to each test. The cmake variable "
-      "CMAKE_TESTDRIVER_BEFORE_TESTMAIN can be set to have code that will be "
-      "placed directly before calling the test main function.   "
-      "CMAKE_TESTDRIVER_AFTER_TESTMAIN can be set to have code that will be "
-      "placed directly after the call to the test main function.";
-    }
-
   cmTypeMacro(cmCreateTestSourceList, cmCommand);
 };
 
diff --git a/Source/cmDefinePropertyCommand.h b/Source/cmDefinePropertyCommand.h
index b5175d50b..8dc4d963a 100644
--- a/Source/cmDefinePropertyCommand.h
+++ b/Source/cmDefinePropertyCommand.h
@@ -34,53 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "define_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Define and document custom properties.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  define_property(<GLOBAL | DIRECTORY | TARGET | SOURCE |\n"
-        "                   TEST | VARIABLE | CACHED_VARIABLE>\n"
-        "                   PROPERTY <name> [INHERITED]\n"
-        "                   BRIEF_DOCS <brief-doc> [docs...]\n"
-        "                   FULL_DOCS <full-doc> [docs...])\n"
-        "Define one property in a scope for use with the "
-        "set_property and get_property commands.  "
-        "This is primarily useful to associate documentation with property "
-        "names that may be retrieved with the get_property command.  "
-        "The first argument determines the kind of scope in which the "
-        "property should be used.  It must be one of the following:\n"
-        "  GLOBAL    = associated with the global namespace\n"
-        "  DIRECTORY = associated with one directory\n"
-        "  TARGET    = associated with one target\n"
-        "  SOURCE    = associated with one source file\n"
-        "  TEST      = associated with a test named with add_test\n"
-        "  VARIABLE  = documents a CMake language variable\n"
-        "  CACHED_VARIABLE = documents a CMake cache variable\n"
-        "Note that unlike set_property and get_property no actual scope "
-        "needs to be given; only the kind of scope is important.\n"
-        "The required PROPERTY option is immediately followed by the name "
-        "of the property being defined.\n"
-        "If the INHERITED option then the get_property command will chain "
-        "up to the next higher scope when the requested property is not "
-        "set in the scope given to the command.  "
-        "DIRECTORY scope chains to GLOBAL.  "
-        "TARGET, SOURCE, and TEST chain to DIRECTORY.\n"
-        "The BRIEF_DOCS and FULL_DOCS options are followed by strings to be "
-        "associated with the property as its brief and full documentation.  "
-        "Corresponding options to the get_property command will retrieve the "
-        "documentation.";
-    }
-
   cmTypeMacro(cmDefinePropertyCommand, cmCommand);
 private:
   std::string PropertyName;
diff --git a/Source/cmDocumentGeneratorExpressions.h b/Source/cmDocumentGeneratorExpressions.h
deleted file mode 100644
index 7bab7413f..000000000
--- a/Source/cmDocumentGeneratorExpressions.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2010 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 cmDocumentGeneratorExpressions_h
-#define cmDocumentGeneratorExpressions_h
-
-#define CM_DOCUMENT_ADD_TEST_GENERATOR_EXPRESSIONS                      \
-  "Generator expressions are evaluated during build system generation " \
-  "to produce information specific to each build configuration.  "      \
-  "Valid expressions are:\n"                                            \
-  "  $<0:...>                  = empty string (ignores \"...\")\n"      \
-  "  $<1:...>                  = content of \"...\"\n"                  \
-  "  $<CONFIG:cfg>             = '1' if config is \"cfg\", else '0'\n"  \
-  "  $<CONFIGURATION>          = configuration name\n"                  \
-  "  $<BOOL:...>               = '1' if the '...' is true, else '0'\n"  \
-  "  $<STREQUAL:a,b>           = '1' if a is STREQUAL b, else '0'\n"    \
-  "  $<ANGLE-R>                = A literal '>'. Used to compare "       \
-  "strings which contain a '>' for example.\n"                          \
-  "  $<COMMA>                  = A literal ','. Used to compare "       \
-  "strings which contain a ',' for example.\n"                          \
-  "  $<SEMICOLON>              = A literal ';'. Used to prevent "       \
-  "list expansion on an argument with ';'.\n"                           \
-  "  $<JOIN:list,...>          = joins the list with the content of "   \
-  "\"...\"\n"                                                           \
-  "  $<TARGET_NAME:...>        = Marks ... as being the name of a "     \
-  "target.  This is required if exporting targets to multiple "         \
-  "dependent export sets.  The '...' must be a literal name of a "      \
-  "target- it may not contain generator expressions.\n"                 \
-  "  $<INSTALL_INTERFACE:...>  = content of \"...\" when the property " \
-  "is exported using install(EXPORT), and empty otherwise.\n"           \
-  "  $<BUILD_INTERFACE:...>    = content of \"...\" when the property " \
-  "is exported using export(), or when the target is used by another "  \
-  "target in the same buildsystem. Expands to the empty string "        \
-  "otherwise.\n"                                                        \
-  "  $<PLATFORM_ID>            = The CMake-id of the platform "         \
-  "  $<PLATFORM_ID:comp>       = '1' if the The CMake-id of the "       \
-  "platform matches comp, otherwise '0'.\n"                             \
-  "  $<C_COMPILER_ID>          = The CMake-id of the C compiler "       \
-  "used.\n"                                                             \
-  "  $<C_COMPILER_ID:comp>     = '1' if the CMake-id of the C "         \
-  "compiler matches comp, otherwise '0'.\n"                             \
-  "  $<CXX_COMPILER_ID>        = The CMake-id of the CXX compiler "     \
-  "used.\n"                                                             \
-  "  $<CXX_COMPILER_ID:comp>   = '1' if the CMake-id of the CXX "       \
-  "compiler matches comp, otherwise '0'.\n"                             \
-  "  $<VERSION_GREATER:v1,v2>  = '1' if v1 is a version greater than "  \
-  "v2, else '0'.\n"                                                     \
-  "  $<VERSION_LESS:v1,v2>     = '1' if v1 is a version less than v2, " \
-  "else '0'.\n"                                                         \
-  "  $<VERSION_EQUAL:v1,v2>    = '1' if v1 is the same version as v2, " \
-  "else '0'.\n"                                                         \
-  "  $<C_COMPILER_VERSION>     = The version of the C compiler used.\n" \
-  "  $<C_COMPILER_VERSION:ver> = '1' if the version of the C "          \
-  "compiler matches ver, otherwise '0'.\n"                              \
-  "  $<CXX_COMPILER_VERSION>   = The version of the CXX compiler "      \
-  "used.\n"                                                             \
-  "  $<CXX_COMPILER_VERSION:ver> = '1' if the version of the CXX "      \
-  "compiler matches ver, otherwise '0'.\n"                              \
-  "  $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)\n"       \
-  "  $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)\n"   \
-  "  $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)\n"            \
-  "where \"tgt\" is the name of a target.  "                            \
-  "Target file expressions produce a full path, but _DIR and _NAME "    \
-  "versions can produce the directory and file name components:\n"      \
-  "  $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>\n"                  \
-  "  $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>\n"    \
-  "  $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>\n"    \
-  "\n"                                                                  \
-  "  $<TARGET_PROPERTY:tgt,prop>   = The value of the property prop "   \
-  "on the target tgt.\n"                                                \
-  "Note that tgt is not added as a dependency of the target this "      \
-  "expression is evaluated on.\n"                                       \
-  "  $<TARGET_POLICY:pol>          = '1' if the policy was NEW when "   \
-  "the 'head' target was created, else '0'.  If the policy was not "    \
-  "set, the warning message for the policy will be emitted.  This "     \
-  "generator expression only works for a subset of policies.\n"         \
-  "  $<INSTALL_PREFIX>         = Content of the install prefix when "   \
-  "the target is exported via INSTALL(EXPORT) and empty otherwise.\n"   \
-  "Boolean expressions:\n"                                              \
-  "  $<AND:?[,?]...>           = '1' if all '?' are '1', else '0'\n"    \
-  "  $<OR:?[,?]...>            = '0' if all '?' are '0', else '1'\n"    \
-  "  $<NOT:?>                  = '0' if '?' is '1', else '1'\n"         \
-  "where '?' is always either '0' or '1'.\n"                            \
-  ""
-
-#define CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS                       \
-  CM_DOCUMENT_ADD_TEST_GENERATOR_EXPRESSIONS \
-  "Expressions with an implicit 'this' target:\n"                       \
-  "  $<TARGET_PROPERTY:prop>   = The value of the property prop on "    \
-  "the target on which the generator expression is evaluated.\n"        \
-  ""
-
-#endif
diff --git a/Source/cmDocumentLocationUndefined.h b/Source/cmDocumentLocationUndefined.h
deleted file mode 100644
index 9aecf2163..000000000
--- a/Source/cmDocumentLocationUndefined.h
+++ /dev/null
@@ -1,24 +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 cmDocumentLocationUndefined_h
-#define cmDocumentLocationUndefined_h
-
-#define CM_LOCATION_UNDEFINED_BEHAVIOR(action) \
-  "\n" \
-  "Do not set properties that affect the location of a target after " \
-  action ".  These include properties whose names match " \
-  "\"(RUNTIME|LIBRARY|ARCHIVE)_OUTPUT_(NAME|DIRECTORY)(_<CONFIG>)?\", " \
-  "\"(IMPLIB_)?(PREFIX|SUFFIX)\", or \"LINKER_LANGUAGE\".  " \
-  "Failure to follow this rule is not diagnosed and leaves the location " \
-  "of the target undefined."
-
-#endif
diff --git a/Source/cmElseCommand.h b/Source/cmElseCommand.h
index f25991943..d472e99a7 100644
--- a/Source/cmElseCommand.h
+++ b/Source/cmElseCommand.h
@@ -47,24 +47,6 @@ public:
    */
   virtual const char* GetName() const { return "else";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Starts the else portion of an if block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  else(expression)\n"
-      "See the if command.";
-    }
-
   cmTypeMacro(cmElseCommand, cmCommand);
 };
 
diff --git a/Source/cmElseIfCommand.h b/Source/cmElseIfCommand.h
index 46e2bd9f9..d811b35cc 100644
--- a/Source/cmElseIfCommand.h
+++ b/Source/cmElseIfCommand.h
@@ -47,24 +47,6 @@ public:
    */
   virtual const char* GetName() const { return "elseif";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Starts the elseif portion of an if block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  elseif(expression)\n"
-      "See the if command.";
-    }
-
   cmTypeMacro(cmElseIfCommand, cmCommand);
 };
 
diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h
index 747448b3e..a248042ac 100644
--- a/Source/cmEnableLanguageCommand.h
+++ b/Source/cmEnableLanguageCommand.h
@@ -45,37 +45,6 @@ public:
    */
   virtual const char* GetName() const {return "enable_language";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Enable a language (CXX/C/Fortran/etc)";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  enable_language(<lang> [OPTIONAL] )\n"
-      "This command enables support for the named language in CMake. "
-      "This is the same as the project command but does not create "
-      "any of the extra variables that are created by the project command. "
-      "Example languages are CXX, C, Fortran. "
-      "\n"
-      "This command must be called in file scope, not in a function call.  "
-      "Furthermore, it must be called in the highest directory common to "
-      "all targets using the named language directly for compiling sources "
-      "or indirectly through link dependencies.  "
-      "It is simplest to enable all needed languages in the top-level "
-      "directory of a project."
-      "\n"
-      "The OPTIONAL keyword is a placeholder for future implementation "
-      "and does not currently work.";
-    }
-
   cmTypeMacro(cmEnableLanguageCommand, cmCommand);
 };
 
diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h
index 9b9e9851b..e102f5e43 100644
--- a/Source/cmEnableTestingCommand.h
+++ b/Source/cmEnableTestingCommand.h
@@ -50,27 +50,6 @@ public:
    */
   virtual const char* GetName() const { return "enable_testing";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Enable testing for current directory and below.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  enable_testing()\n"
-      "Enables testing for this directory and below.  "
-      "See also the add_test command.  Note that ctest expects to find "
-      "a test file in the build directory root.  Therefore, this command "
-      "should be in the source directory root.";
-    }
-
   cmTypeMacro(cmEnableTestingCommand, cmCommand);
 
 };
diff --git a/Source/cmEndForEachCommand.h b/Source/cmEndForEachCommand.h
index d5ee8a6ae..44d29b56f 100644
--- a/Source/cmEndForEachCommand.h
+++ b/Source/cmEndForEachCommand.h
@@ -54,24 +54,6 @@ public:
    */
   virtual const char* GetName() const { return "endforeach";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Ends a list of commands in a FOREACH block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  endforeach(expression)\n"
-      "See the FOREACH command.";
-    }
-
   cmTypeMacro(cmEndForEachCommand, cmCommand);
 };
 
diff --git a/Source/cmEndFunctionCommand.h b/Source/cmEndFunctionCommand.h
index d7b74e98b..4fdca6bc6 100644
--- a/Source/cmEndFunctionCommand.h
+++ b/Source/cmEndFunctionCommand.h
@@ -54,24 +54,6 @@ public:
    */
   virtual const char* GetName() const { return "endfunction";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Ends a list of commands in a function block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  endfunction(expression)\n"
-      "See the function command.";
-    }
-
   cmTypeMacro(cmEndFunctionCommand, cmCommand);
 };
 
diff --git a/Source/cmEndIfCommand.h b/Source/cmEndIfCommand.h
index 5c4b9e36a..634da60cc 100644
--- a/Source/cmEndIfCommand.h
+++ b/Source/cmEndIfCommand.h
@@ -47,24 +47,6 @@ public:
    */
   virtual const char* GetName() const { return "endif";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Ends a list of commands in an if block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  endif(expression)\n"
-      "See the if command.";
-    }
-
   cmTypeMacro(cmEndIfCommand, cmCommand);
 };
 
diff --git a/Source/cmEndMacroCommand.h b/Source/cmEndMacroCommand.h
index 9d0e70fdc..db15f2742 100644
--- a/Source/cmEndMacroCommand.h
+++ b/Source/cmEndMacroCommand.h
@@ -54,24 +54,6 @@ public:
    */
   virtual const char* GetName() const { return "endmacro";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Ends a list of commands in a macro block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  endmacro(expression)\n"
-      "See the macro command.";
-    }
-
   cmTypeMacro(cmEndMacroCommand, cmCommand);
 };
 
diff --git a/Source/cmEndWhileCommand.h b/Source/cmEndWhileCommand.h
index 18ba5ea31..41138d1a9 100644
--- a/Source/cmEndWhileCommand.h
+++ b/Source/cmEndWhileCommand.h
@@ -54,24 +54,6 @@ public:
    */
   virtual const char* GetName() const { return "endwhile";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Ends a list of commands in a while block.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  endwhile(expression)\n"
-      "See the while command.";
-    }
-
   cmTypeMacro(cmEndWhileCommand, cmCommand);
 };
 
diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h
index f752501fa..4892dd858 100644
--- a/Source/cmExecProgramCommand.h
+++ b/Source/cmExecProgramCommand.h
@@ -50,39 +50,6 @@ public:
    */
   virtual bool IsScriptable() const { return true; }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Deprecated.  Use the execute_process() command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "Run an executable program during the processing of the CMakeList.txt"
-      " file.\n"
-      "  exec_program(Executable [directory in which to run]\n"
-      "               [ARGS <arguments to executable>]\n"
-      "               [OUTPUT_VARIABLE <var>]\n"
-      "               [RETURN_VALUE <var>])\n"
-      "The executable is run in the optionally specified directory.  The "
-      "executable can include arguments if it is double quoted, but it is "
-      "better to use the optional ARGS argument to specify arguments to the "
-      "program.   This is because cmake will then be able to escape spaces "
-      "in the executable path.  An optional argument OUTPUT_VARIABLE "
-      "specifies a variable in which to store the output. "
-      "To capture the return value of the execution, provide a RETURN_VALUE. "
-      "If OUTPUT_VARIABLE is specified, then no output will go to the "
-      "stdout/stderr of the console running cmake.\n"
-      ;
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmExecuteProcessCommand.h b/Source/cmExecuteProcessCommand.h
index 0e20a4b19..bd0f783b6 100644
--- a/Source/cmExecuteProcessCommand.h
+++ b/Source/cmExecuteProcessCommand.h
@@ -49,64 +49,6 @@ public:
    */
   virtual bool IsScriptable() const { return true; }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Execute one or more child processes.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  execute_process(COMMAND <cmd1> [args1...]]\n"
-      "                  [COMMAND <cmd2> [args2...] [...]]\n"
-      "                  [WORKING_DIRECTORY <directory>]\n"
-      "                  [TIMEOUT <seconds>]\n"
-      "                  [RESULT_VARIABLE <variable>]\n"
-      "                  [OUTPUT_VARIABLE <variable>]\n"
-      "                  [ERROR_VARIABLE <variable>]\n"
-      "                  [INPUT_FILE <file>]\n"
-      "                  [OUTPUT_FILE <file>]\n"
-      "                  [ERROR_FILE <file>]\n"
-      "                  [OUTPUT_QUIET]\n"
-      "                  [ERROR_QUIET]\n"
-      "                  [OUTPUT_STRIP_TRAILING_WHITESPACE]\n"
-      "                  [ERROR_STRIP_TRAILING_WHITESPACE])\n"
-      "Runs the given sequence of one or more commands with the standard "
-      "output of each process piped to the standard input of the next.  "
-      "A single standard error pipe is used for all processes.  "
-      "If WORKING_DIRECTORY is given the named directory will be set as "
-      "the current working directory of the child processes.  "
-      "If TIMEOUT is given the child processes will be terminated if they "
-      "do not finish in the specified number of seconds "
-      "(fractions are allowed).  "
-      "If RESULT_VARIABLE is given the variable will be set to contain "
-      "the result of running the processes.  This will be an integer return "
-      "code from the last child or a string describing an error condition.  "
-      "If OUTPUT_VARIABLE or ERROR_VARIABLE are given the variable named "
-      "will be set with the contents of the standard output and standard "
-      "error pipes respectively.  If the same variable is named for both "
-      "pipes their output will be merged in the order produced.  "
-      "If INPUT_FILE, OUTPUT_FILE, or ERROR_FILE is given the file named "
-      "will be attached to the standard input of the first process, "
-      "standard output of the last process, or standard error of all "
-      "processes respectively.  "
-      "If OUTPUT_QUIET or ERROR_QUIET is given then the standard output "
-      "or standard error results will be quietly ignored.  "
-      "If more than one OUTPUT_* or ERROR_* option is given for the same "
-      "pipe the precedence is not specified.  "
-      "If no OUTPUT_* or ERROR_* options are given the output will be shared "
-      "with the corresponding pipes of the CMake process itself.\n"
-      "The execute_process command is a newer more powerful version of "
-      "exec_program, but the old command has been kept for compatibility."
-      ;
-    }
-
   cmTypeMacro(cmExecuteProcessCommand, cmCommand);
 };
 
diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h
index 38e8d9a6d..ea7c3a309 100644
--- a/Source/cmExportCommand.h
+++ b/Source/cmExportCommand.h
@@ -13,7 +13,6 @@
 #define cmExportCommand_h
 
 #include "cmCommand.h"
-#include "cmDocumentLocationUndefined.h"
 
 class cmExportBuildFileGenerator;
 
@@ -47,61 +46,6 @@ public:
    */
   virtual const char* GetName() const { return "export";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Export targets from the build tree for use by outside projects.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  export(TARGETS [target1 [target2 [...]]] [NAMESPACE <namespace>]\n"
-      "         [APPEND] FILE <filename> [EXPORT_LINK_INTERFACE_LIBRARIES])\n"
-      "Create a file <filename> that may be included by outside projects to "
-      "import targets from the current project's build tree.  "
-      "This is useful during cross-compiling to build utility executables "
-      "that can run on the host platform in one project and then import "
-      "them into another project being compiled for the target platform.  "
-      "If the NAMESPACE option is given the <namespace> string will be "
-      "prepended to all target names written to the file.  "
-      "If the APPEND option is given the generated code will be appended "
-      "to the file instead of overwriting it.  "
-      "The EXPORT_LINK_INTERFACE_LIBRARIES keyword, if present, causes the "
-      "contents of the properties matching "
-      "(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)? to be exported, when "
-      "policy CMP0022 is NEW.  "
-      "If a library target is included in the export but "
-      "a target to which it links is not included the behavior is "
-      "unspecified."
-      "\n"
-      "The file created by this command is specific to the build tree and "
-      "should never be installed.  "
-      "See the install(EXPORT) command to export targets from an "
-      "installation tree."
-      "\n"
-      "The properties set on the generated IMPORTED targets will have the "
-      "same values as the final values of the input TARGETS."
-      "\n"
-      "  export(PACKAGE <name>)\n"
-      "Store the current build directory in the CMake user package registry "
-      "for package <name>.  "
-      "The find_package command may consider the directory while searching "
-      "for package <name>.  "
-      "This helps dependent projects find and use a package from the "
-      "current project's build tree without help from the user.  "
-      "Note that the entry in the package registry that this command "
-      "creates works only in conjunction with a package configuration "
-      "file (<name>Config.cmake) that works with the build tree."
-      ;
-    }
-
   cmTypeMacro(cmExportCommand, cmCommand);
 
 private:
diff --git a/Source/cmExportLibraryDependencies.h b/Source/cmExportLibraryDependencies.h
index d8b65ccf1..a384a7c98 100644
--- a/Source/cmExportLibraryDependencies.h
+++ b/Source/cmExportLibraryDependencies.h
@@ -50,38 +50,6 @@ public:
    */
   virtual const char* GetName() const { return "export_library_dependencies";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated.  Use INSTALL(EXPORT) or EXPORT command.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "This command generates an old-style library dependencies file.  "
-      "Projects requiring CMake 2.6 or later should not use the command.  "
-      "Use instead the install(EXPORT) command to help export targets "
-      "from an installation tree and the export() command to export targets "
-      "from a build tree.\n"
-      "The old-style library dependencies file does not take into account "
-      "per-configuration names of libraries or the LINK_INTERFACE_LIBRARIES "
-      "target property.\n"
-      "  export_library_dependencies(<file> [APPEND])\n"
-      "Create a file named <file> that can be included into a CMake listfile "
-      "with the INCLUDE command.  The file will contain a number of SET "
-      "commands that will set all the variables needed for library dependency "
-      "information.  This should be the last command in the top level "
-      "CMakeLists.txt file of the project.  If the APPEND option is "
-      "specified, the SET commands will be appended to the given file "
-      "instead of replacing it.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmFLTKWrapUICommand.h b/Source/cmFLTKWrapUICommand.h
index 530de2c96..b94390ca9 100644
--- a/Source/cmFLTKWrapUICommand.h
+++ b/Source/cmFLTKWrapUICommand.h
@@ -54,28 +54,6 @@ public:
    */
   virtual const char* GetName() const { return "fltk_wrap_ui";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Create FLTK user interfaces Wrappers.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  fltk_wrap_ui(resultingLibraryName source1\n"
-      "               source2 ... sourceN )\n"
-      "Produce .h and .cxx files for all the .fl and .fld files listed.  "
-      "The resulting .h and .cxx files will be added to a variable named "
-      "resultingLibraryName_FLTK_UI_SRCS which should be added to your "
-      "library.";
-    }
-
 private:
   /**
    * List of produced files.
diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h
index aa755d1f5..ba4581516 100644
--- a/Source/cmFileCommand.h
+++ b/Source/cmFileCommand.h
@@ -48,213 +48,6 @@ public:
    */
   virtual const char* GetName() const { return "file";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "File manipulation command.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  file(WRITE filename \"message to write\"... )\n"
-      "  file(APPEND filename \"message to write\"... )\n"
-      "  file(READ filename variable [LIMIT numBytes] [OFFSET offset] [HEX])\n"
-      "  file(<MD5|SHA1|SHA224|SHA256|SHA384|SHA512> filename variable)\n"
-      "  file(STRINGS filename variable [LIMIT_COUNT num]\n"
-      "       [LIMIT_INPUT numBytes] [LIMIT_OUTPUT numBytes]\n"
-      "       [LENGTH_MINIMUM numBytes] [LENGTH_MAXIMUM numBytes]\n"
-      "       [NEWLINE_CONSUME] [REGEX regex]\n"
-      "       [NO_HEX_CONVERSION])\n"
-      "  file(GLOB variable [RELATIVE path] [globbing expressions]...)\n"
-      "  file(GLOB_RECURSE variable [RELATIVE path] \n"
-      "       [FOLLOW_SYMLINKS] [globbing expressions]...)\n"
-      "  file(RENAME <oldname> <newname>)\n"
-      "  file(REMOVE [file1 ...])\n"
-      "  file(REMOVE_RECURSE [file1 ...])\n"
-      "  file(MAKE_DIRECTORY [directory1 directory2 ...])\n"
-      "  file(RELATIVE_PATH variable directory file)\n"
-      "  file(TO_CMAKE_PATH path result)\n"
-      "  file(TO_NATIVE_PATH path result)\n"
-      "  file(DOWNLOAD url file [INACTIVITY_TIMEOUT timeout]\n"
-      "       [TIMEOUT timeout] [STATUS status] [LOG log] [SHOW_PROGRESS]\n"
-      "       [EXPECTED_HASH ALGO=value] [EXPECTED_MD5 sum]\n"
-      "       [TLS_VERIFY on|off] [TLS_CAINFO file])\n"
-      "  file(UPLOAD filename url [INACTIVITY_TIMEOUT timeout]\n"
-      "       [TIMEOUT timeout] [STATUS status] [LOG log] [SHOW_PROGRESS])\n"
-      "  file(TIMESTAMP filename variable [<format string>] [UTC])\n"
-      "  file(GENERATE OUTPUT output_file\n"
-      "       <INPUT input_file|CONTENT input_content>\n"
-      "       [CONDITION expression])\n"
-      "WRITE will write a message into a file called 'filename'. It "
-      "overwrites the file if it already exists, and creates the file "
-      "if it does not exist. (If the file is a build input, use "
-      "configure_file to update the file only when its content changes.)\n"
-      "APPEND will write a message into a file same as WRITE, except "
-      "it will append it to the end of the file\n"
-      "READ will read the content of a file and store it into the "
-      "variable. It will start at the given offset and read up to numBytes. "
-      "If the argument HEX is given, the binary data will be converted to "
-      "hexadecimal representation and this will be stored in the variable.\n"
-      "MD5, SHA1, SHA224, SHA256, SHA384, and SHA512 "
-      "will compute a cryptographic hash of the content of a file.\n"
-      "STRINGS will parse a list of ASCII strings from a file and "
-      "store it in a variable. Binary data in the file are ignored. Carriage "
-      "return (CR) characters are ignored. It works also for Intel Hex and "
-      "Motorola S-record files, which are automatically converted to binary "
-      "format when reading them. Disable this using NO_HEX_CONVERSION.\n"
-      "LIMIT_COUNT sets the maximum number of strings to return. "
-      "LIMIT_INPUT sets the maximum number of bytes to read from "
-      "the input file. "
-      "LIMIT_OUTPUT sets the maximum number of bytes to store in the "
-      "output variable. "
-      "LENGTH_MINIMUM sets the minimum length of a string to return. "
-      "Shorter strings are ignored. "
-      "LENGTH_MAXIMUM sets the maximum length of a string to return.  Longer "
-      "strings are split into strings no longer than the maximum length. "
-      "NEWLINE_CONSUME allows newlines to be included in strings instead "
-      "of terminating them.\n"
-      "REGEX specifies a regular expression that a string must match to be "
-      "returned. Typical usage \n"
-      "  file(STRINGS myfile.txt myfile)\n"
-      "stores a list in the variable \"myfile\" in which each item is "
-      "a line from the input file.\n"
-      "GLOB will generate a list of all files that match the globbing "
-      "expressions and store it into the variable. Globbing expressions "
-      "are similar to regular expressions, but much simpler. If RELATIVE "
-      "flag is specified for an expression, the results will be returned "
-      "as a relative path to the given path.  "
-      "(We do not recommend using GLOB to collect a list of source files "
-      "from your source tree.  If no CMakeLists.txt file changes when a "
-      "source is added or removed then the generated build system cannot "
-      "know when to ask CMake to regenerate.)"
-      "\n"
-      "Examples of globbing expressions include:\n"
-      "   *.cxx      - match all files with extension cxx\n"
-      "   *.vt?      - match all files with extension vta,...,vtz\n"
-      "   f[3-5].txt - match files f3.txt, f4.txt, f5.txt\n"
-      "GLOB_RECURSE will generate a list similar to the regular GLOB, except "
-      "it will traverse all the subdirectories of the matched directory and "
-      "match the files. Subdirectories that are symlinks are only traversed "
-      "if FOLLOW_SYMLINKS is given or cmake policy CMP0009 is not set to NEW. "
-      "See cmake --help-policy CMP0009 for more information.\n"
-      "Examples of recursive globbing include:\n"
-      "   /dir/*.py  - match all python files in /dir and subdirectories\n"
-      "MAKE_DIRECTORY will create the given directories, also if their parent "
-      "directories don't exist yet\n"
-      "RENAME moves a file or directory within a filesystem, "
-      "replacing the destination atomically."
-      "\n"
-      "REMOVE will remove the given files, also in subdirectories\n"
-      "REMOVE_RECURSE will remove the given files and directories, also "
-      "non-empty directories\n"
-      "RELATIVE_PATH will determine relative path from directory to the given"
-      " file.\n"
-      "TO_CMAKE_PATH will convert path into a cmake style path with unix /. "
-      " The input can be a single path or a system path like \"$ENV{PATH}\". "
-      " Note the double quotes around the ENV call TO_CMAKE_PATH only takes "
-      " one argument. This command will also convert the native list"
-      " delimiters for a list of paths like the PATH environment variable.\n"
-      "TO_NATIVE_PATH works just like TO_CMAKE_PATH, but will convert from "
-      " a cmake style path into the native path style \\ for windows and / "
-      "for UNIX.\n"
-      "DOWNLOAD will download the given URL to the given file. "
-      "If LOG var is specified a log of the download will be put in var. "
-      "If STATUS var is specified the status of the operation will"
-      " be put in var. The status is returned in a list of length 2. "
-      "The first element is the numeric return value for the operation, "
-      "and the second element is a string value for the error. A 0 "
-      "numeric error means no error in the operation. "
-      "If TIMEOUT time is specified, the operation will "
-      "timeout after time seconds, time should be specified as an integer. "
-      "The INACTIVITY_TIMEOUT specifies an integer number of seconds of "
-      "inactivity after which the operation should terminate. "
-      "If EXPECTED_HASH ALGO=value is specified, the operation will verify "
-      "that the downloaded file's actual hash matches the expected value, "
-      "where ALGO is one of MD5, SHA1, SHA224, SHA256, SHA384, or SHA512.  "
-      "If it does not match, the operation fails with an error. "
-      "(\"EXPECTED_MD5 sum\" is short-hand for \"EXPECTED_HASH MD5=sum\".) "
-      "If SHOW_PROGRESS is specified, progress information will be printed "
-      "as status messages until the operation is complete. "
-      "For https URLs CMake must be built with OpenSSL.  "
-      "TLS/SSL certificates are not checked by default.  "
-      "Set TLS_VERIFY to ON to check certificates and/or use "
-      "EXPECTED_HASH to verify downloaded content.  "
-      "Set TLS_CAINFO to specify a custom Certificate Authority file.  "
-      "If either TLS option is not given CMake will check variables "
-      "CMAKE_TLS_VERIFY and CMAKE_TLS_CAINFO, "
-      "respectively."
-      "\n"
-      "UPLOAD will upload the given file to the given URL. "
-      "If LOG var is specified a log of the upload will be put in var. "
-      "If STATUS var is specified the status of the operation will"
-      " be put in var. The status is returned in a list of length 2. "
-      "The first element is the numeric return value for the operation, "
-      "and the second element is a string value for the error. A 0 "
-      "numeric error means no error in the operation. "
-      "If TIMEOUT time is specified, the operation will "
-      "timeout after time seconds, time should be specified as an integer. "
-      "The INACTIVITY_TIMEOUT specifies an integer number of seconds of "
-      "inactivity after which the operation should terminate. "
-      "If SHOW_PROGRESS is specified, progress information will be printed "
-      "as status messages until the operation is complete."
-      "\n"
-      "TIMESTAMP will write a string representation of "
-      "the modification time of filename to variable.\n"
-      "Should the command be unable to obtain a timestamp "
-      "variable will be set to the empty string \"\".\n"
-      "See documentation of the string TIMESTAMP sub-command for more details."
-      "\n"
-      "The file() command also provides COPY and INSTALL signatures:\n"
-      "  file(<COPY|INSTALL> files... DESTINATION <dir>\n"
-      "       [FILE_PERMISSIONS permissions...]\n"
-      "       [DIRECTORY_PERMISSIONS permissions...]\n"
-      "       [NO_SOURCE_PERMISSIONS] [USE_SOURCE_PERMISSIONS]\n"
-      "       [FILES_MATCHING]\n"
-      "       [[PATTERN <pattern> | REGEX <regex>]\n"
-      "        [EXCLUDE] [PERMISSIONS permissions...]] [...])\n"
-      "The COPY signature copies files, directories, and symlinks to a "
-      "destination folder.  "
-      "Relative input paths are evaluated with respect to the current "
-      "source directory, and a relative destination is evaluated with "
-      "respect to the current build directory.  "
-      "Copying preserves input file timestamps, and optimizes out a file "
-      "if it exists at the destination with the same timestamp.  "
-      "Copying preserves input permissions unless explicit permissions or "
-      "NO_SOURCE_PERMISSIONS are given (default is USE_SOURCE_PERMISSIONS).  "
-      "See the install(DIRECTORY) command for documentation of permissions, "
-      "PATTERN, REGEX, and EXCLUDE options.  "
-      "\n"
-      "The INSTALL signature differs slightly from COPY: "
-      "it prints status messages, and NO_SOURCE_PERMISSIONS is default.  "
-      "Installation scripts generated by the install() command use this "
-      "signature (with some undocumented options for internal use)."
-      "\n"
-      "GENERATE will write an <output_file> with content from an "
-      "<input_file>, or from <input_content>.  The output is generated "
-      "conditionally based on the content of the <condition>.  The file is "
-      "written at CMake generate-time and the input may contain generator "
-      "expressions.  The <condition>, <output_file> and <input_file> may "
-      "also contain generator expressions.  The <condition> must evaluate to "
-      "either '0' or '1'.  The <output_file> must evaluate to a unique name "
-      "among all configurations and among all invocations of file(GENERATE)."
-      // Undocumented INSTALL options:
-      //  - RENAME <name>
-      //  - OPTIONAL
-      //  - FILES keyword to re-enter files... list
-      //  - PERMISSIONS before REGEX is alias for FILE_PERMISSIONS
-      //  - DIR_PERMISSIONS is alias for DIRECTORY_PERMISSIONS
-      //  - TYPE <FILE|DIRECTORY|EXECUTABLE|PROGRAM|
-      //          STATIC_LIBRARY|SHARED_LIBRARY|MODULE>
-      //  - COMPONENTS, CONFIGURATIONS, PROPERTIES (ignored for compat)
-      ;
-    }
-
   cmTypeMacro(cmFileCommand, cmCommand);
 
 protected:
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index 7ce003216..c1e7b1e6d 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -19,106 +19,6 @@ cmFindBase::cmFindBase()
   this->NamesPerDirAllowed = false;
 }
 
-//----------------------------------------------------------------------------
-void cmFindBase::GenerateDocumentation()
-{
-  this->cmFindCommon::GenerateDocumentation();
-  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
-                               "FIND_ARGS_XXX", "<VAR> NAMES name");
-  this->GenericDocumentation =
-    "   FIND_XXX(<VAR> name1 [path1 path2 ...])\n"
-    "This is the short-hand signature for the command that "
-    "is sufficient in many cases.  It is the same "
-    "as FIND_XXX(<VAR> name1 [PATHS path1 path2 ...])\n"
-    "   FIND_XXX(\n"
-    "             <VAR>\n"
-    "             name | NAMES name1 [name2 ...]\n"
-    "             [HINTS path1 [path2 ... ENV var]]\n"
-    "             [PATHS path1 [path2 ... ENV var]]\n"
-    "             [PATH_SUFFIXES suffix1 [suffix2 ...]]\n"
-    "             [DOC \"cache documentation string\"]\n"
-    "             [NO_DEFAULT_PATH]\n"
-    "             [NO_CMAKE_ENVIRONMENT_PATH]\n"
-    "             [NO_CMAKE_PATH]\n"
-    "             [NO_SYSTEM_ENVIRONMENT_PATH]\n"
-    "             [NO_CMAKE_SYSTEM_PATH]\n"
-    "             [CMAKE_FIND_ROOT_PATH_BOTH |\n"
-    "              ONLY_CMAKE_FIND_ROOT_PATH |\n"
-    "              NO_CMAKE_FIND_ROOT_PATH]\n"
-    "            )\n"
-    ""
-    "This command is used to find a SEARCH_XXX_DESC. "
-    "A cache entry named by <VAR> is created to store the result "
-    "of this command.  "
-    "If the SEARCH_XXX is found the result is stored in the variable "
-    "and the search will not be repeated unless the variable is cleared.  "
-    "If nothing is found, the result will be "
-    "<VAR>-NOTFOUND, and the search will be attempted again the "
-    "next time FIND_XXX is invoked with the same variable.  "
-    "The name of the SEARCH_XXX that "
-    "is searched for is specified by the names listed "
-    "after the NAMES argument.   Additional search locations "
-    "can be specified after the PATHS argument.  If ENV var is "
-    "found in the HINTS or PATHS section the environment variable var "
-    "will be read and converted from a system environment variable to "
-    "a cmake style list of paths.  For example ENV PATH would be a way "
-    "to list the system path variable. The argument "
-    "after DOC will be used for the documentation string in "
-    "the cache.  "
-    "PATH_SUFFIXES specifies additional subdirectories to check below "
-    "each search path."
-    "\n"
-    "If NO_DEFAULT_PATH is specified, then no additional paths are "
-    "added to the search. "
-    "If NO_DEFAULT_PATH is not specified, the search process is as follows:\n"
-    "1. Search paths specified in cmake-specific cache variables.  "
-    "These are intended to be used on the command line with a -DVAR=value.  "
-    "This can be skipped if NO_CMAKE_PATH is passed.\n"
-    "XXX_EXTRA_PREFIX_ENTRY"
-    "   <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
-    "   CMAKE_XXX_PATH\n"
-    "   CMAKE_XXX_MAC_PATH\n"
-    "2. Search paths specified in cmake-specific environment variables.  "
-    "These are intended to be set in the user's shell configuration.  "
-    "This can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n"
-    "XXX_EXTRA_PREFIX_ENTRY"
-    "   <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
-    "   CMAKE_XXX_PATH\n"
-    "   CMAKE_XXX_MAC_PATH\n"
-    "3. Search the paths specified by the HINTS option.  "
-    "These should be paths computed by system introspection, such as a "
-    "hint provided by the location of another item already found.  "
-    "Hard-coded guesses should be specified with the PATHS option.\n"
-    "4. Search the standard system environment variables. "
-    "This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.\n"
-    "   PATH\n"
-    "   XXX_SYSTEM\n"  // replace with "", LIB, or INCLUDE
-    "5. Search cmake variables defined in the Platform files "
-    "for the current system.  This can be skipped if NO_CMAKE_SYSTEM_PATH "
-    "is passed.\n"
-    "XXX_EXTRA_PREFIX_ENTRY"
-    "   <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH\n"
-    "   CMAKE_SYSTEM_XXX_PATH\n"
-    "   CMAKE_SYSTEM_XXX_MAC_PATH\n"
-    "6. Search the paths specified by the PATHS option "
-    "or in the short-hand version of the command.  "
-    "These are typically hard-coded guesses.\n"
-    ;
-  this->GenericDocumentation += this->GenericDocumentationMacPolicy;
-  this->GenericDocumentation += this->GenericDocumentationRootPath;
-  this->GenericDocumentation += this->GenericDocumentationPathsOrder;
-}
-
-//----------------------------------------------------------------------------
-const char* cmFindBase::GetFullDocumentation() const
-{
-  if(this->GenericDocumentation.empty())
-    {
-    const_cast<cmFindBase *>(this)->GenerateDocumentation();
-    }
-  return this->GenericDocumentation.c_str();
-}
-
 //----------------------------------------------------------------------------
 bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
 {
diff --git a/Source/cmFindBase.h b/Source/cmFindBase.h
index 84b03300c..0562b1b0a 100644
--- a/Source/cmFindBase.h
+++ b/Source/cmFindBase.h
@@ -31,10 +31,7 @@ public:
   virtual bool ParseArguments(std::vector<std::string> const& args);
   cmTypeMacro(cmFindBase, cmFindCommon);
 
-  virtual const char* GetFullDocumentation() const;
-
 protected:
-  virtual void GenerateDocumentation();
   void PrintFindStuff();
   void ExpandPaths();
   void AddPathSuffixes();
@@ -44,7 +41,6 @@ protected:
   // if it has documentation in the cache
   bool CheckForVariableInCache();
 
-  cmStdString GenericDocumentation;
   // use by command during find
   cmStdString VariableDocumentation;
   cmStdString VariableName;
diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx
index b44864e13..7beeda097 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -36,55 +36,6 @@ cmFindCommon::cmFindCommon()
   this->SearchAppBundleLast = false;
 }
 
-//----------------------------------------------------------------------------
-void cmFindCommon::GenerateDocumentation()
-{
-  // Documentation components.
-  this->GenericDocumentationMacPolicy =
-    "On Darwin or systems supporting OS X Frameworks, the cmake variable"
-    "    CMAKE_FIND_FRAMEWORK can be set to empty or one of the following:\n"
-    "   \"FIRST\"  - Try to find frameworks before standard\n"
-    "              libraries or headers. This is the default on Darwin.\n"
-    "   \"LAST\"   - Try to find frameworks after standard\n"
-    "              libraries or headers.\n"
-    "   \"ONLY\"   - Only try to find frameworks.\n"
-    "   \"NEVER\" - Never try to find frameworks.\n"
-    "On Darwin or systems supporting OS X Application Bundles, the cmake "
-    "variable CMAKE_FIND_APPBUNDLE can be set to empty or one of the "
-    "following:\n"
-    "   \"FIRST\"  - Try to find application bundles before standard\n"
-    "              programs. This is the default on Darwin.\n"
-    "   \"LAST\"   - Try to find application bundles after standard\n"
-    "              programs.\n"
-    "   \"ONLY\"   - Only try to find application bundles.\n"
-    "   \"NEVER\" - Never try to find application bundles.\n";
-  this->GenericDocumentationRootPath =
-    "The CMake variable CMAKE_FIND_ROOT_PATH specifies one or more "
-    "directories to be prepended to all other search directories. "
-    "This effectively \"re-roots\" the entire search under given locations. "
-    "By default it is empty. It is especially useful when "
-    "cross-compiling to point to the root directory of the "
-    "target environment and CMake will search there too. By default at first "
-    "the directories listed in CMAKE_FIND_ROOT_PATH and then the non-rooted "
-    "directories will be searched. "
-    "The default behavior can be adjusted by setting "
-    "CMAKE_FIND_ROOT_PATH_MODE_XXX.  This behavior can be manually "
-    "overridden on a per-call basis. "
-    "By using CMAKE_FIND_ROOT_PATH_BOTH the search order will "
-    "be as described above. If NO_CMAKE_FIND_ROOT_PATH is used "
-    "then CMAKE_FIND_ROOT_PATH will not be used. If ONLY_CMAKE_FIND_ROOT_PATH "
-    "is used then only the re-rooted directories will be searched.\n";
-  this->GenericDocumentationPathsOrder =
-    "The default search order is designed to be most-specific to "
-    "least-specific for common use cases.  "
-    "Projects may override the order by simply calling the command "
-    "multiple times and using the NO_* options:\n"
-    "   FIND_XXX(FIND_ARGS_XXX PATHS paths... NO_DEFAULT_PATH)\n"
-    "   FIND_XXX(FIND_ARGS_XXX)\n"
-    "Once one of the calls succeeds the result variable will be set "
-    "and stored in the cache so that no call will search again.";
-}
-
 //----------------------------------------------------------------------------
 cmFindCommon::~cmFindCommon()
 {
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index 542805faf..6109a9fd4 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -56,8 +56,6 @@ protected:
   /** Compute the current default bundle/framework search policy.  */
   void SelectDefaultMacMode();
 
-  virtual void GenerateDocumentation();
-
   cmStdString CMakePathName;
   RootPathMode FindRootPathMode;
 
@@ -85,10 +83,6 @@ protected:
   std::vector<std::string> SearchPaths;
   std::set<cmStdString> SearchPathsEmitted;
 
-  std::string GenericDocumentationMacPolicy;
-  std::string GenericDocumentationRootPath;
-  std::string GenericDocumentationPathsOrder;
-
   bool SearchFrameworkFirst;
   bool SearchFrameworkOnly;
   bool SearchFrameworkLast;
diff --git a/Source/cmFindFileCommand.cxx b/Source/cmFindFileCommand.cxx
index fa66fa11d..615e7c1d2 100644
--- a/Source/cmFindFileCommand.cxx
+++ b/Source/cmFindFileCommand.cxx
@@ -16,15 +16,3 @@ cmFindFileCommand::cmFindFileCommand()
 {
   this->IncludeFileInPath = true;
 }
-
-void cmFindFileCommand::GenerateDocumentation()
-{
-  this->cmFindPathCommand::GenerateDocumentation();
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "find_path", "find_file");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "directory containing the named file",
-                               "full path to named file");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "file in a directory", "full path to a file");
-}
diff --git a/Source/cmFindFileCommand.h b/Source/cmFindFileCommand.h
index 1bfdcbd16..3f0baa2cd 100644
--- a/Source/cmFindFileCommand.h
+++ b/Source/cmFindFileCommand.h
@@ -35,17 +35,7 @@ public:
     }
   virtual const char* GetName() const { return "find_file";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Find the full path to a file.";
-    }
-
   cmTypeMacro(cmFindFileCommand, cmFindPathCommand);
-protected:
-  virtual void GenerateDocumentation();
 };
 
 
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index 4af7e11bf..de52df7a0 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -20,62 +20,6 @@ cmFindLibraryCommand::cmFindLibraryCommand()
   this->NamesPerDirAllowed = true;
 }
 
-//----------------------------------------------------------------------------
-void cmFindLibraryCommand::GenerateDocumentation()
-{
-  this->cmFindBase::GenerateDocumentation();
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "FIND_XXX", "find_library");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_XXX_PATH", "CMAKE_LIBRARY_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_XXX_MAC_PATH",
-                               "CMAKE_FRAMEWORK_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_MAC_PATH",
-                               "CMAKE_SYSTEM_FRAMEWORK_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_SYSTEM", "LIB");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_PATH",
-                               "CMAKE_SYSTEM_LIBRARY_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX_DESC", "library");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX", "library");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_SUBDIR", "lib");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "NAMES name1 [name2 ...]",
-                               "NAMES name1 [name2 ...] [NAMES_PER_DIR]");
-  cmSystemTools::ReplaceString(
-    this->GenericDocumentation,
-    "XXX_EXTRA_PREFIX_ENTRY",
-    "   <prefix>/lib/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and\n");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
-                               "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY");
-  this->GenericDocumentation +=
-    "\n"
-    "When more than one value is given to the NAMES option this command "
-    "by default will consider one name at a time and search every directory "
-    "for it.  "
-    "The NAMES_PER_DIR option tells this command to consider one directory "
-    "at a time and search for all names in it."
-    "\n"
-    "If the library found is a framework, then VAR will be set to "
-    "the full path to the framework <fullPath>/A.framework. "
-    "When a full path to a framework is used as a library, "
-    "CMake will use a -framework A, and a -F<fullPath> to "
-    "link the framework to the target."
-    "\n"
-    "If the global property FIND_LIBRARY_USE_LIB64_PATHS is set all search "
-    "paths will be tested as normal, with \"64/\" appended, and with all "
-    "matches of \"lib/\" replaced with \"lib64/\". This property is "
-    "automatically set for the platforms that are known to need it if at "
-    "least one of the languages supported by the PROJECT command is enabled.";
-}
-
 // cmFindLibraryCommand
 bool cmFindLibraryCommand
 ::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
diff --git a/Source/cmFindLibraryCommand.h b/Source/cmFindLibraryCommand.h
index cd0fce8ad..a9ec40e93 100644
--- a/Source/cmFindLibraryCommand.h
+++ b/Source/cmFindLibraryCommand.h
@@ -51,13 +51,6 @@ public:
    */
   virtual const char* GetName() const {return "find_library";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Find a library.";
-    }
   cmTypeMacro(cmFindLibraryCommand, cmFindBase);
 
 protected:
@@ -67,7 +60,6 @@ protected:
                            const char* suffix,
                            bool fresh = true);
   std::string FindLibrary();
-  virtual void GenerateDocumentation();
 private:
   std::string FindNormalLibrary();
   std::string FindNormalLibraryNamesPerDir();
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 1d6530f2a..aeca39a5e 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -78,322 +78,6 @@ cmFindPackageCommand::cmFindPackageCommand()
   this->RequiredCMakeVersion = 0;
 }
 
-//----------------------------------------------------------------------------
-void cmFindPackageCommand::GenerateDocumentation()
-{
-  this->cmFindCommon::GenerateDocumentation();
-  cmSystemTools::ReplaceString(this->GenericDocumentationRootPath,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
-                               "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE");
-  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
-                               "FIND_ARGS_XXX", "<package>");
-  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
-                               "FIND_XXX", "find_package");
-  this->CommandDocumentation =
-    "  find_package(<package> [version] [EXACT] [QUIET] [MODULE]\n"
-    "               [REQUIRED] [[COMPONENTS] [components...]]\n"
-    "               [OPTIONAL_COMPONENTS components...]\n"
-    "               [NO_POLICY_SCOPE])\n"
-    "Finds and loads settings from an external project.  "
-    "<package>_FOUND will be set to indicate whether the package was found.  "
-    "When the package is found package-specific information is provided "
-    "through variables and imported targets documented by the package "
-    "itself.  "
-    "The QUIET option disables messages if the package cannot be found.  "
-    "The MODULE option disables the second signature documented below.  "
-    "The REQUIRED option stops processing with an error message if the "
-    "package cannot be found."
-    "\n"
-    "A package-specific list of required components may be listed after the "
-    "COMPONENTS option (or after the REQUIRED option if present).  "
-    "Additional optional components may be listed after OPTIONAL_COMPONENTS.  "
-    "Available components and their influence on whether a package is "
-    "considered to be found are defined by the target package."
-    "\n"
-    "The [version] argument requests a version with which the package found "
-    "should be compatible (format is major[.minor[.patch[.tweak]]]).  "
-    "The EXACT option requests that the version be matched exactly.  "
-    "If no [version] and/or component list is given to a recursive "
-    "invocation inside a find-module, the corresponding arguments "
-    "are forwarded automatically from the outer call (including the "
-    "EXACT flag for [version]).  "
-    "Version support is currently provided only on a package-by-package "
-    "basis (details below).\n"
-    "User code should generally look for packages using the above simple "
-    "signature.  The remainder of this command documentation specifies the "
-    "full command signature and details of the search process.  Project "
-    "maintainers wishing to provide a package to be found by this command "
-    "are encouraged to read on.\n"
-    "The command has two modes by which it searches for packages: "
-    "\"Module\" mode and \"Config\" mode.  "
-    "Module mode is available when the command is invoked with the above "
-    "reduced signature.  "
-    "CMake searches for a file called \"Find<package>.cmake\" in "
-    "the CMAKE_MODULE_PATH followed by the CMake installation.  "
-    "If the file is found, it is read and processed by CMake.  "
-    "It is responsible for finding the package, checking the version, "
-    "and producing any needed messages.  "
-    "Many find-modules provide limited or no support for versioning; "
-    "check the module documentation.  "
-    "If no module is found and the MODULE option is not given the command "
-    "proceeds to Config mode.\n"
-    "The complete Config mode command signature is:\n"
-    "  find_package(<package> [version] [EXACT] [QUIET]\n"
-    "               [REQUIRED] [[COMPONENTS] [components...]]\n"
-    "               [CONFIG|NO_MODULE]\n"
-    "               [NO_POLICY_SCOPE]\n"
-    "               [NAMES name1 [name2 ...]]\n"
-    "               [CONFIGS config1 [config2 ...]]\n"
-    "               [HINTS path1 [path2 ... ]]\n"
-    "               [PATHS path1 [path2 ... ]]\n"
-    "               [PATH_SUFFIXES suffix1 [suffix2 ...]]\n"
-    "               [NO_DEFAULT_PATH]\n"
-    "               [NO_CMAKE_ENVIRONMENT_PATH]\n"
-    "               [NO_CMAKE_PATH]\n"
-    "               [NO_SYSTEM_ENVIRONMENT_PATH]\n"
-    "               [NO_CMAKE_PACKAGE_REGISTRY]\n"
-    "               [NO_CMAKE_BUILDS_PATH]\n"
-    "               [NO_CMAKE_SYSTEM_PATH]\n"
-    "               [NO_CMAKE_SYSTEM_PACKAGE_REGISTRY]\n"
-    "               [CMAKE_FIND_ROOT_PATH_BOTH |\n"
-    "                ONLY_CMAKE_FIND_ROOT_PATH |\n"
-    "                NO_CMAKE_FIND_ROOT_PATH])\n"
-    "The CONFIG option may be used to skip Module mode explicitly and "
-    "switch to Config mode.  It is synonymous to using NO_MODULE.  "
-    "Config mode is also implied by use of options not specified in the "
-    "reduced signature.  "
-    "\n"
-    "Config mode attempts to locate a configuration file provided by the "
-    "package to be found.  A cache entry called <package>_DIR is created to "
-    "hold the directory containing the file.  "
-    "By default the command searches for a package with the name <package>.  "
-    "If the NAMES option is given the names following it are used instead "
-    "of <package>.  "
-    "The command searches for a file called \"<name>Config.cmake\" or "
-    "\"<lower-case-name>-config.cmake\" for each name specified.  "
-    "A replacement set of possible configuration file names may be given "
-    "using the CONFIGS option.  "
-    "The search procedure is specified below.  Once found, the configuration "
-    "file is read and processed by CMake.  Since the file is provided by the "
-    "package it already knows the location of package contents.  "
-    "The full path to the configuration file is stored in the cmake "
-    "variable <package>_CONFIG."
-    "\n"
-    "All configuration files which have been considered by CMake while "
-    "searching for an installation of the package with an appropriate "
-    "version are stored in the cmake variable <package>_CONSIDERED_CONFIGS, "
-    "the associated versions in <package>_CONSIDERED_VERSIONS. "
-    "\n"
-    "If the package configuration file cannot be found CMake "
-    "will generate an error describing the problem unless the QUIET "
-    "argument is specified.  If REQUIRED is specified and the package "
-    "is not found a fatal error is generated and the configure step stops "
-    "executing.  If <package>_DIR has been set to a directory not containing "
-    "a configuration file CMake will ignore it and search from scratch."
-    "\n"
-    "When the [version] argument is given Config mode will only find a "
-    "version of the package that claims compatibility with the requested "
-    "version (format is major[.minor[.patch[.tweak]]]).  "
-    "If the EXACT option is given only a version of the package claiming "
-    "an exact match of the requested version may be found.  "
-    "CMake does not establish any convention for the meaning of version "
-    "numbers.  "
-    "Package version numbers are checked by \"version\" files provided by "
-    "the packages themselves.  "
-    "For a candidate package configuration file \"<config-file>.cmake\" the "
-    "corresponding version file is located next to it and named either "
-    "\"<config-file>-version.cmake\" or \"<config-file>Version.cmake\".  "
-    "If no such version file is available then the configuration file "
-    "is assumed to not be compatible with any requested version.  "
-    "A basic version file containing generic version matching code can be "
-    "created using the macro write_basic_package_version_file(), see its "
-    "documentation for more details.  "
-    "When a version file is found it is loaded to check the requested "
-    "version number.  "
-    "The version file is loaded in a nested scope in which the following "
-    "variables have been defined:\n"
-    "  PACKAGE_FIND_NAME          = the <package> name\n"
-    "  PACKAGE_FIND_VERSION       = full requested version string\n"
-    "  PACKAGE_FIND_VERSION_MAJOR = major version if requested, else 0\n"
-    "  PACKAGE_FIND_VERSION_MINOR = minor version if requested, else 0\n"
-    "  PACKAGE_FIND_VERSION_PATCH = patch version if requested, else 0\n"
-    "  PACKAGE_FIND_VERSION_TWEAK = tweak version if requested, else 0\n"
-    "  PACKAGE_FIND_VERSION_COUNT = number of version components, 0 to 4\n"
-    "The version file checks whether it satisfies the requested version "
-    "and sets these variables:\n"
-    "  PACKAGE_VERSION            = full provided version string\n"
-    "  PACKAGE_VERSION_EXACT      = true if version is exact match\n"
-    "  PACKAGE_VERSION_COMPATIBLE = true if version is compatible\n"
-    "  PACKAGE_VERSION_UNSUITABLE = true if unsuitable as any version\n"
-    "These variables are checked by the find_package command to determine "
-    "whether the configuration file provides an acceptable version.  "
-    "They are not available after the find_package call returns.  "
-    "If the version is acceptable the following variables are set:\n"
-    "  <package>_VERSION       = full provided version string\n"
-    "  <package>_VERSION_MAJOR = major version if provided, else 0\n"
-    "  <package>_VERSION_MINOR = minor version if provided, else 0\n"
-    "  <package>_VERSION_PATCH = patch version if provided, else 0\n"
-    "  <package>_VERSION_TWEAK = tweak version if provided, else 0\n"
-    "  <package>_VERSION_COUNT = number of version components, 0 to 4\n"
-    "and the corresponding package configuration file is loaded.  "
-    "When multiple package configuration files are available whose version "
-    "files claim compatibility with the version requested it is unspecified "
-    "which one is chosen.  "
-    "No attempt is made to choose a highest or closest version number."
-    "\n"
-    "Config mode provides an elaborate interface and search procedure.  "
-    "Much of the interface is provided for completeness and for use "
-    "internally by find-modules loaded by Module mode.  "
-    "Most user code should simply call\n"
-    "  find_package(<package> [major[.minor]] [EXACT] [REQUIRED|QUIET])\n"
-    "in order to find a package.  Package maintainers providing CMake "
-    "package configuration files are encouraged to name and install "
-    "them such that the procedure outlined below will find them "
-    "without requiring use of additional options."
-    "\n"
-    "CMake constructs a set of possible installation prefixes for the "
-    "package.  Under each prefix several directories are searched for a "
-    "configuration file.  The tables below show the directories searched.  "
-    "Each entry is meant for installation trees following Windows (W), "
-    "UNIX (U), or Apple (A) conventions.\n"
-    "  <prefix>/                                               (W)\n"
-    "  <prefix>/(cmake|CMake)/                                 (W)\n"
-    "  <prefix>/<name>*/                                       (W)\n"
-    "  <prefix>/<name>*/(cmake|CMake)/                         (W)\n"
-    "  <prefix>/(lib/<arch>|lib|share)/cmake/<name>*/          (U)\n"
-    "  <prefix>/(lib/<arch>|lib|share)/<name>*/                (U)\n"
-    "  <prefix>/(lib/<arch>|lib|share)/<name>*/(cmake|CMake)/  (U)\n"
-    "On systems supporting OS X Frameworks and Application Bundles "
-    "the following directories are searched for frameworks or bundles "
-    "containing a configuration file:\n"
-    "  <prefix>/<name>.framework/Resources/                    (A)\n"
-    "  <prefix>/<name>.framework/Resources/CMake/              (A)\n"
-    "  <prefix>/<name>.framework/Versions/*/Resources/         (A)\n"
-    "  <prefix>/<name>.framework/Versions/*/Resources/CMake/   (A)\n"
-    "  <prefix>/<name>.app/Contents/Resources/                 (A)\n"
-    "  <prefix>/<name>.app/Contents/Resources/CMake/           (A)\n"
-    "In all cases the <name> is treated as case-insensitive and corresponds "
-    "to any of the names specified (<package> or names given by NAMES).  "
-    "Paths with lib/<arch> are enabled if CMAKE_LIBRARY_ARCHITECTURE is set.  "
-    "If PATH_SUFFIXES is specified the suffixes are appended to each "
-    "(W) or (U) directory entry one-by-one.\n"
-    "This set of directories is intended to work in cooperation with "
-    "projects that provide configuration files in their installation trees.  "
-    "Directories above marked with (W) are intended for installations on "
-    "Windows where the prefix may point at the top of an application's "
-    "installation directory.  Those marked with (U) are intended for "
-    "installations on UNIX platforms where the prefix is shared by "
-    "multiple packages.  This is merely a convention, so all (W) and (U) "
-    "directories are still searched on all platforms.  "
-    "Directories marked with (A) are intended for installations on "
-    "Apple platforms.  The cmake variables CMAKE_FIND_FRAMEWORK and "
-    "CMAKE_FIND_APPBUNDLE determine the order of preference "
-    "as specified below.\n"
-    "The set of installation prefixes is constructed using the following "
-    "steps.  If NO_DEFAULT_PATH is specified all NO_* options are enabled.\n"
-    "1. Search paths specified in cmake-specific cache variables.  "
-    "These are intended to be used on the command line with a -DVAR=value.  "
-    "This can be skipped if NO_CMAKE_PATH is passed.\n"
-    "   CMAKE_PREFIX_PATH\n"
-    "   CMAKE_FRAMEWORK_PATH\n"
-    "   CMAKE_APPBUNDLE_PATH\n"
-    "2. Search paths specified in cmake-specific environment variables.  "
-    "These are intended to be set in the user's shell configuration.  "
-    "This can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n"
-    "   <package>_DIR\n"
-    "   CMAKE_PREFIX_PATH\n"
-    "   CMAKE_FRAMEWORK_PATH\n"
-    "   CMAKE_APPBUNDLE_PATH\n"
-    "3. Search paths specified by the HINTS option.  "
-    "These should be paths computed by system introspection, such as a "
-    "hint provided by the location of another item already found.  "
-    "Hard-coded guesses should be specified with the PATHS option.\n"
-    "4. Search the standard system environment variables. "
-    "This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is passed.  "
-    "Path entries ending in \"/bin\" or \"/sbin\" are automatically "
-    "converted to their parent directories.\n"
-    "   PATH\n"
-    "5. Search project build trees recently configured in a CMake GUI.  "
-    "This can be skipped if NO_CMAKE_BUILDS_PATH is passed.  "
-    "It is intended for the case when a user is building multiple "
-    "dependent projects one after another.\n"
-    "6. Search paths stored in the CMake user package registry.  "
-    "This can be skipped if NO_CMAKE_PACKAGE_REGISTRY is passed.  "
-    "On Windows a <package> may appear under registry key\n"
-    "  HKEY_CURRENT_USER\\Software\\Kitware\\CMake\\Packages\\<package>\n"
-    "as a REG_SZ value, with arbitrary name, that specifies the directory "
-    "containing the package configuration file.  "
-    "On UNIX platforms a <package> may appear under the directory\n"
-    "  ~/.cmake/packages/<package>\n"
-    "as a file, with arbitrary name, whose content specifies the directory "
-    "containing the package configuration file.  "
-    "See the export(PACKAGE) command to create user package registry entries "
-    "for project build trees."
-    "\n"
-    "7. Search cmake variables defined in the Platform files "
-    "for the current system.  This can be skipped if NO_CMAKE_SYSTEM_PATH "
-    "is passed.\n"
-    "   CMAKE_SYSTEM_PREFIX_PATH\n"
-    "   CMAKE_SYSTEM_FRAMEWORK_PATH\n"
-    "   CMAKE_SYSTEM_APPBUNDLE_PATH\n"
-    "8. Search paths stored in the CMake system package registry.  "
-    "This can be skipped if NO_CMAKE_SYSTEM_PACKAGE_REGISTRY is passed.  "
-    "On Windows a <package> may appear under registry key\n"
-    "  HKEY_LOCAL_MACHINE\\Software\\Kitware\\CMake\\Packages\\<package>\n"
-    "as a REG_SZ value, with arbitrary name, that specifies the directory "
-    "containing the package configuration file.  "
-    "There is no system package registry on non-Windows platforms."
-    "\n"
-    "9. Search paths specified by the PATHS option.  "
-    "These are typically hard-coded guesses.\n"
-    ;
-  this->CommandDocumentation += this->GenericDocumentationMacPolicy;
-  this->CommandDocumentation += this->GenericDocumentationRootPath;
-  this->CommandDocumentation += this->GenericDocumentationPathsOrder;
-  this->CommandDocumentation +=
-    "\n"
-    "Every non-REQUIRED find_package() call can be disabled by setting the "
-    "variable CMAKE_DISABLE_FIND_PACKAGE_<package> to TRUE. See the "
-    "documentation for the CMAKE_DISABLE_FIND_PACKAGE_<package> variable for "
-    "more information.\n"
-    "When loading a find module or package configuration file find_package "
-    "defines variables to provide information about the call arguments "
-    "(and restores their original state before returning):\n"
-    " <package>_FIND_REQUIRED      = true if REQUIRED option was given\n"
-    " <package>_FIND_QUIETLY       = true if QUIET option was given\n"
-    " <package>_FIND_VERSION       = full requested version string\n"
-    " <package>_FIND_VERSION_MAJOR = major version if requested, else 0\n"
-    " <package>_FIND_VERSION_MINOR = minor version if requested, else 0\n"
-    " <package>_FIND_VERSION_PATCH = patch version if requested, else 0\n"
-    " <package>_FIND_VERSION_TWEAK = tweak version if requested, else 0\n"
-    " <package>_FIND_VERSION_COUNT = number of version components, 0 to 4\n"
-    " <package>_FIND_VERSION_EXACT = true if EXACT option was given\n"
-    " <package>_FIND_COMPONENTS    = list of requested components\n"
-    " <package>_FIND_REQUIRED_<c>  = true if component <c> is required\n"
-    "                                false if component <c> is optional\n"
-    "In Module mode the loaded find module is responsible to honor the "
-    "request detailed by these variables; see the find module for details.  "
-    "In Config mode find_package handles REQUIRED, QUIET, and version "
-    "options automatically but leaves it to the package configuration file "
-    "to handle components in a way that makes sense for the package.  "
-    "The package configuration file may set <package>_FOUND to false "
-    "to tell find_package that component requirements are not satisfied."
-    "\n"
-    "See the cmake_policy() command documentation for discussion of the "
-    "NO_POLICY_SCOPE option."
-    ;
-}
-
-//----------------------------------------------------------------------------
-const char* cmFindPackageCommand::GetFullDocumentation() const
-{
-  if(this->CommandDocumentation.empty())
-    {
-    const_cast<cmFindPackageCommand *>(this)->GenerateDocumentation();
-    }
-  return this->CommandDocumentation.c_str();
-}
-
 //----------------------------------------------------------------------------
 bool cmFindPackageCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index c3801220d..1ed071069 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -51,22 +51,7 @@ public:
    */
   virtual const char* GetName() const { return "find_package";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Load settings for an external project.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const;
-
   cmTypeMacro(cmFindPackageCommand, cmFindCommon);
-protected:
-  virtual void GenerateDocumentation();
 private:
   void AppendSuccessInformation();
   void AppendToFoundProperty(bool found);
@@ -113,7 +98,6 @@ private:
   struct OriginalDef { bool exists; std::string value; };
   std::map<cmStdString, OriginalDef> OriginalDefs;
 
-  std::string CommandDocumentation;
   cmStdString Name;
   cmStdString Variable;
   cmStdString Version;
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index 6a432984d..845999575 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -20,51 +20,6 @@ cmFindPathCommand::cmFindPathCommand()
   this->IncludeFileInPath = false;
 }
 
-void cmFindPathCommand::GenerateDocumentation()
-{
-  this->cmFindBase::GenerateDocumentation();
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "FIND_XXX", "find_path");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_XXX_PATH", "CMAKE_INCLUDE_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_XXX_MAC_PATH",
-                               "CMAKE_FRAMEWORK_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_MAC_PATH",
-                               "CMAKE_SYSTEM_FRAMEWORK_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_SYSTEM", "INCLUDE");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_PATH",
-                               "CMAKE_SYSTEM_INCLUDE_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX_DESC",
-                               "directory containing the named file");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX", "file in a directory");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_SUBDIR", "include");
-  cmSystemTools::ReplaceString(
-    this->GenericDocumentation,
-    "XXX_EXTRA_PREFIX_ENTRY",
-    "   <prefix>/include/<arch> if CMAKE_LIBRARY_ARCHITECTURE is set, and\n");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
-                               "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE");
-  if(!this->IncludeFileInPath)
-    {
-    this->GenericDocumentation +=
-      "\n"
-      "When searching for frameworks, if the file is specified as "
-      "A/b.h, then the framework search will look for "
-      "A.framework/Headers/b.h. "
-      "If that is found the path will be set to the path to the framework. "
-      "CMake will convert this to the correct -F option to include the "
-      "file. ";
-    }
-}
-
 // cmFindPathCommand
 bool cmFindPathCommand
 ::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
diff --git a/Source/cmFindPathCommand.h b/Source/cmFindPathCommand.h
index 759567dc1..8df4540dc 100644
--- a/Source/cmFindPathCommand.h
+++ b/Source/cmFindPathCommand.h
@@ -51,18 +51,8 @@ public:
    */
   virtual const char* GetName() const {return "find_path";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Find the directory containing a file.";
-    }
-
   cmTypeMacro(cmFindPathCommand, cmFindBase);
   bool IncludeFileInPath;
-protected:
-  virtual void GenerateDocumentation();
 private:
   std::string FindHeaderInFramework(std::string const& file,
                                     std::string const& dir);
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 909b333ff..bb27753b5 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -17,37 +17,6 @@
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
-void cmFindProgramCommand::GenerateDocumentation()
-{
-  this->cmFindBase::GenerateDocumentation();
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "FIND_XXX", "find_program");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_XXX_PATH", "CMAKE_PROGRAM_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_XXX_MAC_PATH",
-                               "CMAKE_APPBUNDLE_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_MAC_PATH",
-                               "CMAKE_SYSTEM_APPBUNDLE_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_SYSTEM", "");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_PATH",
-                               "CMAKE_SYSTEM_PROGRAM_PATH");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX_DESC", "program");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX", "program");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_SUBDIR", "[s]bin");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "XXX_EXTRA_PREFIX_ENTRY", "");
-  cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
-                               "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM");
-}
-
 // cmFindProgramCommand
 bool cmFindProgramCommand
 ::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
diff --git a/Source/cmFindProgramCommand.h b/Source/cmFindProgramCommand.h
index 8350c9b42..7f4811c0a 100644
--- a/Source/cmFindProgramCommand.h
+++ b/Source/cmFindProgramCommand.h
@@ -50,19 +50,10 @@ public:
    */
   virtual const char* GetName() const { return "find_program";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Find an executable program.";
-    }
-
   cmTypeMacro(cmFindProgramCommand, cmFindBase);
 
 protected:
   std::string FindProgram(std::vector<std::string> names);
-  virtual void GenerateDocumentation();
 
 private:
   std::string FindAppBundle(std::vector<std::string> names);
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index dc4761306..e548ba8d8 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -61,52 +61,6 @@ public:
    */
   virtual const char* GetName() const { return "foreach";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Evaluate a group of commands for each value in a list.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  foreach(loop_var arg1 arg2 ...)\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  endforeach(loop_var)\n"
-      "All commands between foreach and the matching endforeach are recorded "
-      "without being invoked.  Once the endforeach is evaluated, the "
-      "recorded list of commands is invoked once for each argument listed "
-      "in the original foreach command.  Before each iteration of the loop "
-      "\"${loop_var}\" will be set as a variable with "
-      "the current value in the list.\n"
-      "  foreach(loop_var RANGE total)\n"
-      "  foreach(loop_var RANGE start stop [step])\n"
-      "Foreach can also iterate over a generated range of numbers. "
-      "There are three types of this iteration:\n"
-      "* When specifying single number, the range will have elements "
-      "0 to \"total\".\n"
-      "* When specifying two numbers, the range will have elements from "
-      "the first number to the second number.\n"
-      "* The third optional number is the increment used to iterate from "
-      "the first number to the second number."
-      "\n"
-      "  foreach(loop_var IN [LISTS [list1 [...]]]\n"
-      "                      [ITEMS [item1 [...]]])\n"
-      "Iterates over a precise list of items.  "
-      "The LISTS option names list-valued variables to be traversed, "
-      "including empty elements (an empty string is a zero-length list).  "
-      "The ITEMS option ends argument parsing and includes all arguments "
-      "following it in the iteration."
-      ;
-    }
-
   cmTypeMacro(cmForEachCommand, cmCommand);
 private:
   bool HandleInMode(std::vector<std::string> const& args);
diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
index a126cd110..85b89d9ab 100644
--- a/Source/cmFunctionCommand.cxx
+++ b/Source/cmFunctionCommand.cxx
@@ -66,24 +66,6 @@ public:
    */
   virtual const char* GetName() const { return this->Args[0].c_str(); }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-  {
-    std::string docs = "Function named: ";
-    docs += this->GetName();
-    return docs.c_str();
-  }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-  {
-    return this->GetTerseDocumentation();
-  }
-
   cmTypeMacro(cmFunctionHelperCommand, cmCommand);
 
   std::vector<std::string> Args;
diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h
index 0a029dc5f..a8bd3e784 100644
--- a/Source/cmFunctionCommand.h
+++ b/Source/cmFunctionCommand.h
@@ -59,46 +59,6 @@ public:
    */
   virtual const char* GetName() const { return "function";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Start recording a function for later invocation as a command.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  function(<name> [arg1 [arg2 [arg3 ...]]])\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  endfunction(<name>)\n"
-      "Define a function named <name> that takes arguments named "
-      "arg1 arg2 arg3 (...).  Commands listed after function, but before "
-      "the matching endfunction, are not invoked until the function "
-      "is invoked.  When it is invoked, the commands recorded in the "
-      "function are first modified by replacing formal parameters (${arg1}) "
-      "with the arguments passed, and then invoked as normal commands. In "
-      "addition to referencing the formal parameters you can reference "
-      "the variable ARGC which will be set to the number of arguments "
-      "passed into the function as well as ARGV0 ARGV1 ARGV2 ... which "
-      "will have the actual values of the arguments passed in. This "
-      "facilitates creating functions with optional arguments. Additionally "
-      "ARGV holds the list of all arguments given to the function and ARGN "
-      "holds the list of arguments past the last expected argument."
-      "\n"
-      "A function opens a new scope: see set(var PARENT_SCOPE) for details."
-      "\n"
-      "See the cmake_policy() command documentation for the behavior of "
-      "policies inside functions."
-      ;
-    }
-
   cmTypeMacro(cmFunctionCommand, cmCommand);
 };
 
diff --git a/Source/cmGetCMakePropertyCommand.h b/Source/cmGetCMakePropertyCommand.h
index b77eaae04..6c58bb44a 100644
--- a/Source/cmGetCMakePropertyCommand.h
+++ b/Source/cmGetCMakePropertyCommand.h
@@ -39,31 +39,6 @@ public:
    */
   virtual const char* GetName() const { return "get_cmake_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a property of the CMake instance.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  get_cmake_property(VAR property)\n"
-        "Get a property from the CMake instance.  "
-        "The value of the property is stored in the variable VAR.  "
-        "If the property is not found, VAR will be set to \"NOTFOUND\".  "
-        "Some supported properties "
-        "include: VARIABLES, CACHE_VARIABLES, COMMANDS, MACROS, and "
-        "COMPONENTS."
-        "\n"
-        "See also the more general get_property() command.";
-    }
-
   cmTypeMacro(cmGetCMakePropertyCommand, cmCommand);
 };
 
diff --git a/Source/cmGetDirectoryPropertyCommand.h b/Source/cmGetDirectoryPropertyCommand.h
index d0d582028..aea04ad17 100644
--- a/Source/cmGetDirectoryPropertyCommand.h
+++ b/Source/cmGetDirectoryPropertyCommand.h
@@ -39,37 +39,6 @@ public:
    */
   virtual const char* GetName() const { return "get_directory_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a property of DIRECTORY scope.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  get_directory_property(<variable> [DIRECTORY <dir>] <prop-name>)\n"
-        "Store a property of directory scope in the named variable.  "
-        "If the property is not defined the empty-string is returned.  "
-        "The DIRECTORY argument specifies another directory from which "
-        "to retrieve the property value.  "
-        "The specified directory must have already been traversed by "
-        "CMake."
-        "\n"
-        "  get_directory_property(<variable> [DIRECTORY <dir>]\n"
-        "                         DEFINITION <var-name>)\n"
-        "Get a variable definition from a directory.  "
-        "This form is useful to get a variable definition from another "
-        "directory."
-        "\n"
-        "See also the more general get_property() command.";
-    }
-
   cmTypeMacro(cmGetDirectoryPropertyCommand, cmCommand);
 };
 
diff --git a/Source/cmGetFilenameComponentCommand.h b/Source/cmGetFilenameComponentCommand.h
index 09af3325a..e2cd21960 100644
--- a/Source/cmGetFilenameComponentCommand.h
+++ b/Source/cmGetFilenameComponentCommand.h
@@ -48,43 +48,6 @@ public:
    */
   virtual const char* GetName() const { return "get_filename_component";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a specific component of a full filename.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  get_filename_component(<VAR> <FileName> <COMP> [CACHE])\n"
-      "Set <VAR> to a component of <FileName>, where <COMP> is one of:\n"
-      " DIRECTORY = Directory without file name\n"
-      " NAME      = File name without directory\n"
-      " EXT       = File name longest extension (.b.c from d/a.b.c)\n"
-      " NAME_WE   = File name without directory or longest extension\n"
-      " ABSOLUTE  = Full path to file\n"
-      " REALPATH  = Full path to existing file with symlinks resolved\n"
-      " PATH      = Legacy alias for DIRECTORY (use for CMake <= 2.8.11)\n"
-      "Paths are returned with forward slashes and have no trailing slahes. "
-      "The longest file extension is always considered. "
-      "If the optional CACHE argument is specified, the result variable is "
-      "added to the cache.\n"
-      "  get_filename_component(<VAR> FileName\n"
-      "                         PROGRAM [PROGRAM_ARGS <ARG_VAR>]\n"
-      "                         [CACHE])\n"
-      "The program in FileName will be found in the system search path or "
-      "left as a full path.  If PROGRAM_ARGS is present with PROGRAM, then "
-      "any command-line arguments present in the FileName string are split "
-      "from the program name and stored in <ARG_VAR>.  This is used to "
-      "separate a program name from its arguments in a command line string.";
-    }
-
   cmTypeMacro(cmGetFilenameComponentCommand, cmCommand);
 };
 
diff --git a/Source/cmGetPropertyCommand.h b/Source/cmGetPropertyCommand.h
index 3c597fdcf..e1630ffb3 100644
--- a/Source/cmGetPropertyCommand.h
+++ b/Source/cmGetPropertyCommand.h
@@ -41,58 +41,6 @@ public:
    */
   virtual const char* GetName() const { return "get_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a property.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  get_property(<variable>\n"
-        "               <GLOBAL             |\n"
-        "                DIRECTORY [dir]    |\n"
-        "                TARGET    <target> |\n"
-        "                SOURCE    <source> |\n"
-        "                TEST      <test>   |\n"
-        "                CACHE     <entry>  |\n"
-        "                VARIABLE>\n"
-        "               PROPERTY <name>\n"
-        "               [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])\n"
-        "Get one property from one object in a scope.  "
-        "The first argument specifies the variable in which to store the "
-        "result.  "
-        "The second argument determines the scope from which to get the "
-        "property.  It must be one of the following:\n"
-        "GLOBAL scope is unique and does not accept a name.\n"
-        "DIRECTORY scope defaults to the current directory but another "
-        "directory (already processed by CMake) may be named by full or "
-        "relative path.\n"
-        "TARGET scope must name one existing target.\n"
-        "SOURCE scope must name one source file.\n"
-        "TEST scope must name one existing test.\n"
-        "CACHE scope must name one cache entry.\n"
-        "VARIABLE scope is unique and does not accept a name.\n"
-        "The required PROPERTY option is immediately followed by the name "
-        "of the property to get.  "
-        "If the property is not set an empty value is returned.  "
-        "If the SET option is given the variable is set to a boolean "
-        "value indicating whether the property has been set.  "
-        "If the DEFINED option is given the variable is set to a boolean "
-        "value indicating whether the property has been defined "
-        "such as with define_property. "
-        "If BRIEF_DOCS or FULL_DOCS is given then the variable is set to "
-        "a string containing documentation for the requested property.  "
-        "If documentation is requested for a property that has not been "
-        "defined NOTFOUND is returned.";
-    }
-
   cmTypeMacro(cmGetPropertyCommand, cmCommand);
 private:
   enum OutType { OutValue, OutDefined, OutBriefDoc, OutFullDoc, OutSet };
diff --git a/Source/cmGetSourceFilePropertyCommand.h b/Source/cmGetSourceFilePropertyCommand.h
index 2ba81037f..338318eb5 100644
--- a/Source/cmGetSourceFilePropertyCommand.h
+++ b/Source/cmGetSourceFilePropertyCommand.h
@@ -34,30 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "get_source_file_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a property for a source file.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  get_source_file_property(VAR file property)\n"
-        "Get a property from a source file.  The value of the property is "
-        "stored in the variable VAR.  If the property is not found, VAR "
-        "will be set to \"NOTFOUND\". Use set_source_files_properties to set "
-        "property values.  Source file properties usually control how the "
-        "file is built. One property that is always there is LOCATION"
-        "\n"
-        "See also the more general get_property() command.";
-    }
-
   cmTypeMacro(cmGetSourceFilePropertyCommand, cmCommand);
 };
 
diff --git a/Source/cmGetTargetPropertyCommand.h b/Source/cmGetTargetPropertyCommand.h
index f5e1aa729..4985b3c62 100644
--- a/Source/cmGetTargetPropertyCommand.h
+++ b/Source/cmGetTargetPropertyCommand.h
@@ -34,32 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "get_target_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a property from a target.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  get_target_property(VAR target property)\n"
-        "Get a property from a target.   The value of the property is "
-        "stored in the variable VAR.  If the property is not found, VAR "
-        "will be set to \"NOTFOUND\".  Use set_target_properties to set "
-        "property values.  Properties are usually used to control how "
-        "a target is built, but some query the target instead.  "
-        "This command can get properties for any target so far created. "
-        "The targets do not need to be in the current CMakeLists.txt file."
-        "\n"
-        "See also the more general get_property() command.";
-    }
-
   cmTypeMacro(cmGetTargetPropertyCommand, cmCommand);
 };
 
diff --git a/Source/cmGetTestPropertyCommand.h b/Source/cmGetTestPropertyCommand.h
index 01f54d951..2dccabe77 100644
--- a/Source/cmGetTestPropertyCommand.h
+++ b/Source/cmGetTestPropertyCommand.h
@@ -34,29 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "get_test_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Get a property of the test.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  get_test_property(test property VAR)\n"
-      "Get a property from the Test.  The value of the property is "
-      "stored in the variable VAR.  If the property is not found, VAR "
-      "will be set to \"NOTFOUND\". For a list of standard properties "
-      "you can type cmake --help-property-list"
-      "\n"
-      "See also the more general get_property() command.";
-    }
-
   cmTypeMacro(cmGetTestPropertyCommand, cmCommand);
 };
 
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index f794b78b8..f2633adc4 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -65,188 +65,11 @@ public:
    */
   virtual const char* GetName() const { return "if";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Conditionally execute a group of commands.";
-    }
-
   /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() const { return true; }
 
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  if(expression)\n"
-      "    # then section.\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  elseif(expression2)\n"
-      "    # elseif section.\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  else(expression)\n"
-      "    # else section.\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  endif(expression)\n"
-      "Evaluates the given expression.  If the result is true, the commands "
-      "in the THEN section are invoked.  Otherwise, the commands in the "
-      "else section are invoked.  The elseif and else sections are "
-      "optional. You may have multiple elseif clauses. Note that "
-      "the expression in the else and endif clause is optional. Long "
-      "expressions can be used and there is a traditional order of "
-      "precedence. "
-      "Parenthetical expressions are evaluated first followed by unary "
-      "operators such as EXISTS, COMMAND, and DEFINED. "
-      "Then any EQUAL, LESS, GREATER, STRLESS, STRGREATER, STREQUAL, MATCHES "
-      "will be evaluated. Then NOT operators and finally AND, OR operators "
-      "will be evaluated. Possible expressions are:\n"
-      "  if(<constant>)\n"
-      "True if the constant is 1, ON, YES, TRUE, Y, or a non-zero number.  "
-      "False if the constant is 0, OFF, NO, FALSE, N, IGNORE, NOTFOUND, '', "
-      "or ends in the suffix '-NOTFOUND'.  "
-      "Named boolean constants are case-insensitive.  "
-      "If the argument is not one of these constants, "
-      "it is treated as a variable:"
-      "\n"
-      "  if(<variable>)\n"
-      "True if the variable is defined to a value that is not a false "
-      "constant.  False otherwise.  "
-      "(Note macro arguments are not variables.)"
-      "\n"
-      "  if(NOT <expression>)\n"
-      "True if the expression is not true."
-      "\n"
-      "  if(<expr1> AND <expr2>)\n"
-      "True if both expressions would be considered true individually."
-      "\n"
-      "  if(<expr1> OR <expr2>)\n"
-      "True if either expression would be considered true individually."
-      "\n"
-      "  if(COMMAND command-name)\n"
-      "True if the given name is a command, macro or function that can be "
-      "invoked.\n"
-      "  if(POLICY policy-id)\n"
-      "True if the given name is an existing policy "
-      "(of the form CMP<NNNN>).\n"
-      "  if(TARGET target-name)\n"
-      "True if the given name is an existing target, built or imported.\n"
-      "  if(EXISTS file-name)\n"
-      "  if(EXISTS directory-name)\n"
-      "True if the named file or directory exists.  "
-      "Behavior is well-defined only for full paths.\n"
-      "  if(file1 IS_NEWER_THAN file2)\n"
-      "True if file1 is newer than file2 or if one of the two files "
-      "doesn't exist. "
-      "Behavior is well-defined only for full paths. "
-      "If the file time stamps are exactly the same, an "
-      "IS_NEWER_THAN comparison returns true, so that any dependent "
-      "build operations will occur in the event of a tie. "
-      "This includes the case of passing the same file name for both "
-      "file1 and file2.\n"
-      "  if(IS_DIRECTORY directory-name)\n"
-      "True if the given name is a directory.  "
-      "Behavior is well-defined only for full paths.\n"
-      "  if(IS_SYMLINK file-name)\n"
-      "True if the given name is a symbolic link.  "
-      "Behavior is well-defined only for full paths.\n"
-      "  if(IS_ABSOLUTE path)\n"
-      "True if the given path is an absolute path.\n"
-      "  if(<variable|string> MATCHES regex)\n"
-      "True if the given string or variable's value matches the given "
-      "regular expression.\n"
-      "  if(<variable|string> LESS <variable|string>)\n"
-      "  if(<variable|string> GREATER <variable|string>)\n"
-      "  if(<variable|string> EQUAL <variable|string>)\n"
-      "True if the given string or variable's value is a valid number and "
-      "the inequality or equality is true.\n"
-      "  if(<variable|string> STRLESS <variable|string>)\n"
-      "  if(<variable|string> STRGREATER <variable|string>)\n"
-      "  if(<variable|string> STREQUAL <variable|string>)\n"
-      "True if the given string or variable's value is lexicographically "
-      "less (or greater, or equal) than the string or variable on the right.\n"
-      "  if(<variable|string> VERSION_LESS <variable|string>)\n"
-      "  if(<variable|string> VERSION_EQUAL <variable|string>)\n"
-      "  if(<variable|string> VERSION_GREATER <variable|string>)\n"
-      "Component-wise integer version number comparison (version format is "
-      "major[.minor[.patch[.tweak]]]).\n"
-      "  if(DEFINED <variable>)\n"
-      "True if the given variable is defined. It does not matter if the "
-      "variable is true or false just if it has been set.\n"
-      "  if((expression) AND (expression OR (expression)))\n"
-      "The expressions inside the parenthesis are evaluated first and "
-      "then the remaining expression is evaluated as in the previous "
-      "examples. Where there are nested parenthesis the innermost are "
-      "evaluated as part of evaluating the expression "
-      "that contains them."
-      "\n"
-
-      "The if command was written very early in CMake's history, predating "
-      "the ${} variable evaluation syntax, and for convenience evaluates "
-      "variables named by its arguments as shown in the above signatures.  "
-      "Note that normal variable evaluation with ${} applies before the "
-      "if command even receives the arguments.  "
-      "Therefore code like\n"
-      "  set(var1 OFF)\n"
-      "  set(var2 \"var1\")\n"
-      "  if(${var2})\n"
-      "appears to the if command as\n"
-      "  if(var1)\n"
-      "and is evaluated according to the if(<variable>) case "
-      "documented above.  "
-      "The result is OFF which is false.  "
-      "However, if we remove the ${} from the example then the command sees\n"
-      "  if(var2)\n"
-      "which is true because var2 is defined to \"var1\" which is not "
-      "a false constant."
-      "\n"
-      "Automatic evaluation applies in the other cases whenever the "
-      "above-documented signature accepts <variable|string>:\n"
-
-      "1) The left hand argument to MATCHES is first checked to see "
-      "if it is a defined variable, if so the variable's value is "
-      "used, otherwise the original value is used. \n"
-
-      "2) If the left hand argument to MATCHES is missing it returns "
-      "false without error \n"
-
-      "3) Both left and right hand arguments to LESS GREATER EQUAL "
-      "are independently tested to see if they are defined variables, "
-      "if so their defined values are used otherwise the original "
-      "value is used. \n"
-
-      "4) Both left and right hand arguments to STRLESS STREQUAL "
-      "STRGREATER are independently tested to see if they are defined "
-      "variables, if so their defined values are used otherwise the "
-      "original value is used. \n"
-
-      "5) Both left and right hand argumemnts to VERSION_LESS "
-      "VERSION_EQUAL VERSION_GREATER are independently tested to see "
-      "if they are defined variables, if so their defined values are "
-      "used otherwise the original value is used. \n"
-
-      "6) The right hand argument to NOT is tested to see if it is a "
-      "boolean constant, if so the value is used, otherwise it is "
-      "assumed to be a variable and it is dereferenced. \n"
-
-      "7) The left and right hand arguments to AND OR are "
-      "independently tested to see if they are boolean constants, if "
-      "so they are used as such, otherwise they are assumed to be "
-      "variables and are dereferenced. \n"
-      ;
-    }
-
   // this is a shared function for both If and Else to determine if the
   // arguments were valid, and if so, was the response true. If there is
   // an error, the errorString will be set.
diff --git a/Source/cmIncludeCommand.h b/Source/cmIncludeCommand.h
index 8ff8b20f3..267723d49 100644
--- a/Source/cmIncludeCommand.h
+++ b/Source/cmIncludeCommand.h
@@ -48,41 +48,6 @@ public:
    */
   virtual const char* GetName() const {return "include";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Load and run CMake code from a file or module.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  include(<file|module> [OPTIONAL] [RESULT_VARIABLE <VAR>]\n"
-      "                        [NO_POLICY_SCOPE])\n"
-      "Load and run CMake code from the file given.  "
-      "Variable reads and writes access the scope of the caller "
-      "(dynamic scoping).  "
-      "If OPTIONAL is present, then no error "
-      "is raised if the file does not exist.  If RESULT_VARIABLE is given "
-      "the variable will be set to the full filename which "
-      "has been included or NOTFOUND if it failed.\n"
-      "If a module is specified instead of a file, the file with name "
-      "<modulename>.cmake is searched first in CMAKE_MODULE_PATH, then in the "
-      "CMake module directory. There is one exception to this: if the file "
-      "which calls include() is located itself in the CMake module directory, "
-      "then first the CMake module directory is searched and "
-      "CMAKE_MODULE_PATH afterwards. See also policy CMP0017."
-      "\n"
-      "See the cmake_policy() command documentation for discussion of the "
-      "NO_POLICY_SCOPE option."
-      ;
-    }
-
   cmTypeMacro(cmIncludeCommand, cmCommand);
 };
 
diff --git a/Source/cmIncludeDirectoryCommand.h b/Source/cmIncludeDirectoryCommand.h
index 77a340a64..c621dcbc7 100644
--- a/Source/cmIncludeDirectoryCommand.h
+++ b/Source/cmIncludeDirectoryCommand.h
@@ -43,44 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "include_directories";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Add include directories to the build.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  include_directories([AFTER|BEFORE] [SYSTEM] dir1 dir2 ...)\n"
-      "Add the given directories to those the compiler uses to search "
-      "for include files.  Relative paths are interpreted as relative to "
-      "the current source directory. \n"
-      "The include directories are added to the directory property "
-      "INCLUDE_DIRECTORIES for the current CMakeLists file. "
-      "They are also added to the target property INCLUDE_DIRECTORIES "
-      "for each target in the current CMakeLists file. "
-      "The target property values are the ones used by the generators."
-      "\n"
-      "By default the directories are appended onto the current list of "
-      "directories. "
-      "This default behavior can be changed by setting "
-      "CMAKE_INCLUDE_DIRECTORIES_BEFORE to ON. "
-      "By using AFTER or BEFORE explicitly, you can select between "
-      "appending and prepending, independent of the default. "
-      "\n"
-      "If the SYSTEM option is given, the compiler will be told the "
-      "directories are meant as system include directories on some "
-      "platforms (signalling this setting might achieve effects such as "
-      "the compiler skipping warnings, or these fixed-install system files "
-      "not being considered in dependency calculations - see compiler docs).";
-    }
-
   cmTypeMacro(cmIncludeDirectoryCommand, cmCommand);
 
 protected:
diff --git a/Source/cmIncludeExternalMSProjectCommand.h b/Source/cmIncludeExternalMSProjectCommand.h
index d5cec01eb..8ca674fb1 100644
--- a/Source/cmIncludeExternalMSProjectCommand.h
+++ b/Source/cmIncludeExternalMSProjectCommand.h
@@ -44,38 +44,6 @@ public:
    */
   virtual const char* GetName() const {return "include_external_msproject";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Include an external Microsoft project file in a workspace.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  include_external_msproject(projectname location\n"
-      "                             [TYPE projectTypeGUID]\n"
-      "                             [GUID projectGUID]\n"
-      "                             [PLATFORM platformName]\n"
-      "                             dep1 dep2 ...)\n"
-      "Includes an external Microsoft project in the generated workspace "
-      "file.  Currently does nothing on UNIX. This will create a "
-      "target named [projectname].  This can be used in the add_dependencies "
-      "command to make things depend on the external project."
-      "\n"
-      "TYPE, GUID and PLATFORM are optional parameters that allow one "
-      "to specify the type of project, id (GUID) of the project and "
-      "the name of the target platform.  "
-      "This is useful for projects requiring values other than the default "
-      "(e.g. WIX projects). "
-      "These options are not supported by the Visual Studio 6 generator.";
-    }
-
   cmTypeMacro(cmIncludeExternalMSProjectCommand, cmCommand);
 };
 
diff --git a/Source/cmIncludeRegularExpressionCommand.h b/Source/cmIncludeRegularExpressionCommand.h
index 2e4177548..0c5fa6f93 100644
--- a/Source/cmIncludeRegularExpressionCommand.h
+++ b/Source/cmIncludeRegularExpressionCommand.h
@@ -43,30 +43,6 @@ public:
    */
   virtual const char* GetName() const {return "include_regular_expression";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set the regular expression used for dependency checking.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  include_regular_expression(regex_match [regex_complain])\n"
-      "Set the regular expressions used in dependency checking.  Only files "
-      "matching regex_match will be traced as dependencies.  Only files "
-      "matching regex_complain will generate warnings if they cannot be "
-      "found "
-      "(standard header paths are not searched).  The defaults are:\n"
-      "  regex_match    = \"^.*$\" (match everything)\n"
-      "  regex_complain = \"^$\" (match empty string only)";
-    }
-
   cmTypeMacro(cmIncludeRegularExpressionCommand, cmCommand);
 };
 
diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h
index 65095011f..9db2490ba 100644
--- a/Source/cmInstallCommand.h
+++ b/Source/cmInstallCommand.h
@@ -43,307 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "install";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Specify rules to run at install time.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "This command generates installation rules for a project.  "
-      "Rules specified by calls to this command within a source directory "
-      "are executed in order during installation.  "
-      "The order across directories is not defined."
-      "\n"
-      "There are multiple signatures for this command.  Some of them define "
-      "installation properties for files and targets.  Properties common to "
-      "multiple signatures are covered here but they are valid only for "
-      "signatures that specify them.\n"
-      "DESTINATION arguments specify "
-      "the directory on disk to which a file will be installed.  "
-      "If a full path (with a leading slash or drive letter) is given it "
-      "is used directly.  If a relative path is given it is interpreted "
-      "relative to the value of CMAKE_INSTALL_PREFIX. The prefix can "
-      "be relocated at install time using DESTDIR mechanism explained in the "
-      "CMAKE_INSTALL_PREFIX variable documentation.\n"
-      "PERMISSIONS arguments specify permissions for installed files.  "
-      "Valid permissions are "
-      "OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, "
-      "GROUP_READ, GROUP_WRITE, GROUP_EXECUTE, "
-      "WORLD_READ, WORLD_WRITE, WORLD_EXECUTE, "
-      "SETUID, and SETGID.  "
-      "Permissions that do not make sense on certain platforms are ignored "
-      "on those platforms.\n"
-      "The CONFIGURATIONS argument specifies a list of build configurations "
-      "for which the install rule applies (Debug, Release, etc.).\n"
-      "The COMPONENT argument specifies an installation component name "
-      "with which the install rule is associated, such as \"runtime\" or "
-      "\"development\".  During component-specific installation only "
-      "install rules associated with the given component name will be "
-      "executed.  During a full installation all components are installed."
-      " If COMPONENT is not provided a default component \"Unspecified\" is"
-      " created. The default component name may be controlled with the "
-      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME variable.\n"
-      "The RENAME argument specifies a name for an installed file that "
-      "may be different from the original file.  Renaming is allowed only "
-      "when a single file is installed by the command.\n"
-      "The OPTIONAL argument specifies that it is not an error if the "
-      "file to be installed does not exist.  "
-      "\n"
-      "The TARGETS signature:\n"
-      "  install(TARGETS targets... [EXPORT <export-name>]\n"
-      "          [[ARCHIVE|LIBRARY|RUNTIME|FRAMEWORK|BUNDLE|\n"
-      "            PRIVATE_HEADER|PUBLIC_HEADER|RESOURCE]\n"
-      "           [DESTINATION <dir>]\n"
-      "           [INCLUDES DESTINATION [<dir> ...]]\n"
-      "           [PERMISSIONS permissions...]\n"
-      "           [CONFIGURATIONS [Debug|Release|...]]\n"
-      "           [COMPONENT <component>]\n"
-      "           [OPTIONAL] [NAMELINK_ONLY|NAMELINK_SKIP]\n"
-      "          ] [...])\n"
-      "The TARGETS form specifies rules for installing targets from a "
-      "project.  There are five kinds of target files that may be "
-      "installed: ARCHIVE, LIBRARY, RUNTIME, FRAMEWORK, and BUNDLE.  "
-
-      "Executables are treated as RUNTIME targets, except that those "
-      "marked with the MACOSX_BUNDLE property are treated as BUNDLE "
-      "targets on OS X. "
-      "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, except that those marked with the FRAMEWORK property "
-      "are treated as FRAMEWORK targets on OS X.  "
-      "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. "
-      "The ARCHIVE, LIBRARY, RUNTIME, and FRAMEWORK "
-      "arguments change the type of target to which the subsequent "
-      "properties "
-      "apply.  If none is given the installation properties apply to "
-      "all target types.  If only one is given then only targets of that "
-      "type will be installed (which can be used to install just a DLL or "
-      "just an import library)."
-      "The INCLUDES DESTINATION specifies a list of directories which will "
-      "be added to the INTERFACE_INCLUDE_DIRECTORIES of the <targets> when "
-      "exported by install(EXPORT).  If a relative path is specified, it is "
-      "treated as relative to the $<INSTALL_PREFIX>."
-      "\n"
-      "The PRIVATE_HEADER, PUBLIC_HEADER, and RESOURCE arguments cause "
-      "subsequent properties to be applied to installing a FRAMEWORK "
-      "shared library target's associated files on non-Apple platforms.  "
-      "Rules defined by these arguments are ignored on Apple platforms "
-      "because the associated files are installed into the appropriate "
-      "locations inside the framework folder.  "
-      "See documentation of the PRIVATE_HEADER, PUBLIC_HEADER, and RESOURCE "
-      "target properties for details."
-      "\n"
-      "Either NAMELINK_ONLY or NAMELINK_SKIP may be specified as a LIBRARY "
-      "option.  "
-      "On some platforms a versioned shared library has a symbolic link "
-      "such as\n"
-      "  lib<name>.so -> lib<name>.so.1\n"
-      "where \"lib<name>.so.1\" is the soname of the library and "
-      "\"lib<name>.so\" is a \"namelink\" allowing linkers to find the "
-      "library when given \"-l<name>\".  "
-      "The NAMELINK_ONLY option causes installation of only the namelink "
-      "when a library target is installed.  "
-      "The NAMELINK_SKIP option causes installation of library files other "
-      "than the namelink when a library target is installed.  "
-      "When neither option is given both portions are installed.  "
-      "On platforms where versioned shared libraries do not have namelinks "
-      "or when a library is not versioned the NAMELINK_SKIP option installs "
-      "the library and the NAMELINK_ONLY option installs nothing.  "
-      "See the VERSION and SOVERSION target properties for details on "
-      "creating versioned shared libraries."
-      "\n"
-      "One or more groups of properties may be specified in a single call "
-      "to the TARGETS form of this command.  A target may be installed more "
-      "than once to different locations.  Consider hypothetical "
-      "targets \"myExe\", \"mySharedLib\", and \"myStaticLib\".  The code\n"
-      "    install(TARGETS myExe mySharedLib myStaticLib\n"
-      "            RUNTIME DESTINATION bin\n"
-      "            LIBRARY DESTINATION lib\n"
-      "            ARCHIVE DESTINATION lib/static)\n"
-      "    install(TARGETS mySharedLib DESTINATION /some/full/path)\n"
-      "will install myExe to <prefix>/bin and myStaticLib to "
-      "<prefix>/lib/static.  "
-      "On non-DLL platforms mySharedLib will be installed to <prefix>/lib "
-      "and /some/full/path.  On DLL platforms the mySharedLib DLL will be "
-      "installed to <prefix>/bin and /some/full/path and its import library "
-      "will be installed to <prefix>/lib/static and /some/full/path."
-      "\n"
-      "The EXPORT option associates the installed target files with an "
-      "export called <export-name>.  "
-      "It must appear before any RUNTIME, LIBRARY, or ARCHIVE options.  "
-      "To actually install the export file itself, call install(EXPORT).  "
-      "See documentation of the install(EXPORT ...) signature below for "
-      "details."
-      "\n"
-      "Installing a target with EXCLUDE_FROM_ALL set to true has "
-      "undefined behavior."
-      "\n"
-      "The FILES signature:\n"
-      "  install(FILES files... DESTINATION <dir>\n"
-      "          [PERMISSIONS permissions...]\n"
-      "          [CONFIGURATIONS [Debug|Release|...]]\n"
-      "          [COMPONENT <component>]\n"
-      "          [RENAME <name>] [OPTIONAL])\n"
-      "The FILES form specifies rules for installing files for a "
-      "project.  File names given as relative paths are interpreted with "
-      "respect to the current source directory.  Files installed by this "
-      "form are by default given permissions OWNER_WRITE, OWNER_READ, "
-      "GROUP_READ, and WORLD_READ if no PERMISSIONS argument is given."
-      "\n"
-      "The PROGRAMS signature:\n"
-      "  install(PROGRAMS files... DESTINATION <dir>\n"
-      "          [PERMISSIONS permissions...]\n"
-      "          [CONFIGURATIONS [Debug|Release|...]]\n"
-      "          [COMPONENT <component>]\n"
-      "          [RENAME <name>] [OPTIONAL])\n"
-      "The PROGRAMS form is identical to the FILES form except that the "
-      "default permissions for the installed file also include "
-      "OWNER_EXECUTE, GROUP_EXECUTE, and WORLD_EXECUTE.  "
-      "This form is intended to install programs that are not targets, "
-      "such as shell scripts.  Use the TARGETS form to install targets "
-      "built within the project."
-      "\n"
-      "The DIRECTORY signature:\n"
-      "  install(DIRECTORY dirs... DESTINATION <dir>\n"
-      "          [FILE_PERMISSIONS permissions...]\n"
-      "          [DIRECTORY_PERMISSIONS permissions...]\n"
-      "          [USE_SOURCE_PERMISSIONS] [OPTIONAL]\n"
-      "          [CONFIGURATIONS [Debug|Release|...]]\n"
-      "          [COMPONENT <component>] [FILES_MATCHING]\n"
-      "          [[PATTERN <pattern> | REGEX <regex>]\n"
-      "           [EXCLUDE] [PERMISSIONS permissions...]] [...])\n"
-      "The DIRECTORY form installs contents of one or more directories "
-      "to a given destination.  "
-      "The directory structure is copied verbatim to the destination.  "
-      "The last component of each directory name is appended to the "
-      "destination directory but a trailing slash may be used to "
-      "avoid this because it leaves the last component empty.  "
-      "Directory names given as relative paths are interpreted with "
-      "respect to the current source directory.  "
-      "If no input directory names are given the destination directory "
-      "will be created but nothing will be installed into it.  "
-      "The FILE_PERMISSIONS and DIRECTORY_PERMISSIONS options specify "
-      "permissions given to files and directories in the destination.  "
-      "If USE_SOURCE_PERMISSIONS is specified and FILE_PERMISSIONS is not, "
-      "file permissions will be copied from the source directory structure.  "
-      "If no permissions are specified files will be given the default "
-      "permissions specified in the FILES form of the command, and the "
-      "directories will be given the default permissions specified in the "
-      "PROGRAMS form of the command.\n"
-
-      "Installation of directories may be controlled with fine granularity "
-      "using the PATTERN or REGEX options.  These \"match\" options specify a "
-      "globbing pattern or regular expression to match directories or files "
-      "encountered within input directories.  They may be used to apply "
-      "certain options (see below) to a subset of the files and directories "
-      "encountered.  "
-      "The full path to each input file or directory "
-      "(with forward slashes) is matched against the expression.  "
-      "A PATTERN will match only complete file names: the portion of the "
-      "full path matching the pattern must occur at the end of the file name "
-      "and be preceded by a slash.  "
-      "A REGEX will match any portion of the full path but it may use "
-      "'/' and '$' to simulate the PATTERN behavior.  "
-      "By default all files and directories are installed whether "
-      "or not they are matched.  "
-      "The FILES_MATCHING option may be given before the first match option "
-      "to disable installation of files (but not directories) not matched by "
-      "any expression.  For example, the code\n"
-      "  install(DIRECTORY src/ DESTINATION include/myproj\n"
-      "          FILES_MATCHING PATTERN \"*.h\")\n"
-      "will extract and install header files from a source tree.\n"
-      "Some options may follow a PATTERN or REGEX expression and are "
-      "applied only to files or directories matching them.  "
-      "The EXCLUDE option will skip the matched file or directory.  "
-      "The PERMISSIONS option overrides the permissions setting for the "
-      "matched file or directory.  "
-      "For example the code\n"
-      "  install(DIRECTORY icons scripts/ DESTINATION share/myproj\n"
-      "          PATTERN \"CVS\" EXCLUDE\n"
-      "          PATTERN \"scripts/*\"\n"
-      "          PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ\n"
-      "                      GROUP_EXECUTE GROUP_READ)\n"
-      "will install the icons directory to share/myproj/icons and the "
-      "scripts directory to share/myproj.  The icons will get default file "
-      "permissions, the scripts will be given specific permissions, and "
-      "any CVS directories will be excluded."
-      "\n"
-      "The SCRIPT and CODE signature:\n"
-      "  install([[SCRIPT <file>] [CODE <code>]] [...])\n"
-      "The SCRIPT form will invoke the given CMake script files during "
-      "installation.  If the script file name is a relative path "
-      "it will be interpreted with respect to the current source directory.  "
-      "The CODE form will invoke the given CMake code during installation.  "
-      "Code is specified as a single argument inside a double-quoted string. "
-      "For example, the code\n"
-      "  install(CODE \"MESSAGE(\\\"Sample install message.\\\")\")\n"
-      "will print a message during installation.\n"
-      ""
-      "The EXPORT signature:\n"
-      "  install(EXPORT <export-name> DESTINATION <dir>\n"
-      "          [NAMESPACE <namespace>] [FILE <name>.cmake]\n"
-      "          [PERMISSIONS permissions...]\n"
-      "          [CONFIGURATIONS [Debug|Release|...]]\n"
-      "          [EXPORT_LINK_INTERFACE_LIBRARIES]\n"
-      "          [COMPONENT <component>])\n"
-      "The EXPORT form generates and installs a CMake file containing code "
-      "to import targets from the installation tree into another project.  "
-      "Target installations are associated with the export <export-name> "
-      "using the EXPORT option of the install(TARGETS ...) signature "
-      "documented above.  The NAMESPACE option will prepend <namespace> to "
-      "the target names as they are written to the import file.  "
-      "By default the generated file will be called <export-name>.cmake but "
-      "the FILE option may be used to specify a different name.  The value "
-      "given to the FILE option must be a file name with the \".cmake\" "
-      "extension.  "
-      "If a CONFIGURATIONS option is given then the file will only be "
-      "installed when one of the named configurations is installed.  "
-      "Additionally, the generated import file will reference only the "
-      "matching target configurations.  "
-      "The EXPORT_LINK_INTERFACE_LIBRARIES keyword, if present, causes the "
-      "contents of the properties matching "
-      "(IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)? to be exported, when "
-      "policy CMP0022 is NEW.  "
-      "If a COMPONENT option is specified that does not match that given "
-      "to the targets associated with <export-name> the behavior is "
-      "undefined.  "
-      "If a library target is included in the export but "
-      "a target to which it links is not included the behavior is "
-      "unspecified."
-      "\n"
-      "The EXPORT form is useful to help outside projects use targets built "
-      "and installed by the current project.  For example, the code\n"
-      "  install(TARGETS myexe EXPORT myproj DESTINATION bin)\n"
-      "  install(EXPORT myproj NAMESPACE mp_ DESTINATION lib/myproj)\n"
-      "will install the executable myexe to <prefix>/bin and code to import "
-      "it in the file \"<prefix>/lib/myproj/myproj.cmake\".  "
-      "An outside project may load this file with the include command "
-      "and reference the myexe executable from the installation tree using "
-      "the imported target name mp_myexe as if the target were built "
-      "in its own tree."
-      "\n"
-      "NOTE: This command supercedes the INSTALL_TARGETS command and the "
-      "target properties PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT.  "
-      "It also replaces the FILES forms of the INSTALL_FILES and "
-      "INSTALL_PROGRAMS commands.  "
-      "The processing order of these install rules relative to those "
-      "generated by INSTALL_TARGETS, INSTALL_FILES, and INSTALL_PROGRAMS "
-      "commands is not defined.\n"
-      ;
-    }
-
   cmTypeMacro(cmInstallCommand, cmCommand);
 
 private:
diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h
index bb0a6ccaf..5583fe455 100644
--- a/Source/cmInstallFilesCommand.h
+++ b/Source/cmInstallFilesCommand.h
@@ -43,14 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "install_files";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated.  Use the install(FILES ) command instead.";
-    }
-
   /**
    * This is called at the end after all the information
    * specified by the command is accumulated. Most commands do
@@ -60,37 +52,6 @@ public:
   virtual void FinalPass();
   virtual bool HasFinalPass() const { return !this->IsFilesForm; }
 
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "This command has been superceded by the install command.  It "
-      "is provided for compatibility with older CMake code.  "
-      "The FILES form is directly replaced by the FILES form of the "
-      "install command.  The regexp form can be expressed "
-      "more clearly using the GLOB form of the file command.\n"
-      "  install_files(<dir> extension file file ...)\n"
-      "Create rules to install the listed files with the given extension "
-      "into the given directory.  "
-      "Only files existing in the current source tree or its corresponding "
-      "location in the binary tree may be listed.  "
-      "If a file specified already has an extension, that extension will be "
-      "removed first.  This is useful for providing lists of source files "
-      "such as foo.cxx when you want the corresponding foo.h to be "
-      "installed. A typical extension is '.h'.\n"
-      "  install_files(<dir> regexp)\n"
-      "Any files in the current source directory that match the regular "
-      "expression will be installed.\n"
-      "  install_files(<dir> FILES file file ...)\n"
-      "Any files listed after the FILES keyword will be "
-      "installed explicitly from the names given.  Full paths are allowed in "
-      "this form.\n"
-      "The directory <dir> is relative to the installation prefix, which "
-      "is stored in the variable CMAKE_INSTALL_PREFIX.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h
index 27a0498e5..95acfa298 100644
--- a/Source/cmInstallProgramsCommand.h
+++ b/Source/cmInstallProgramsCommand.h
@@ -43,14 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "install_programs";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the install(PROGRAMS ) command instead.";
-    }
-
   /**
    * This is called at the end after all the information
    * specified by the command is accumulated. Most commands do
@@ -61,33 +53,6 @@ public:
 
   virtual bool HasFinalPass() const { return true; }
 
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "This command has been superceded by the install command.  It "
-      "is provided for compatibility with older CMake code.  "
-      "The FILES form is directly replaced by the PROGRAMS form of the "
-      "INSTALL command.  The regexp form can be expressed more clearly "
-      "using the GLOB form of the FILE command.\n"
-      "  install_programs(<dir> file1 file2 [file3 ...])\n"
-      "  install_programs(<dir> FILES file1 [file2 ...])\n"
-      "Create rules to install the listed programs into the given directory. "
-      "Use the FILES argument to guarantee that the file list version of "
-      "the command will be used even when there is only one argument.\n"
-      "  install_programs(<dir> regexp)\n"
-      "In the second form any program in the current source directory that "
-      "matches the regular expression will be installed.\n"
-      "This command is intended to install programs that are not built "
-      "by cmake, such as shell scripts.  See the TARGETS form of "
-      "the INSTALL command to "
-      "create installation rules for targets built by cmake.\n"
-      "The directory <dir> is relative to the installation prefix, which "
-      "is stored in the variable CMAKE_INSTALL_PREFIX.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmInstallTargetsCommand.h b/Source/cmInstallTargetsCommand.h
index c47b38700..2aa34dbe3 100644
--- a/Source/cmInstallTargetsCommand.h
+++ b/Source/cmInstallTargetsCommand.h
@@ -44,30 +44,6 @@ public:
    */
   virtual const char* GetName() const { return "install_targets";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the install(TARGETS )  command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "This command has been superceded by the install command.  It "
-      "is provided for compatibility with older CMake code.\n"
-      "  install_targets(<dir> [RUNTIME_DIRECTORY dir] target target)\n"
-      "Create rules to install the listed targets into the given directory.  "
-      "The directory <dir> is relative to the installation prefix, which "
-      "is stored in the variable CMAKE_INSTALL_PREFIX. If RUNTIME_DIRECTORY "
-      "is specified, then on systems with special runtime files "
-      "(Windows DLL), the files will be copied to that directory.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmLinkDirectoriesCommand.h b/Source/cmLinkDirectoriesCommand.h
index 9218f448d..c6eb40ce5 100644
--- a/Source/cmLinkDirectoriesCommand.h
+++ b/Source/cmLinkDirectoriesCommand.h
@@ -45,33 +45,6 @@ public:
    */
   virtual const char* GetName() const { return "link_directories";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Specify directories in which the linker will look for libraries.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  link_directories(directory1 directory2 ...)\n"
-      "Specify the paths in which the linker should search for libraries. "
-      "The command will apply only to targets created after it is called. "
-      "Relative paths given to this command are interpreted as relative to "
-      "the current source directory, see CMP0015. \n"
-      "Note that this command is rarely necessary.  Library locations "
-      "returned by find_package() and find_library() are absolute paths.  "
-      "Pass these absolute library file paths directly to the "
-      "target_link_libraries() command.  CMake will ensure the linker finds "
-      "them."
-      ;
-    }
-
   cmTypeMacro(cmLinkDirectoriesCommand, cmCommand);
 private:
   void AddLinkDir(std::string const& dir);
diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h
index c450a1cb9..74de23c53 100644
--- a/Source/cmLinkLibrariesCommand.h
+++ b/Source/cmLinkLibrariesCommand.h
@@ -44,31 +44,6 @@ public:
    */
   virtual const char* GetName() const { return "link_libraries";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the target_link_libraries() command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "Link libraries to all targets added later.\n"
-      "  link_libraries(library1 <debug | optimized> library2 ...)\n"
-      "Specify a list of libraries to be linked into "
-      "any following targets (typically added with the add_executable "
-      "or add_library calls).  This command is passed "
-      "down to all subdirectories.  "
-      "The debug and optimized strings may be used to indicate that "
-      "the next library listed is to be used only for that specific "
-      "type of build.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h
index 55236332b..0cb5da2a7 100644
--- a/Source/cmListCommand.h
+++ b/Source/cmListCommand.h
@@ -46,66 +46,6 @@ public:
    */
   virtual const char* GetName() const { return "list";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "List operations.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  list(LENGTH <list> <output variable>)\n"
-      "  list(GET <list> <element index> [<element index> ...]\n"
-      "       <output variable>)\n"
-      "  list(APPEND <list> [<element> ...])\n"
-      "  list(FIND <list> <value> <output variable>)\n"
-      "  list(INSERT <list> <element_index> <element> [<element> ...])\n"
-      "  list(REMOVE_ITEM <list> <value> [<value> ...])\n"
-      "  list(REMOVE_AT <list> <index> [<index> ...])\n"
-      "  list(REMOVE_DUPLICATES <list>)\n"
-      "  list(REVERSE <list>)\n"
-      "  list(SORT <list>)\n"
-      "LENGTH will return a given list's length.\n"
-      "GET will return list of elements specified by indices from the list.\n"
-      "APPEND will append elements to the list.\n"
-      "FIND will return the index of the element specified in the list or -1 "
-      "if it wasn't found.\n"
-      "INSERT will insert elements to the list to the specified location.\n"
-      "REMOVE_AT and REMOVE_ITEM will remove items from the list. The "
-      "difference is that REMOVE_ITEM will remove the given items, while "
-      "REMOVE_AT will remove the items at the given indices.\n"
-      "REMOVE_DUPLICATES will remove duplicated items in the list.\n"
-      "REVERSE reverses the contents of the list in-place.\n"
-      "SORT sorts the list in-place alphabetically.\n"
-      "The list subcommands APPEND, INSERT, REMOVE_AT, REMOVE_ITEM, "
-      "REMOVE_DUPLICATES, REVERSE and SORT may create new values for "
-      "the list within the current CMake variable scope. Similar to "
-      "the SET command, the LIST command creates new variable values "
-      "in the current scope, even if the list itself is actually "
-      "defined in a parent scope. To propagate the results of these "
-      "operations upwards, use SET with PARENT_SCOPE, SET with CACHE "
-      "INTERNAL, or some other means of value propagation.\n"
-      "NOTES: A list in cmake is a ; separated group of strings. "
-      "To create a list the set command can be used. For example, "
-      "set(var a b c d e)  creates a list with a;b;c;d;e, and "
-      "set(var \"a b c d e\") creates a string or a list with one "
-      "item in it.\n"
-      "When specifying index values, if <element index> is 0 or"
-      " greater, it is indexed from the "
-      "beginning of the list, with 0 representing the first list element. "
-      "If <element index> is -1 or lesser, it is indexed from the end of "
-      "the list, with -1 representing the last list element. Be careful "
-      "when counting with negative indices: they do not start from 0. "
-      "-0 is equivalent to 0, the first list element.\n"
-      ;
-    }
-
   cmTypeMacro(cmListCommand, cmCommand);
 protected:
   bool HandleLengthCommand(std::vector<std::string> const& args);
diff --git a/Source/cmLoadCacheCommand.h b/Source/cmLoadCacheCommand.h
index f55cbb3c1..c8f72362d 100644
--- a/Source/cmLoadCacheCommand.h
+++ b/Source/cmLoadCacheCommand.h
@@ -42,39 +42,6 @@ public:
    */
   virtual const char* GetName() const { return "load_cache";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Load in the values from another project's CMake cache.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  load_cache(pathToCacheFile READ_WITH_PREFIX\n"
-      "             prefix entry1...)\n"
-      "Read the cache and store the requested entries in variables with "
-      "their name prefixed with the given prefix.  "
-      "This only reads the values, and does not create entries in the local "
-      "project's cache.\n"
-      "  load_cache(pathToCacheFile [EXCLUDE entry1...]\n"
-      "             [INCLUDE_INTERNALS entry1...])\n"
-      "Load in the values from another cache and store them in the local "
-      "project's cache as internal entries.  This is useful for a project "
-      "that depends on another project built in a different tree.  "
-      "EXCLUDE option can be used to provide a list of entries to be "
-      "excluded.  "
-      "INCLUDE_INTERNALS can be used to provide a list of internal entries "
-      "to be included.  Normally, no internal entries are brought in.  Use "
-      "of this form of the command is strongly discouraged, but it is "
-      "provided for backward compatibility.";
-    }
-
   cmTypeMacro(cmLoadCacheCommand, cmCommand);
 protected:
 
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index b2acf06ad..84dd299e4 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -71,23 +71,6 @@ public:
    */
   virtual const char* GetName() const { return info.Name; }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-      if (this->info.GetTerseDocumentation)
-        {
-        cmLoadedCommand::InstallSignalHandlers(info.Name);
-        const char* ret = info.GetTerseDocumentation();
-        cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
-        return ret;
-        }
-      else
-        {
-        return "LoadedCommand without any additional documentation";
-        }
-    }
   static const char* LastName;
   static void TrapsForSignals(int sig)
     {
@@ -120,24 +103,6 @@ public:
         }
     }
 
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      if (this->info.GetFullDocumentation)
-        {
-        cmLoadedCommand::InstallSignalHandlers(info.Name);
-        const char* ret = info.GetFullDocumentation();
-        cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
-        return ret;
-        }
-      else
-        {
-        return "LoadedCommand without any additional documentation";
-        }
-    }
-
   cmTypeMacro(cmLoadedCommand, cmCommand);
 
   cmLoadedCommandInfo info;
diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h
index f0b34ee59..918f32b03 100644
--- a/Source/cmLoadCommandCommand.h
+++ b/Source/cmLoadCommandCommand.h
@@ -42,31 +42,6 @@ public:
    */
   virtual const char* GetName() const {return "load_command";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Load a command into a running CMake.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  load_command(COMMAND_NAME <loc1> [loc2 ...])\n"
-      "The given locations are searched for a library whose name is "
-      "cmCOMMAND_NAME.  If found, it is loaded as a module and the command "
-      "is added to the set of available CMake commands.  Usually, "
-      "TRY_COMPILE is used before this command to compile the module. "
-      "If the command is successfully loaded a variable named\n"
-      "  CMAKE_LOADED_COMMAND_<COMMAND_NAME>\n"
-      "will be set to the full path of the module that was loaded.  "
-      "Otherwise the variable will not be set.";
-    }
-
   cmTypeMacro(cmLoadCommandCommand, cmCommand);
 };
 
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index 8ba612cc9..fd6537fa6 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -67,24 +67,6 @@ public:
    */
   virtual const char* GetName() const { return this->Args[0].c_str(); }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-  {
-    std::string docs = "Macro named: ";
-    docs += this->GetName();
-    return docs.c_str();
-  }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-  {
-    return this->GetTerseDocumentation();
-  }
-
   cmTypeMacro(cmMacroHelperCommand, cmCommand);
 
   std::vector<std::string> Args;
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index aedbb4ddc..4c585d850 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -59,50 +59,6 @@ public:
    */
   virtual const char* GetName() const { return "macro";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Start recording a macro for later invocation as a command.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  macro(<name> [arg1 [arg2 [arg3 ...]]])\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  endmacro(<name>)\n"
-      "Define a macro named <name> that takes arguments named "
-      "arg1 arg2 arg3 (...).  Commands listed after macro, "
-      "but before the matching endmacro, are not invoked until the macro "
-      "is invoked.  When it is invoked, the commands recorded in the "
-      "macro are first modified by replacing formal parameters (${arg1}) "
-      "with the arguments passed, and then invoked as normal commands. In "
-      "addition to referencing the formal parameters you can reference "
-      "the values ${ARGC} which will be set to the number of arguments "
-      "passed into the function as well as ${ARGV0} ${ARGV1} ${ARGV2} "
-      "... which "
-      "will have the actual values of the arguments passed in. This "
-      "facilitates creating macros with optional arguments. Additionally "
-      "${ARGV} holds the list of all arguments given to the macro and "
-      "${ARGN} "
-      "holds the list of arguments past the last expected argument. "
-      "Note that the parameters to a macro and values such as ARGN "
-      "are not variables in the usual CMake sense. They are string "
-      "replacements much like the C preprocessor would do with a macro. "
-      "If you want true CMake variables and/or better CMake scope control "
-      "you should look at the function command."
-      "\n"
-      "See the cmake_policy() command documentation for the behavior of "
-      "policies inside macros."
-      ;
-    }
   cmTypeMacro(cmMacroCommand, cmCommand);
 };
 
diff --git a/Source/cmMakeDirectoryCommand.h b/Source/cmMakeDirectoryCommand.h
index a0f866a5f..49a4009f2 100644
--- a/Source/cmMakeDirectoryCommand.h
+++ b/Source/cmMakeDirectoryCommand.h
@@ -51,26 +51,6 @@ public:
    */
   virtual bool IsScriptable() const { return true; }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the file(MAKE_DIRECTORY ) command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  make_directory(directory)\n"
-      "Creates the specified directory.  Full paths should be given.  Any "
-      "parent directories that do not exist will also be created.  Use with "
-      "care.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmMarkAsAdvancedCommand.h b/Source/cmMarkAsAdvancedCommand.h
index adfc5537e..b65e4a87e 100644
--- a/Source/cmMarkAsAdvancedCommand.h
+++ b/Source/cmMarkAsAdvancedCommand.h
@@ -42,33 +42,6 @@ public:
    */
   virtual const char* GetName() const {return "mark_as_advanced";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Mark cmake cached variables as advanced.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  mark_as_advanced([CLEAR|FORCE] VAR [VAR2 ...])\n"
-      "Mark the named cached variables as advanced.  An advanced variable "
-      "will not be displayed in any of the cmake GUIs unless the show "
-      "advanced option is on.  "
-      "If CLEAR is the first argument advanced variables are changed back "
-      "to unadvanced.  "
-      "If FORCE is the first argument, then the variable is made advanced.  "
-      "If neither FORCE nor CLEAR is specified, new values will be marked as "
-      "advanced, but if the variable already has an advanced/non-advanced "
-      "state, it will not be changed.\n"
-      "It does nothing in script mode.";
-    }
-
   /**
    * This determines if the command is invoked when in script mode.
    * mark_as_advanced() will have no effect in script mode, but this will
diff --git a/Source/cmMathCommand.h b/Source/cmMathCommand.h
index dc0ceb340..c826ef162 100644
--- a/Source/cmMathCommand.h
+++ b/Source/cmMathCommand.h
@@ -43,28 +43,6 @@ public:
    */
   virtual const char* GetName() const { return "math";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Mathematical expressions.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  math(EXPR <output variable> <math expression>)\n"
-      "EXPR evaluates mathematical expression and returns result in the "
-      "output variable. Example mathematical expression is "
-      "'5 * ( 10 + 13 )'.  Supported operators are "
-      "+ - * / % | & ^ ~ << >> * / %.  They have the same meaning "
-      " as they do in C code.";
-    }
-
   cmTypeMacro(cmMathCommand, cmCommand);
 protected:
 
diff --git a/Source/cmMessageCommand.h b/Source/cmMessageCommand.h
index a053bdd79..fec9a3233 100644
--- a/Source/cmMessageCommand.h
+++ b/Source/cmMessageCommand.h
@@ -46,47 +46,6 @@ public:
    */
   virtual bool IsScriptable() const { return true; }
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Display a message to the user.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  message([<mode>] \"message to display\" ...)\n"
-      "The optional <mode> keyword determines the type of message:\n"
-      "  (none)         = Important information\n"
-      "  STATUS         = Incidental information\n"
-      "  WARNING        = CMake Warning, continue processing\n"
-      "  AUTHOR_WARNING = CMake Warning (dev), continue processing\n"
-      "  SEND_ERROR     = CMake Error, continue processing,\n"
-      "                                but skip generation\n"
-      "  FATAL_ERROR    = CMake Error, stop processing and generation\n"
-      "  DEPRECATION    = CMake Deprecation Error or Warning if variable\n"
-      "                   CMAKE_ERROR_DEPRECATED or CMAKE_WARN_DEPRECATED\n"
-      "                   is enabled, respectively, else no message.\n"
-      "The CMake command-line tool displays STATUS messages on stdout "
-      "and all other message types on stderr.  "
-      "The CMake GUI displays all messages in its log area.  "
-      "The interactive dialogs (ccmake and CMakeSetup) show STATUS messages "
-      "one at a time on a status line and other messages in interactive "
-      "pop-up boxes."
-      "\n"
-      "CMake Warning and Error message text displays using a simple "
-      "markup language.  "
-      "Non-indented text is formatted in line-wrapped paragraphs delimited "
-      "by newlines.  "
-      "Indented text is considered pre-formatted."
-      ;
-    }
-
   cmTypeMacro(cmMessageCommand, cmCommand);
 };
 
diff --git a/Source/cmOptionCommand.h b/Source/cmOptionCommand.h
index 7d0240050..89e3ac122 100644
--- a/Source/cmOptionCommand.h
+++ b/Source/cmOptionCommand.h
@@ -42,29 +42,6 @@ public:
    */
   virtual const char* GetName() const {return "option";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Provides an option that the user can optionally select.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  option(<option_variable> \"help string describing option\"\n"
-      "         [initial value])\n"
-      "Provide an option for the user to select as ON or OFF.  If no "
-      "initial value is provided, OFF is used.\n"
-      "If you have options that depend on the values of other "
-      "options, see the module help for CMakeDependentOption."
-      ;
-    }
-
   /**
    * This determines if the command is invoked when in script mode.
    */
diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h
index 1d7e39457..d43b2295a 100644
--- a/Source/cmOutputRequiredFilesCommand.h
+++ b/Source/cmOutputRequiredFilesCommand.h
@@ -42,30 +42,6 @@ public:
    */
   virtual const char* GetName() const { return "output_required_files";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated.  Approximate C preprocessor dependency scanning.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "This command exists only because ancient CMake versions provided it.  "
-      "CMake handles preprocessor dependency scanning automatically using a "
-      "more advanced scanner.\n"
-      "  output_required_files(srcfile outputfile)\n"
-      "Outputs a list of all the source files that are required by the "
-      "specified srcfile. This list is written into outputfile. This is "
-      "similar to writing out the dependencies for srcfile except that it "
-      "jumps from .h files into .cxx, .c and .cpp files if possible.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h
index 9547c4c8f..f7d086d36 100644
--- a/Source/cmProjectCommand.h
+++ b/Source/cmProjectCommand.h
@@ -45,41 +45,6 @@ public:
    */
   virtual const char* GetName() const {return "project";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set a name for the entire project.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  project(<projectname> [languageName1 languageName2 ... ] )\n"
-      "Sets the name of the project.  "
-      "Additionally this sets the variables <projectName>_BINARY_DIR and "
-      "<projectName>_SOURCE_DIR to the respective values.\n"
-      "Optionally you can specify which languages your project supports.  "
-      "Example languages are CXX (i.e. C++), C, Fortran, etc. "
-      "By default C and CXX are enabled.  E.g. if you do not have a "
-      "C++ compiler, you can disable the check for it by explicitly listing "
-      "the languages you want to support, e.g. C.  By using the special "
-      "language \"NONE\" all checks for any language can be disabled. "
-      "If a variable exists called CMAKE_PROJECT_<projectName>_INCLUDE, "
-      "the file pointed to by that variable will be included as the last step "
-      "of the project command."
-      "\n"
-      "The top-level CMakeLists.txt file for a project must contain a "
-      "literal, direct call to the project() command; loading one through "
-      "the include() command is not sufficient.  "
-      "If no such call exists CMake will implicitly add one to the top that "
-      "enables the default languages (C and CXX).";
-    }
-
   cmTypeMacro(cmProjectCommand, cmCommand);
 };
 
diff --git a/Source/cmQTWrapCPPCommand.h b/Source/cmQTWrapCPPCommand.h
index 4863402e4..868eb91fa 100644
--- a/Source/cmQTWrapCPPCommand.h
+++ b/Source/cmQTWrapCPPCommand.h
@@ -46,27 +46,6 @@ public:
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() const { return "qt_wrap_cpp";}
-
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Create Qt Wrappers.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  qt_wrap_cpp(resultingLibraryName DestName\n"
-      "              SourceLists ...)\n"
-      "Produce moc files for all the .h files listed in the SourceLists.  "
-      "The moc files will be added to the library using the DestName "
-      "source list.";
-    }
 };
 
 
diff --git a/Source/cmQTWrapUICommand.h b/Source/cmQTWrapUICommand.h
index b15c5cde0..3406dac3f 100644
--- a/Source/cmQTWrapUICommand.h
+++ b/Source/cmQTWrapUICommand.h
@@ -44,30 +44,6 @@ public:
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() const { return "qt_wrap_ui";}
-
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Create Qt user interfaces Wrappers.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  qt_wrap_ui(resultingLibraryName HeadersDestName\n"
-      "             SourcesDestName SourceLists ...)\n"
-      "Produce .h and .cxx files for all the .ui files listed "
-      "in the SourceLists.  "
-      "The .h files will be added to the library using the HeadersDestName"
-      "source list.  "
-      "The .cxx files will be added to the library using the SourcesDestName"
-      "source list.";
-    }
 };
 
 
diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h
index 5aedc26e5..ad739088f 100644
--- a/Source/cmRemoveCommand.h
+++ b/Source/cmRemoveCommand.h
@@ -47,26 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "remove";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the list(REMOVE_ITEM ) command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  remove(VAR VALUE VALUE ...)\n"
-      "Removes VALUE from the variable VAR.  "
-      "This is typically used to remove entries from a vector "
-      "(e.g. semicolon separated list).  VALUE is expanded.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmRemoveDefinitionsCommand.h b/Source/cmRemoveDefinitionsCommand.h
index 18f617124..4e291fc38 100644
--- a/Source/cmRemoveDefinitionsCommand.h
+++ b/Source/cmRemoveDefinitionsCommand.h
@@ -44,25 +44,6 @@ public:
    */
   virtual const char* GetName() const {return "remove_definitions";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Removes -D define flags added by add_definitions.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  remove_definitions(-DFOO -DBAR ...)\n"
-      "Removes flags (added by add_definitions) from the compiler command "
-      "line for sources in the current directory and below.";
-    }
-
   cmTypeMacro(cmRemoveDefinitionsCommand, cmCommand);
 };
 
diff --git a/Source/cmReturnCommand.h b/Source/cmReturnCommand.h
index a6e87eff3..2822b62c4 100644
--- a/Source/cmReturnCommand.h
+++ b/Source/cmReturnCommand.h
@@ -47,32 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "return";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Return from a file, directory or function.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  return()\n"
-      "Returns from a file, directory or function. When this command is "
-      "encountered in an included file (via include() or find_package()), "
-      "it causes processing of the current file to stop and control is "
-      "returned to the including file. If it is encountered in a file which "
-      "is not included by another file, e.g. a CMakeLists.txt, control is "
-      "returned to the parent directory if there is one. "
-      "If return is called in a function, control is returned to the caller "
-      "of the function. Note that a macro "
-      "is not a function and does not handle return like a function does.";
-    }
-
   cmTypeMacro(cmReturnCommand, cmCommand);
 };
 
diff --git a/Source/cmSeparateArgumentsCommand.h b/Source/cmSeparateArgumentsCommand.h
index d62baf787..ce0236043 100644
--- a/Source/cmSeparateArgumentsCommand.h
+++ b/Source/cmSeparateArgumentsCommand.h
@@ -47,43 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "separate_arguments";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Parse space-separated arguments into a semicolon-separated list.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  separate_arguments(<var> <UNIX|WINDOWS>_COMMAND \"<args>\")\n"
-      "Parses a unix- or windows-style command-line string \"<args>\" and "
-      "stores a semicolon-separated list of the arguments in <var>.  "
-      "The entire command line must be given in one \"<args>\" argument."
-      "\n"
-      "The UNIX_COMMAND mode separates arguments by unquoted whitespace.  "
-      "It recognizes both single-quote and double-quote pairs.  "
-      "A backslash escapes the next literal character (\\\" is \"); "
-      "there are no special escapes (\\n is just n)."
-      "\n"
-      "The WINDOWS_COMMAND mode parses a windows command-line using the "
-      "same syntax the runtime library uses to construct argv at startup.  "
-      "It separates arguments by whitespace that is not double-quoted.  "
-      "Backslashes are literal unless they precede double-quotes.  "
-      "See the MSDN article \"Parsing C Command-Line Arguments\" for details."
-      "\n"
-      "  separate_arguments(VARIABLE)\n"
-      "Convert the value of VARIABLE to a semi-colon separated list.  "
-      "All spaces are replaced with ';'.  This helps with generating "
-      "command lines.";
-    }
-
   cmTypeMacro(cmSeparateArgumentsCommand, cmCommand);
 };
 
diff --git a/Source/cmSetCommand.h b/Source/cmSetCommand.h
index fe1d58df6..6cef0a0f5 100644
--- a/Source/cmSetCommand.h
+++ b/Source/cmSetCommand.h
@@ -47,114 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "set";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set a CMake, cache or environment variable to a given value.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  set(<variable> <value>\n"
-      "      [[CACHE <type> <docstring> [FORCE]] | PARENT_SCOPE])\n"
-      "Within CMake sets <variable> to the value <value>.  "
-      "<value> is expanded before <variable> is set to it.  "
-      "Normally, set will set a regular CMake variable. "
-      "If CACHE is present, then the <variable> is put in the cache "
-      "instead, unless it is already in the cache. "
-      "See section 'Variable types in CMake' below for details of "
-      "regular and cache variables and their interactions. "
-      "If CACHE is used, <type> and <docstring> are required. <type> is used "
-      "by the CMake GUI to choose a widget with which the user sets a value. "
-      "The value for <type> may be one of\n"
-      "  FILEPATH = File chooser dialog.\n"
-      "  PATH     = Directory chooser dialog.\n"
-      "  STRING   = Arbitrary string.\n"
-      "  BOOL     = Boolean ON/OFF checkbox.\n"
-      "  INTERNAL = No GUI entry (used for persistent variables).\n"
-      "If <type> is INTERNAL, the cache variable is marked as internal, "
-      "and will not be shown to the user in tools like cmake-gui. "
-      "This is intended for values that should be persisted in the cache, "
-      "but which users should not normally change. INTERNAL implies FORCE."
-      "\n"
-      "Normally, set(...CACHE...) creates cache variables, but does not "
-      "modify them. "
-      "If FORCE is specified, the value of the cache variable is set, even "
-      "if the variable is already in the cache. This should normally be "
-      "avoided, as it will remove any changes to the cache variable's value "
-      "by the user.\n"
-      "If PARENT_SCOPE is present, the variable will be set in the scope "
-      "above the current scope. Each new directory or function creates a new "
-      "scope. This command will set the value of a variable into the parent "
-      "directory or calling function (whichever is applicable to the case at "
-      "hand). PARENT_SCOPE cannot be combined with CACHE.\n"
-      "If <value> is not specified then the variable is removed "
-      "instead of set.  See also: the unset() command.\n"
-      "  set(<variable> <value1> ... <valueN>)\n"
-      "In this case <variable> is set to a semicolon separated list of "
-      "values.\n"
-      "<variable> can be an environment variable such as:\n"
-      "  set( ENV{PATH} /home/martink )\n"
-      "in which case the environment variable will be set.\n"
-      "*** Variable types in CMake ***\n"
-      "In CMake there are two types of variables: normal variables and cache "
-      "variables. Normal variables are meant for the internal use of the "
-      "script (just like variables in most programming languages); they are "
-      "not persisted across CMake runs. "
-      "Cache variables (unless set with INTERNAL) are mostly intended for "
-      "configuration settings where the first CMake run determines a "
-      "suitable default value, which the user can then override, by editing "
-      "the cache with tools such as ccmake or cmake-gui. "
-      "Cache variables are stored in the CMake cache file, and "
-      "are persisted across CMake runs. \n"
-      "Both types can exist at the same time with the same name "
-      "but different values. "
-      "When ${FOO} is evaluated, CMake first looks for "
-      "a normal variable 'FOO' in scope and uses it if set. "
-      "If and only if no normal variable exists then it falls back to the "
-      "cache variable 'FOO'.\n"
-      "Some examples:\n"
-      "The code 'set(FOO \"x\")' sets the normal variable 'FOO'. It does not "
-      "touch the cache, but it will hide any existing cache value 'FOO'.\n"
-      "The code 'set(FOO \"x\" CACHE ...)' checks for 'FOO' in the cache, "
-      "ignoring any normal variable of the same name. If 'FOO' is in the "
-      "cache then nothing happens to either the normal variable or the cache "
-      "variable. If 'FOO' is not in the cache, then it is added to the "
-      "cache.\n"
-      "Finally, whenever a cache variable is added or modified by a command, "
-      "CMake also *removes* the normal variable of the same name from the "
-      "current scope so that an immediately following evaluation of "
-      "it will expose the newly cached value.\n"
-      "Normally projects should avoid using normal and cache variables of "
-      "the same name, as this interaction can be hard to follow. "
-      "However, in some situations it can be useful. "
-      "One example (used by some projects):"
-      "\n"
-      "A project has a subproject in its source tree. The child project has "
-      "its own CMakeLists.txt, which is included from the parent "
-      "CMakeLists.txt using add_subdirectory(). "
-      "Now, if the parent and the child project provide the same option "
-      "(for example a compiler option), the parent gets the first chance "
-      "to add a user-editable option to the cache. "
-      "Normally, the child would then use the same value "
-      "that the parent uses. "
-      "However, it may be necessary to hard-code the value for the child "
-      "project's option while still allowing the user to edit the value used "
-      "by the parent project. The parent project can achieve this simply by "
-      "setting a normal variable with the same name as the option in a scope "
-      "sufficient to hide the option's cache variable from the child "
-      "completely. The parent has already set the cache variable,  so the "
-      "child's set(...CACHE...) will do nothing, and evaluating the option "
-      "variable will use the value from the normal variable, which hides the "
-      "cache variable.";
-    }
-
   cmTypeMacro(cmSetCommand, cmCommand);
 };
 
diff --git a/Source/cmSetDirectoryPropertiesCommand.h b/Source/cmSetDirectoryPropertiesCommand.h
index 8a50c60ff..6240598ad 100644
--- a/Source/cmSetDirectoryPropertiesCommand.h
+++ b/Source/cmSetDirectoryPropertiesCommand.h
@@ -39,14 +39,6 @@ public:
    */
   virtual const char* GetName() const { return "set_directory_properties";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set a property of the directory.";
-    }
-
   /**
    * Static entry point for use by other commands
    */
@@ -55,21 +47,6 @@ public:
                          std::vector<std::string>::const_iterator aitend,
                          std::string &errors);
 
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  set_directory_properties(PROPERTIES prop1 value1 prop2 value2)\n"
-        "Set a property for the current directory and subdirectories. If the "
-        "property is not found, CMake will report an error. The properties "
-        "include: INCLUDE_DIRECTORIES, LINK_DIRECTORIES, "
-        "INCLUDE_REGULAR_EXPRESSION, and ADDITIONAL_MAKE_CLEAN_FILES. "
-        "ADDITIONAL_MAKE_CLEAN_FILES is a list of files that will be cleaned "
-        "as a part of \"make clean\" stage.";
-    }
-
   cmTypeMacro(cmSetDirectoryPropertiesCommand, cmCommand);
 };
 
diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h
index 830299d46..5470314ca 100644
--- a/Source/cmSetPropertyCommand.h
+++ b/Source/cmSetPropertyCommand.h
@@ -36,53 +36,6 @@ public:
    */
   virtual const char* GetName() const { return "set_property";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set a named property in a given scope.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  set_property(<GLOBAL                            |\n"
-        "                DIRECTORY [dir]                   |\n"
-        "                TARGET    [target1 [target2 ...]] |\n"
-        "                SOURCE    [src1 [src2 ...]]       |\n"
-        "                TEST      [test1 [test2 ...]]     |\n"
-        "                CACHE     [entry1 [entry2 ...]]>\n"
-        "               [APPEND] [APPEND_STRING]\n"
-        "               PROPERTY <name> [value1 [value2 ...]])\n"
-        "Set one property on zero or more objects of a scope.  "
-        "The first argument determines the scope in which the property "
-        "is set.  It must be one of the following:\n"
-        "GLOBAL scope is unique and does not accept a name.\n"
-        "DIRECTORY scope defaults to the current directory but another "
-        "directory (already processed by CMake) may be named by full or "
-        "relative path.\n"
-        "TARGET scope may name zero or more existing targets.\n"
-        "SOURCE scope may name zero or more source files.  "
-        "Note that source file properties are visible only to targets "
-        "added in the same directory (CMakeLists.txt).\n"
-        "TEST scope may name zero or more existing tests.\n"
-        "CACHE scope must name zero or more cache existing entries.\n"
-        "The required PROPERTY option is immediately followed by the name "
-        "of the property to set.  Remaining arguments are used to "
-        "compose the property value in the form of a semicolon-separated "
-        "list.  "
-        "If the APPEND option is given the list is appended to any "
-        "existing property value."
-        "If the APPEND_STRING option is given the string is append to any "
-        "existing property value as string, i.e. it results in a longer "
-        "string and not a list of strings."
-        ;
-    }
-
   /**
    * This determines if the command is invoked when in script mode.
    */
diff --git a/Source/cmSetSourceFilesPropertiesCommand.h b/Source/cmSetSourceFilesPropertiesCommand.h
index f7009e781..8541a9678 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.h
+++ b/Source/cmSetSourceFilesPropertiesCommand.h
@@ -34,31 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "set_source_files_properties";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Source files can have properties that affect how they are built.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  set_source_files_properties([file1 [file2 [...]]]\n"
-        "                              PROPERTIES prop1 value1\n"
-        "                              [prop2 value2 [...]])\n"
-        "Set properties associated with source files using a key/value "
-        "paired list.  "
-        "See properties documentation for those known to CMake.  "
-        "Unrecognized properties are ignored.  "
-        "Source file properties are visible only to targets "
-        "added in the same directory (CMakeLists.txt).";
-    }
-
   cmTypeMacro(cmSetSourceFilesPropertiesCommand, cmCommand);
 
   static bool RunCommand(cmMakefile *mf,
diff --git a/Source/cmSetTargetPropertiesCommand.h b/Source/cmSetTargetPropertiesCommand.h
index cf9c19350..6221a189f 100644
--- a/Source/cmSetTargetPropertiesCommand.h
+++ b/Source/cmSetTargetPropertiesCommand.h
@@ -34,14 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "set_target_properties";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Targets can have properties that affect how they are built.";
-    }
-
   /**
    *  Used by this command and cmSetPropertiesCommand
    */
@@ -49,119 +41,6 @@ public:
                            std::vector<std::string> &propertyPairs,
                            cmMakefile *mf);
 
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-      return
-        "  set_target_properties(target1 target2 ...\n"
-        "                        PROPERTIES prop1 value1\n"
-        "                        prop2 value2 ...)\n"
-        "Set properties on a target. The syntax for the command is to "
-        "list all the files you want "
-        "to change, and then provide the values you want to set next.  "
-        "You can use any prop value pair you want and "
-        "extract it later with the GET_TARGET_PROPERTY command.\n"
-        "Properties that affect the name of a target's output file are "
-        "as follows.  "
-        "The PREFIX and SUFFIX properties override the default target name "
-        "prefix (such as \"lib\") and suffix (such as \".so\"). "
-        "IMPORT_PREFIX and IMPORT_SUFFIX are the equivalent properties for "
-        "the import library corresponding to a DLL "
-        "(for SHARED library targets).  "
-        "OUTPUT_NAME sets the real name of a target when it is built and "
-        "can be used to help create two targets of the same name even though "
-        "CMake requires unique logical target names.  There is also a "
-        "<CONFIG>_OUTPUT_NAME that can set the output name on a "
-        "per-configuration basis.  "
-        "<CONFIG>_POSTFIX sets a postfix for the real name of the target "
-        "when it is built under the configuration named by <CONFIG> "
-        "(in upper-case, such as \"DEBUG_POSTFIX\").  The value of "
-        "this property is initialized when the target is created to the "
-        "value of the variable CMAKE_<CONFIG>_POSTFIX (except for executable "
-        "targets because earlier CMake versions which did not use this "
-        "variable for executables)."
-        "\n"
-        "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. "
-        "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. "
-        "The COMPILE_FLAGS property sets additional compiler flags used "
-        "to build sources within the target.  It may also be used to pass "
-        "additional preprocessor definitions."
-        "\n"
-        "The LINKER_LANGUAGE property is used to change the tool "
-        "used to link an executable or shared library. The default is "
-        "set the language to match the files in the library. CXX and C "
-        "are common values for this property."
-        "\n"
-        "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. "
-        "\n"
-        "There are a few properties used to specify RPATH rules. "
-        "INSTALL_RPATH is a semicolon-separated list specifying the rpath "
-        "to use in installed targets (for platforms that support it). "
-        "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. "
-        "SKIP_BUILD_RPATH is a boolean specifying whether to skip automatic "
-        "generation of an rpath allowing the target to run from the "
-        "build tree. "
-        "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.  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. "
-        "When the target is created the values of "
-        "the variables CMAKE_INSTALL_RPATH, "
-        "CMAKE_INSTALL_RPATH_USE_LINK_PATH, CMAKE_SKIP_BUILD_RPATH, "
-        "CMAKE_BUILD_WITH_INSTALL_RPATH, and CMAKE_INSTALL_NAME_DIR "
-        "are used to initialize these properties.\n"
-        "PROJECT_LABEL can be used to change the name of "
-        "the target in an IDE like visual studio.  VS_KEYWORD can be set "
-        "to change the visual studio keyword, for example Qt integration "
-        "works better if this is set to Qt4VSv1.0.\n"
-        "VS_SCC_PROJECTNAME, VS_SCC_LOCALPATH, VS_SCC_PROVIDER and "
-        "VS_SCC_AUXPATH can be set "
-        "to add support for source control bindings in a  Visual Studio "
-        "project file.\n"
-        "VS_GLOBAL_<variable> can be set to add a Visual Studio "
-        "project-specific global variable. "
-        "Qt integration works better if VS_GLOBAL_QtVersion is set to "
-        "the Qt version FindQt4.cmake found. For example, \"4.7.3\"\n"
-        "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."
-        "\n"
-        "The EXCLUDE_FROM_DEFAULT_BUILD property is used by the visual "
-        "studio generators.  If it is set to 1 the target will not be "
-        "part of the default build when you select \"Build Solution\". "
-        "This can also be set on a per-configuration basis using "
-        "EXCLUDE_FROM_DEFAULT_BUILD_<CONFIG>."
-        ;
-    }
-
   cmTypeMacro(cmSetTargetPropertiesCommand, cmCommand);
 };
 
diff --git a/Source/cmSetTestsPropertiesCommand.h b/Source/cmSetTestsPropertiesCommand.h
index f2f261169..9e85495a9 100644
--- a/Source/cmSetTestsPropertiesCommand.h
+++ b/Source/cmSetTestsPropertiesCommand.h
@@ -34,41 +34,6 @@ public:
    */
   virtual const char* GetName() const { return "set_tests_properties";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set a property of the tests.";
-    }
-
-  /**
-   * Longer documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  set_tests_properties(test1 [test2...] PROPERTIES prop1 value1 prop2"
-      " value2)\n"
-      "Set a property for the tests. If the property is not found, CMake "
-      "will report an error. Generator expressions will be expanded the same "
-      "as supported by the test's add_test call. The properties include:\n"
-      "WILL_FAIL: If set to true, this will invert the pass/fail flag of the"
-      " test.\n"
-      "PASS_REGULAR_EXPRESSION: 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.\n"
-      "  Example: PASS_REGULAR_EXPRESSION \"TestPassed;All ok\"\n"
-      "FAIL_REGULAR_EXPRESSION: If set, if the output will match to one of "
-      "specified regular expressions, the test will fail.\n"
-      "  Example: PASS_REGULAR_EXPRESSION \"[^a-z]Error;ERROR;Failed\"\n"
-      "Both PASS_REGULAR_EXPRESSION and FAIL_REGULAR_EXPRESSION expect a "
-      "list of regular expressions.\n"
-      "TIMEOUT: Setting this will limit the test runtime to the number of "
-      "seconds specified.\n";
-    }
-
   cmTypeMacro(cmSetTestsPropertiesCommand, cmCommand);
 
   static bool SetOneTest(const char *tname,
diff --git a/Source/cmSiteNameCommand.h b/Source/cmSiteNameCommand.h
index 52a63bc9c..eb9d4d87e 100644
--- a/Source/cmSiteNameCommand.h
+++ b/Source/cmSiteNameCommand.h
@@ -47,23 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "site_name";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Set the given variable to the name of the computer.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  site_name(variable)\n";
-    }
-
   cmTypeMacro(cmSiteNameCommand, cmCommand);
 };
 
diff --git a/Source/cmSourceGroupCommand.h b/Source/cmSourceGroupCommand.h
index 9f6b7e4f9..5d8b48ce9 100644
--- a/Source/cmSourceGroupCommand.h
+++ b/Source/cmSourceGroupCommand.h
@@ -43,36 +43,6 @@ public:
    */
   virtual const char* GetName() const {return "source_group";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Define a grouping for sources in the makefile.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  source_group(name [REGULAR_EXPRESSION regex] "
-      "[FILES src1 src2 ...])\n"
-      "Defines a group into which sources will be placed in project files.  "
-      "This is mainly used to setup file tabs in Visual Studio.  "
-      "Any file whose name is listed or matches the regular expression will "
-      "be placed in this group.  If a file matches multiple groups, the LAST "
-      "group that explicitly lists the file will be favored, if any.  If no "
-      "group explicitly lists the file, the LAST group whose regular "
-      "expression matches the file will be favored.\n"
-      "The name of the group may contain backslashes to specify subgroups:\n"
-      "  source_group(outer\\\\inner ...)\n"
-      "For backwards compatibility, this command also supports the "
-      "format:\n"
-      "  source_group(name regex)";
-    }
-
   cmTypeMacro(cmSourceGroupCommand, cmCommand);
 };
 
diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h
index f584cfdbf..0e833c45a 100644
--- a/Source/cmStringCommand.h
+++ b/Source/cmStringCommand.h
@@ -52,136 +52,6 @@ public:
    */
   virtual const char* GetName() const { return "string";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "String operations.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  string(REGEX MATCH <regular_expression>\n"
-      "         <output variable> <input> [<input>...])\n"
-      "  string(REGEX MATCHALL <regular_expression>\n"
-      "         <output variable> <input> [<input>...])\n"
-      "  string(REGEX REPLACE <regular_expression>\n"
-      "         <replace_expression> <output variable>\n"
-      "         <input> [<input>...])\n"
-      "  string(REPLACE <match_string>\n"
-      "         <replace_string> <output variable>\n"
-      "         <input> [<input>...])\n"
-      "  string(<MD5|SHA1|SHA224|SHA256|SHA384|SHA512>\n"
-      "         <output variable> <input>)\n"
-      "  string(COMPARE EQUAL <string1> <string2> <output variable>)\n"
-      "  string(COMPARE NOTEQUAL <string1> <string2> <output variable>)\n"
-      "  string(COMPARE LESS <string1> <string2> <output variable>)\n"
-      "  string(COMPARE GREATER <string1> <string2> <output variable>)\n"
-      "  string(ASCII <number> [<number> ...] <output variable>)\n"
-      "  string(CONFIGURE <string1> <output variable>\n"
-      "         [@ONLY] [ESCAPE_QUOTES])\n"
-      "  string(TOUPPER <string1> <output variable>)\n"
-      "  string(TOLOWER <string1> <output variable>)\n"
-      "  string(LENGTH <string> <output variable>)\n"
-      "  string(SUBSTRING <string> <begin> <length> <output variable>)\n"
-      "  string(STRIP <string> <output variable>)\n"
-      "  string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>]\n"
-      "         [RANDOM_SEED <seed>] <output variable>)\n"
-      "  string(FIND <string> <substring> <output variable> [REVERSE])\n"
-      "  string(TIMESTAMP <output variable> [<format string>] [UTC])\n"
-      "  string(MAKE_C_IDENTIFIER <input string> <output variable>)\n"
-      "REGEX MATCH will match the regular expression once and store the "
-      "match in the output variable.\n"
-      "REGEX MATCHALL will match the regular expression as many times as "
-      "possible and store the matches in the output variable as a list.\n"
-      "REGEX REPLACE will match the regular expression as many times as "
-      "possible and substitute the replacement expression for the match "
-      "in the output.  The replace expression may refer to paren-delimited "
-      "subexpressions of the match using \\1, \\2, ..., \\9.  Note that "
-      "two backslashes (\\\\1) are required in CMake code to get a "
-      "backslash through argument parsing.\n"
-      "REPLACE will replace all occurrences of match_string in the input with "
-      "replace_string and store the result in the output.\n"
-      "MD5, SHA1, SHA224, SHA256, SHA384, and SHA512 "
-      "will compute a cryptographic hash of the input string.\n"
-      "COMPARE EQUAL/NOTEQUAL/LESS/GREATER will compare the strings and "
-      "store true or false in the output variable.\n"
-      "ASCII will convert all numbers into corresponding ASCII characters.\n"
-      "CONFIGURE will transform a string like CONFIGURE_FILE transforms "
-      "a file.\n"
-      "TOUPPER/TOLOWER will convert string to upper/lower characters.\n"
-      "LENGTH will return a given string's length.\n"
-      "SUBSTRING will return a substring of a given string. If length is "
-      "-1 the remainder of the string starting at begin will be returned.\n"
-      "STRIP will return a substring of a given string with leading "
-      "and trailing spaces removed.\n"
-      "RANDOM will return a random string of given length consisting of "
-      "characters from the given alphabet. Default length is 5 "
-      "characters and default alphabet is all numbers and upper and "
-      "lower case letters.  If an integer RANDOM_SEED is given, its "
-      "value will be used to seed the random number generator.\n"
-      "FIND will return the position where the given substring was found "
-      "in the supplied string. If the REVERSE flag was used, the command "
-      "will search for the position of the last occurrence of the "
-      "specified substring.\n"
-      "The following characters have special meaning in regular expressions:\n"
-      "   ^         Matches at beginning of input\n"
-      "   $         Matches at end of input\n"
-      "   .         Matches any single character\n"
-      "   [ ]       Matches any character(s) inside the brackets\n"
-      "   [^ ]      Matches any character(s) not inside the brackets\n"
-      "    -        Inside brackets, specifies an inclusive range between\n"
-      "             characters on either side e.g. [a-f] is [abcdef]\n"
-      "             To match a literal - using brackets, make it the first\n"
-      "             or the last character e.g. [+*/-] matches basic\n"
-      "             mathematical operators.\n"
-      "   *         Matches preceding pattern zero or more times\n"
-      "   +         Matches preceding pattern one or more times\n"
-      "   ?         Matches preceding pattern zero or once only\n"
-      "   |         Matches a pattern on either side of the |\n"
-      "   ()        Saves a matched subexpression, which can be referenced \n"
-      "             in the REGEX REPLACE operation. Additionally it is saved\n"
-      "             by all regular expression-related commands, including \n"
-      "             e.g. if( MATCHES ), in the variables CMAKE_MATCH_(0..9).\n"
-      "*, + and ? have higher precedence than concatenation. | has lower "
-      "precedence than concatenation. This means that the regular expression "
-      "\"^ab+d$\" matches \"abbd\" but not \"ababd\", and the regular "
-      "expression \"^(ab|cd)$\" matches \"ab\" but not \"abd\".\n"
-      "TIMESTAMP will write a string representation of "
-      "the current date and/or time to the output variable.\n"
-      "Should the command be unable to obtain a timestamp "
-      "the output variable will be set to the empty string \"\".\n"
-      "The optional UTC flag requests the current date/time "
-      "representation to be in Coordinated Universal Time (UTC) "
-      "rather than local time.\n"
-      "The optional <format string> may contain the following "
-      "format specifiers: \n"
-      "   %d        The day of the current month (01-31).\n"
-      "   %H        The hour on a 24-hour clock (00-23).\n"
-      "   %I        The hour on a 12-hour clock (01-12).\n"
-      "   %j        The day of the current year (001-366).\n"
-      "   %m        The month of the current year (01-12).\n"
-      "   %M        The minute of the current hour (00-59).\n"
-      "   %S        The second of the current minute.\n"
-      "             60 represents a leap second. (00-60)\n"
-      "   %U        The week number of the current year (00-53).\n"
-      "   %w        The day of the current week. 0 is Sunday. (0-6)\n"
-      "   %y        The last two digits of the current year (00-99)\n"
-      "   %Y        The current year. \n"
-      "Unknown format specifiers will be ignored "
-      "and copied to the output as-is.\n"
-      "If no explicit <format string> is given it will default to:\n"
-      "   %Y-%m-%dT%H:%M:%S    for local time.\n"
-      "   %Y-%m-%dT%H:%M:%SZ   for UTC.\n"
-      "MAKE_C_IDENTIFIER will write a string which can be used as an "
-      "identifier in C.";
-    }
-
   cmTypeMacro(cmStringCommand, cmCommand);
   static void ClearMatches(cmMakefile* mf);
   static void StoreMatches(cmMakefile* mf, cmsys::RegularExpression& re);
diff --git a/Source/cmSubdirCommand.h b/Source/cmSubdirCommand.h
index 618d5ff2b..8be8335d0 100644
--- a/Source/cmSubdirCommand.h
+++ b/Source/cmSubdirCommand.h
@@ -44,40 +44,6 @@ public:
    */
   virtual const char* GetName() const { return "subdirs";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the add_subdirectory() command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "Add a list of subdirectories to the build.\n"
-      "  subdirs(dir1 dir2 ..."
-      "[EXCLUDE_FROM_ALL exclude_dir1 exclude_dir2 ...]\n"
-      "          [PREORDER] )\n"
-      "Add a list of subdirectories to the build. The add_subdirectory "
-      "command should be used instead of subdirs although subdirs will "
-      "still work. "
-      "This will cause any CMakeLists.txt files in the sub directories "
-      "to be processed by CMake.  Any directories after the PREORDER flag "
-      "are traversed first by makefile builds, the PREORDER flag has no "
-      "effect on IDE projects. "
-      " Any directories after the EXCLUDE_FROM_ALL marker "
-      "will not be included in the top level makefile or project file. "
-      "This is useful for having CMake create makefiles or projects for "
-      "a set of examples in a project. You would want CMake to "
-      "generate makefiles or project files for all the examples at "
-      "the same time, but you would not want them to show up in the "
-      "top level project or be built each time make is run from the top.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmSubdirDependsCommand.h b/Source/cmSubdirDependsCommand.h
index b274d0196..e6f1f8fc1 100644
--- a/Source/cmSubdirDependsCommand.h
+++ b/Source/cmSubdirDependsCommand.h
@@ -44,25 +44,6 @@ public:
    */
   virtual const char* GetName() const { return "subdir_depends";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated.  Does nothing.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  subdir_depends(subdir dep1 dep2 ...)\n"
-      "Does not do anything.  This command used to help projects order "
-      "parallel builds correctly.  This functionality is now automatic.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmTargetCompileDefinitionsCommand.h b/Source/cmTargetCompileDefinitionsCommand.h
index 585485d2a..7405e90a9 100644
--- a/Source/cmTargetCompileDefinitionsCommand.h
+++ b/Source/cmTargetCompileDefinitionsCommand.h
@@ -38,41 +38,6 @@ public:
    */
   virtual const char* GetName() const { return "target_compile_definitions";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Add compile definitions to a target.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  target_compile_definitions(<target> "
-      "<INTERFACE|PUBLIC|PRIVATE> [items1...]\n"
-      "    [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])\n"
-      "Specify compile definitions to use when compiling a given target.  "
-      "The named <target> must have been created by a command such as "
-      "add_executable or add_library and must not be an IMPORTED target.  "
-      "The INTERFACE, PUBLIC and PRIVATE keywords are required to specify "
-      "the scope of the following arguments.  PRIVATE and PUBLIC items will "
-      "populate the COMPILE_DEFINITIONS property of <target>.  PUBLIC and "
-      "INTERFACE items will populate the INTERFACE_COMPILE_DEFINITIONS "
-      "property of <target>.   "
-      "The following arguments specify compile definitions.  "
-      "Repeated calls for the same <target> append items in the order called."
-      "\n"
-      "Arguments to target_compile_definitions may use \"generator "
-      "expressions\" with the syntax \"$<...>\".  "
-      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      ;
-    }
-
   cmTypeMacro(cmTargetCompileDefinitionsCommand, cmTargetPropCommandBase);
 
 private:
diff --git a/Source/cmTargetCompileOptionsCommand.h b/Source/cmTargetCompileOptionsCommand.h
index b9afd7169..3713e5a48 100644
--- a/Source/cmTargetCompileOptionsCommand.h
+++ b/Source/cmTargetCompileOptionsCommand.h
@@ -38,43 +38,6 @@ public:
    */
   virtual const char* GetName() const { return "target_compile_options";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Add compile options to a target.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  target_compile_options(<target> [BEFORE] "
-      "<INTERFACE|PUBLIC|PRIVATE> [items1...]\n"
-      "    [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])\n"
-      "Specify compile options to use when compiling a given target.  "
-      "The named <target> must have been created by a command such as "
-      "add_executable or add_library and must not be an IMPORTED target.  "
-      "If BEFORE is specified, the content will be prepended to the property "
-      "instead of being appended.\n"
-      "The INTERFACE, PUBLIC and PRIVATE keywords are required to specify "
-      "the scope of the following arguments.  PRIVATE and PUBLIC items will "
-      "populate the COMPILE_OPTIONS property of <target>.  PUBLIC and "
-      "INTERFACE items will populate the INTERFACE_COMPILE_OPTIONS "
-      "property of <target>.   "
-      "The following arguments specify compile opitions.  "
-      "Repeated calls for the same <target> append items in the order called."
-      "\n"
-      "Arguments to target_compile_options may use \"generator "
-      "expressions\" with the syntax \"$<...>\".  "
-      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      ;
-    }
-
   cmTypeMacro(cmTargetCompileOptionsCommand, cmTargetPropCommandBase);
 
 private:
diff --git a/Source/cmTargetIncludeDirectoriesCommand.h b/Source/cmTargetIncludeDirectoriesCommand.h
index fcc37f06a..6863ee5a3 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.h
+++ b/Source/cmTargetIncludeDirectoriesCommand.h
@@ -39,53 +39,6 @@ public:
    */
   virtual const char* GetName() const { return "target_include_directories";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Add include directories to a target.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  target_include_directories(<target> [SYSTEM] [BEFORE] "
-      "<INTERFACE|PUBLIC|PRIVATE> [items1...]\n"
-      "    [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])\n"
-      "Specify include directories or targets to use when compiling a given "
-      "target.  "
-      "The named <target> must have been created by a command such as "
-      "add_executable or add_library and must not be an IMPORTED target.\n"
-      "If BEFORE is specified, the content will be prepended to the property "
-      "instead of being appended.\n"
-      "The INTERFACE, PUBLIC and PRIVATE keywords are required to specify "
-      "the scope of the following arguments.  PRIVATE and PUBLIC items will "
-      "populate the INCLUDE_DIRECTORIES property of <target>.  PUBLIC and "
-      "INTERFACE items will populate the INTERFACE_INCLUDE_DIRECTORIES "
-      "property of <target>.   "
-      "The following arguments specify include directories.  Specified "
-      "include directories may be absolute paths or relative paths.  "
-      "Repeated calls for the same <target> append items in the order called."
-      "If SYSTEM is specified, the compiler will be told the "
-      "directories are meant as system include directories on some "
-      "platforms (signalling this setting might achieve effects such as "
-      "the compiler skipping warnings, or these fixed-install system files "
-      "not being considered in dependency calculations - see compiler "
-      "docs).  If SYSTEM is used together with PUBLIC or INTERFACE, the "
-      "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES target property will be "
-      "populated with the specified directories."
-      "\n"
-      "Arguments to target_include_directories may use \"generator "
-      "expressions\" with the syntax \"$<...>\".  "
-      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      ;
-    }
-
   cmTypeMacro(cmTargetIncludeDirectoriesCommand, cmTargetPropCommandBase);
 
 private:
diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h
index f2b25433c..6fbf722fa 100644
--- a/Source/cmTargetLinkLibrariesCommand.h
+++ b/Source/cmTargetLinkLibrariesCommand.h
@@ -13,7 +13,6 @@
 #define cmTargetLinkLibrariesCommand_h
 
 #include "cmCommand.h"
-#include "cmDocumentGeneratorExpressions.h"
 
 /** \class cmTargetLinkLibrariesCommand
  * \brief Specify a list of libraries to link into executables.
@@ -45,151 +44,6 @@ public:
    */
   virtual const char* GetName() const { return "target_link_libraries";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return
-      "Link a target to given libraries.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  target_link_libraries(<target> [item1 [item2 [...]]]\n"
-      "                        [[debug|optimized|general] <item>] ...)\n"
-      "Specify libraries or flags to use when linking a given target.  "
-      "The named <target> must have been created in the current directory "
-      "by a command such as add_executable or add_library.  "
-      "The remaining arguments specify library names or flags.  "
-      "Repeated calls for the same <target> append items in the order called."
-      "\n"
-      "If a library name matches that of another target in the project "
-      "a dependency will automatically be added in the build system to make "
-      "sure the library being linked is up-to-date before the target links.  "
-      "Item names starting with '-', but not '-l' or '-framework', are "
-      "treated as linker flags."
-      "\n"
-      "A \"debug\", \"optimized\", or \"general\" keyword indicates that "
-      "the library immediately following it is to be used only for the "
-      "corresponding build configuration.  "
-      "The \"debug\" keyword corresponds to the Debug configuration "
-      "(or to configurations named in the DEBUG_CONFIGURATIONS global "
-      "property if it is set).  "
-      "The \"optimized\" keyword corresponds to all other configurations.  "
-      "The \"general\" keyword corresponds to all configurations, and is "
-      "purely optional (assumed if omitted).  "
-      "Higher granularity may be achieved for per-configuration rules "
-      "by creating and linking to IMPORTED library targets.  "
-      "See the IMPORTED mode of the add_library command for more "
-      "information.  "
-      "\n"
-      "Library dependencies are transitive by default.  "
-      "When this target is linked into another target then the libraries "
-      "linked to this target will appear on the link line for the other "
-      "target too.  "
-      "See the INTERFACE_LINK_LIBRARIES target property to override the "
-      "set of transitive link dependencies for a target.  "
-      "Calls to other signatures of this command may set the property "
-      "making any libraries linked exclusively by this signature private."
-      "\n"
-      "CMake will also propagate \"usage requirements\" from linked library "
-      "targets.  "
-      "Usage requirements affect compilation of sources in the <target>.  "
-      "They are specified by properties defined on linked targets.  "
-      "During generation of the build system, CMake integrates "
-      "usage requirement property values with the corresponding "
-      "build properties for <target>:\n"
-      " INTERFACE_COMPILE_DEFINITONS: Appends to COMPILE_DEFINITONS\n"
-      " INTERFACE_INCLUDE_DIRECTORIES: Appends to INCLUDE_DIRECTORIES\n"
-      " INTERFACE_POSITION_INDEPENDENT_CODE: Sets POSITION_INDEPENDENT_CODE\n"
-      "   or checked for consistency with existing value\n"
-      "\n"
-      "If an <item> is a library in a Mac OX framework, the Headers "
-      "directory of the framework will also be processed as a \"usage "
-      "requirement\".  This has the same effect as passing the framework "
-      "directory as an include directory."
-      "  target_link_libraries(<target>\n"
-      "                      <PRIVATE|PUBLIC|INTERFACE> <lib> ...\n"
-      "                      [<PRIVATE|PUBLIC|INTERFACE> <lib> ... ] ...])\n"
-      "The PUBLIC, PRIVATE and INTERFACE keywords can be used to specify "
-      "both the link dependencies and the link interface in one command.  "
-      "Libraries and targets following PUBLIC are linked to, and are "
-      "made part of the link interface.  Libraries and targets "
-      "following PRIVATE are linked to, but are not made part of the "
-      "link interface.  Libraries following INTERFACE are appended "
-      "to the link interface and are not used for linking <target>."
-      "\n"
-      "  target_link_libraries(<target> LINK_INTERFACE_LIBRARIES\n"
-      "                        [[debug|optimized|general] <lib>] ...)\n"
-      "The LINK_INTERFACE_LIBRARIES mode appends the libraries "
-      "to the INTERFACE_LINK_LIBRARIES target property instead of using them "
-      "for linking.  If policy CMP0022 is not NEW, then this mode also "
-      "appends libraries to the LINK_INTERFACE_LIBRARIES and its "
-      "per-configuration equivalent.  This signature "
-      "is for compatibility only. Prefer the INTERFACE mode instead.  "
-      "Libraries specified as \"debug\" are wrapped in a generator "
-      "expression to correspond to debug builds.  If policy CMP0022 is not "
-      "NEW, the libraries are also appended to the "
-      "LINK_INTERFACE_LIBRARIES_DEBUG property (or to the properties "
-      "corresponding to configurations listed in the DEBUG_CONFIGURATIONS "
-      "global property if it is set).  "
-      "Libraries specified as \"optimized\" are appended to the "
-      "INTERFACE_LINK_LIBRARIES property.  If policy CMP0022 is not NEW, "
-      "they are also appended to the LINK_INTERFACE_LIBRARIES property.  "
-      "Libraries specified as \"general\" (or without any keyword) are "
-      "treated as if specified for both \"debug\" and \"optimized\"."
-      "\n"
-      "  target_link_libraries(<target>\n"
-      "                        <LINK_PRIVATE|LINK_PUBLIC>\n"
-      "                          [[debug|optimized|general] <lib>] ...\n"
-      "                        [<LINK_PRIVATE|LINK_PUBLIC>\n"
-      "                          [[debug|optimized|general] <lib>] ...])\n"
-      "The LINK_PUBLIC and LINK_PRIVATE modes can be used to specify both "
-      "the link dependencies and the link interface in one command.  This "
-      "signature is for compatibility only. Prefer the PUBLIC or PRIVATE "
-      "keywords instead.  "
-      "Libraries and targets following LINK_PUBLIC are linked to, and are "
-      "made part of the INTERFACE_LINK_LIBRARIES.  If policy CMP0022 is not "
-      "NEW, they are also made part of the LINK_INTERFACE_LIBRARIES.  "
-      "Libraries and targets following LINK_PRIVATE are linked to, but are "
-      "not made part of the INTERFACE_LINK_LIBRARIES (or "
-      "LINK_INTERFACE_LIBRARIES)."
-      "\n"
-      "The library dependency graph is normally acyclic (a DAG), but in the "
-      "case of mutually-dependent STATIC libraries CMake allows the graph "
-      "to contain cycles (strongly connected components).  "
-      "When another target links to one of the libraries CMake repeats "
-      "the entire connected component.  "
-      "For example, the code\n"
-      "  add_library(A STATIC a.c)\n"
-      "  add_library(B STATIC b.c)\n"
-      "  target_link_libraries(A B)\n"
-      "  target_link_libraries(B A)\n"
-      "  add_executable(main main.c)\n"
-      "  target_link_libraries(main A)\n"
-      "links 'main' to 'A B A B'.  "
-      "("
-      "While one repetition is usually sufficient, pathological object "
-      "file and symbol arrangements can require more.  "
-      "One may handle such cases by manually repeating the component in "
-      "the last target_link_libraries call.  "
-      "However, if two archives are really so interdependent they should "
-      "probably be combined into a single archive."
-      ")"
-      "\n"
-      "Arguments to target_link_libraries may use \"generator expressions\" "
-      "with the syntax \"$<...>\".  Note however, that generator expressions "
-      "will not be used in OLD handling of CMP0003 or CMP0004."
-      "\n"
-      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      ;
-    }
-
   cmTypeMacro(cmTargetLinkLibrariesCommand, cmCommand);
 private:
   void LinkLibraryTypeSpecifierWarning(int left, int right);
diff --git a/Source/cmTargetPropCommandBase.h b/Source/cmTargetPropCommandBase.h
index 690582fdd..c4028365c 100644
--- a/Source/cmTargetPropCommandBase.h
+++ b/Source/cmTargetPropCommandBase.h
@@ -14,7 +14,6 @@
 #define cmTargetPropCommandBase_h
 
 #include "cmCommand.h"
-#include "cmDocumentGeneratorExpressions.h"
 
 class cmTarget;
 
diff --git a/Source/cmTryCompileCommand.h b/Source/cmTryCompileCommand.h
index a20594cbe..8e6bbc13d 100644
--- a/Source/cmTryCompileCommand.h
+++ b/Source/cmTryCompileCommand.h
@@ -42,81 +42,6 @@ public:
    */
   virtual const char* GetName() const { return "try_compile";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Try building some code.";
-    }
-
-  /**
-   * More documentation.  */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  try_compile(RESULT_VAR <bindir> <srcdir>\n"
-      "              <projectName> [targetName] [CMAKE_FLAGS flags...]\n"
-      "              [OUTPUT_VARIABLE <var>])\n"
-      "Try building a project.  In this form, srcdir should contain a "
-      "complete CMake project with a CMakeLists.txt file and all sources. "
-      "The bindir and srcdir will not be deleted after this command is run. "
-      "Specify targetName to build a specific target instead of the 'all' or "
-      "'ALL_BUILD' target."
-      "\n"
-      "  try_compile(RESULT_VAR <bindir> <srcfile|SOURCES srcfile...>\n"
-      "              [CMAKE_FLAGS flags...]\n"
-      "              [COMPILE_DEFINITIONS flags...]\n"
-      "              [LINK_LIBRARIES libs...]\n"
-      "              [OUTPUT_VARIABLE <var>]\n"
-      "              [COPY_FILE <fileName> [COPY_FILE_ERROR <var>]])\n"
-      "Try building an executable from one or more source files.  "
-      "In this form the user need only supply one or more source files "
-      "that include a definition for 'main'.  "
-      "CMake will create a CMakeLists.txt file to build the source(s) "
-      "as an executable.  "
-      "Specify COPY_FILE to get a copy of the linked executable at the "
-      "given fileName and optionally COPY_FILE_ERROR to capture any error."
-      "\n"
-      "In this version all files in bindir/CMakeFiles/CMakeTmp "
-      "will be cleaned automatically. For debugging, --debug-trycompile can "
-      "be passed to cmake to avoid this clean. However, multiple sequential "
-      "try_compile operations reuse this single output directory. If you "
-      "use --debug-trycompile, you can only debug one try_compile call at a "
-      "time. The recommended procedure is to configure with cmake all the "
-      "way through once, then delete the cache entry associated with "
-      "the try_compile call of interest, and then re-run cmake again with "
-      "--debug-trycompile."
-      "\n"
-      "Some extra flags that can be included are,  "
-      "INCLUDE_DIRECTORIES, LINK_DIRECTORIES, and LINK_LIBRARIES.  "
-      "COMPILE_DEFINITIONS are -Ddefinition that will be passed to the "
-      "compile line.\n"
-      "The srcfile signature also accepts a LINK_LIBRARIES argument which "
-      "may contain a list of libraries or IMPORTED targets which will be "
-      "linked to in the generated project.  If LINK_LIBRARIES is specified "
-      "as a parameter to try_compile, then any LINK_LIBRARIES passed as "
-      "CMAKE_FLAGS will be ignored.\n"
-      "try_compile creates a CMakeList.txt "
-      "file on the fly that looks like this:\n"
-      "  add_definitions( <expanded COMPILE_DEFINITIONS from calling "
-      "cmake>)\n"
-      "  include_directories(${INCLUDE_DIRECTORIES})\n"
-      "  link_directories(${LINK_DIRECTORIES})\n"
-      "  add_executable(cmTryCompileExec sources)\n"
-      "  target_link_libraries(cmTryCompileExec ${LINK_LIBRARIES})\n"
-      "In both versions of the command, "
-      "if OUTPUT_VARIABLE is specified, then the "
-      "output from the build process is stored in the given variable. "
-      "The success or failure of the try_compile, i.e. TRUE or FALSE "
-      "respectively, is returned in "
-      "RESULT_VAR. CMAKE_FLAGS can be used to pass -DVAR:TYPE=VALUE flags "
-      "to the cmake that is run during the build. "
-      "Set variable CMAKE_TRY_COMPILE_CONFIGURATION to choose a build "
-      "configuration."
-      ;
-    }
-
   cmTypeMacro(cmTryCompileCommand, cmCoreTryCompile);
 
 };
diff --git a/Source/cmTryRunCommand.h b/Source/cmTryRunCommand.h
index 13b997307..d0bf9ce70 100644
--- a/Source/cmTryRunCommand.h
+++ b/Source/cmTryRunCommand.h
@@ -42,63 +42,6 @@ public:
    */
   virtual const char* GetName() const { return "try_run";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Try compiling and then running some code.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  try_run(RUN_RESULT_VAR COMPILE_RESULT_VAR\n"
-      "          bindir srcfile [CMAKE_FLAGS <Flags>]\n"
-      "          [COMPILE_DEFINITIONS <flags>]\n"
-      "          [COMPILE_OUTPUT_VARIABLE comp]\n"
-      "          [RUN_OUTPUT_VARIABLE run]\n"
-      "          [OUTPUT_VARIABLE var]\n"
-      "          [ARGS <arg1> <arg2>...])\n"
-      "Try compiling a srcfile.  Return TRUE or FALSE for success or failure "
-      "in COMPILE_RESULT_VAR.  Then if the compile succeeded, run the "
-      "executable and return its exit code in RUN_RESULT_VAR. "
-      "If the executable was built, but failed to run, then RUN_RESULT_VAR "
-      "will be set to FAILED_TO_RUN. "
-      "COMPILE_OUTPUT_VARIABLE specifies the variable where the output from "
-      "the compile step goes. RUN_OUTPUT_VARIABLE specifies the variable "
-      "where the output from the running executable goes.\n"
-      "For compatibility reasons OUTPUT_VARIABLE is still supported, which "
-      "gives you the output from the compile and run step combined.\n"
-      "Cross compiling issues\n"
-      "When cross compiling, the executable compiled in the first step "
-      "usually cannot be run on the build host. try_run() checks the "
-      "CMAKE_CROSSCOMPILING variable to detect whether CMake is in "
-      "crosscompiling mode. If that's the case, it will still try to compile "
-      "the executable, but it will not try to run the executable. Instead it "
-      "will create cache variables which must be filled by the user or by "
-      "presetting them in some CMake script file to the values the "
-      "executable would have produced if it had been run on its actual "
-      "target platform. These variables are RUN_RESULT_VAR (explanation see "
-      "above) and if RUN_OUTPUT_VARIABLE (or OUTPUT_VARIABLE) was used, an "
-      "additional cache variable "
-      "RUN_RESULT_VAR__COMPILE_RESULT_VAR__TRYRUN_OUTPUT."
-      "This is intended to hold stdout and stderr from the executable.\n"
-      "In order to make cross compiling your project easier, use try_run "
-      "only if really required. If you use try_run, use RUN_OUTPUT_VARIABLE "
-      "(or OUTPUT_VARIABLE) only if really required. Using them will require "
-      "that when crosscompiling, the cache variables will have to be set "
-      "manually to the output of the executable. You can also \"guard\" the "
-      "calls to try_run with if(CMAKE_CROSSCOMPILING) and provide an "
-      "easy-to-preset alternative for this case.\n"
-      "Set variable CMAKE_TRY_COMPILE_CONFIGURATION to choose a build "
-      "configuration."
-      ;
-    }
-
   cmTypeMacro(cmTryRunCommand, cmCoreTryCompile);
 private:
   void RunExecutable(const std::string& runArgs,
diff --git a/Source/cmUnsetCommand.h b/Source/cmUnsetCommand.h
index a477f19bc..2308139f9 100644
--- a/Source/cmUnsetCommand.h
+++ b/Source/cmUnsetCommand.h
@@ -47,33 +47,6 @@ public:
    */
   virtual const char* GetName() const {return "unset";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Unset a variable, cache variable, or environment variable.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  unset(<variable> [CACHE | PARENT_SCOPE])\n"
-      "Removes the specified variable causing it to become undefined.  "
-      "If CACHE is present then the variable is removed from the cache "
-      "instead of the current scope.\n"
-      "If PARENT_SCOPE is present then the variable is removed from the "
-      "scope above the current scope.  See the same option in the set() "
-      "command for further details.\n"
-      "<variable> can be an environment variable such as:\n"
-      "  unset(ENV{LD_LIBRARY_PATH})\n"
-      "in which case the variable will be removed from the current "
-      "environment.";
-    }
-
   cmTypeMacro(cmUnsetCommand, cmCommand);
 };
 
diff --git a/Source/cmUseMangledMesaCommand.h b/Source/cmUseMangledMesaCommand.h
index 2f52960c4..aac78142c 100644
--- a/Source/cmUseMangledMesaCommand.h
+++ b/Source/cmUseMangledMesaCommand.h
@@ -47,27 +47,6 @@ public:
    */
   virtual const char* GetName() const { return "use_mangled_mesa";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Copy mesa headers for use in combination with system GL.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  use_mangled_mesa(PATH_TO_MESA OUTPUT_DIRECTORY)\n"
-      "The path to mesa includes, should contain gl_mangle.h.  "
-      "The mesa headers are copied to the specified output directory.  "
-      "This allows mangled mesa headers to override other GL headers by "
-      "being added to the include directory path earlier.";
-    }
-
   /**
    * This determines if the command is invoked when in script mode.
    */
diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h
index 195f605f2..0a0653c5c 100644
--- a/Source/cmUtilitySourceCommand.h
+++ b/Source/cmUtilitySourceCommand.h
@@ -46,35 +46,6 @@ public:
    */
   virtual const char* GetName() const { return "utility_source";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Specify the source tree of a third-party utility.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  utility_source(cache_entry executable_name\n"
-      "                 path_to_source [file1 file2 ...])\n"
-      "When a third-party utility's source is included in the distribution, "
-      "this command specifies its location and name.  The cache entry will "
-      "not be set unless the path_to_source and all listed files exist.  It "
-      "is assumed that the source tree of the utility will have been built "
-      "before it is needed.\n"
-      "When cross compiling CMake will print a warning if a utility_source() "
-      "command is executed, because in many cases it is used to build an "
-      "executable which is executed later on. This doesn't work when "
-      "cross compiling, since the executable can run only on their target "
-      "platform. So in this case the cache entry has to be adjusted manually "
-      "so it points to an executable which is runnable on the build host.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmVariableRequiresCommand.h b/Source/cmVariableRequiresCommand.h
index c86f43dc6..1032745ad 100644
--- a/Source/cmVariableRequiresCommand.h
+++ b/Source/cmVariableRequiresCommand.h
@@ -41,34 +41,6 @@ public:
    */
   virtual const char* GetName() const { return "variable_requires";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the if() command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "Assert satisfaction of an option's required variables.\n"
-      "  variable_requires(TEST_VARIABLE RESULT_VARIABLE\n"
-      "                    REQUIRED_VARIABLE1\n"
-      "                    REQUIRED_VARIABLE2 ...)\n"
-      "The first argument (TEST_VARIABLE) is the name of the variable to be "
-      "tested, if that variable is false nothing else is done. If "
-      "TEST_VARIABLE is true, then "
-      "the next argument (RESULT_VARIABLE) is a variable that is set to true "
-      "if all the required variables are set. "
-      "The rest of the arguments are variables that must be true or not "
-      "set to NOTFOUND to avoid an error.  If any are not true, an error "
-      "is reported.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {
diff --git a/Source/cmVariableWatchCommand.h b/Source/cmVariableWatchCommand.h
index 545535c40..fb6062c48 100644
--- a/Source/cmVariableWatchCommand.h
+++ b/Source/cmVariableWatchCommand.h
@@ -56,27 +56,6 @@ public:
    */
   virtual const char* GetName() const { return "variable_watch";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Watch the CMake variable for change.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  variable_watch(<variable name> [<command to execute>])\n"
-      "If the specified variable changes, the message will be printed about "
-      "the variable being changed. If the command is specified, the command "
-      "will be executed. The command will receive the following arguments:"
-      " COMMAND(<variable> <access> <value> <current list file> <stack>)";
-    }
-
   cmTypeMacro(cmVariableWatchCommand, cmCommand);
 
 protected:
diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h
index 1bdf27af3..45badd00d 100644
--- a/Source/cmWhileCommand.h
+++ b/Source/cmWhileCommand.h
@@ -68,32 +68,6 @@ public:
    */
   virtual const char* GetName() const { return "while";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Evaluate a group of commands while a condition is true";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  while(condition)\n"
-      "    COMMAND1(ARGS ...)\n"
-      "    COMMAND2(ARGS ...)\n"
-      "    ...\n"
-      "  endwhile(condition)\n"
-      "All commands between while and the matching endwhile are recorded "
-      "without being invoked.  Once the endwhile is evaluated, the "
-      "recorded list of commands is invoked as long as the condition "
-      "is true. The condition is evaluated using the same logic as the "
-      "if command.";
-    }
-
   cmTypeMacro(cmWhileCommand, cmCommand);
 };
 
diff --git a/Source/cmWriteFileCommand.h b/Source/cmWriteFileCommand.h
index 771ef5a1b..84a38fcfb 100644
--- a/Source/cmWriteFileCommand.h
+++ b/Source/cmWriteFileCommand.h
@@ -46,32 +46,6 @@ public:
    */
   virtual const char* GetName() const { return "write_file";}
 
-  /**
-   * Succinct documentation.
-   */
-  virtual const char* GetTerseDocumentation() const
-    {
-    return "Deprecated. Use the file(WRITE ) command instead.";
-    }
-
-  /**
-   * More documentation.
-   */
-  virtual const char* GetFullDocumentation() const
-    {
-    return
-      "  write_file(filename \"message to write\"... [APPEND])\n"
-      "The first argument is the file name, the rest of the arguments are "
-      "messages to write. If the argument APPEND is specified, then "
-      "the message will be appended.\n"
-      "NOTE 1: file(WRITE ... and file(APPEND ... do exactly the same as "
-      "this one but add some more functionality.\n"
-      "NOTE 2: When using write_file the produced file cannot be used as an "
-      "input to CMake (CONFIGURE_FILE, source file ...) because it will "
-      "lead to an infinite loop. Use configure_file if you want to generate "
-      "input files to CMake.";
-    }
-
   /** This command is kept for compatibility with older CMake versions. */
   virtual bool IsDiscouraged() const
     {