Drop builtin command documentation

Drop all GetTerseDocumentation and GetFullDocumentation methods from
commands.  The command documentation is now in Help/command/*.rst files.

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}

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);
 

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:

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:

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);
 
 };

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:

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);
 
 };

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);
 };
 

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);
 
 };

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:

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:

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:

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;

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:

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:

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);
 };
 

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);

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);
 };
 

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);
 };
 

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);
 };
 

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);
 };
 

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);
 };
 

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);
 };
 

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);

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);
 };
 

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);
 };
 

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);
 };
 

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
     {

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:

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:

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);

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.
    */

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; }
 

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);
 };
 

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;

Source/cmDocumentGeneratorExpressions.h

@@ -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

Source/cmDocumentLocationUndefined.h

@@ -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

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);
 };
 

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);
 };
 

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);
 };
 

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);
 
 };

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);
 };
 

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);
 };
 

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);
 };
 

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);
 };
 

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);
 };
 

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
     {

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);
 };
 

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:

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
     {

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.

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:

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)
 {

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;

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()
 {

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;

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");
-}

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();
 };
 
 

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 &)

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();

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 &)

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;

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 &)

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);

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 &)

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);

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);

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;

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);
 };
 

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);
 };
 

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);
 };
 

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);
 };
 

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 };

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);
 };
 

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);
 };
 

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);
 };
 

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.

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);
 };
 

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:

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);
 };
 

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);
 };
 

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:

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
     {

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
     {

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
     {

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);

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
     {

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);

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:
 

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;

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);
 };
 

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;

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);
 };
 

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
     {

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

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:
 

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);
 };
 

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.
    */

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
     {

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);
 };