Drop the 'Full' field from cmDocumentationEntry

We need only 'Brief' for usage documentation.  We no longer have builtin
'Full' documentation, which is now in Help/*/*.rst files.

Source/CPack/cpack.cxx

@@ -27,92 +27,42 @@
 #include <cmsys/SystemTools.hxx>
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationName[][3] =
+static const char * cmDocumentationName[][2] =
 {
   {0,
-   "  cpack - Packaging driver provided by CMake.", 0},
-  {0,0,0}
+   "  cpack - Packaging driver provided by CMake."},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationUsage[][3] =
+static const char * cmDocumentationUsage[][2] =
 {
   {0,
-   "  cpack -G <generator> [options]",
-   0},
-  {0,0,0}
+   "  cpack -G <generator> [options]"},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationOptions[][3] =
+static const char * cmDocumentationOptions[][2] =
 {
-    {"-G <generator>", "Use the specified generator to generate package.",
-    "CPack may support multiple native packaging systems on certain "
-      "platforms. A generator is responsible for generating input files for "
-      "particular system and invoking that systems. Possible generator names "
-      "are specified in the Generators section." },
-    {"-C <Configuration>", "Specify the project configuration",
-    "This option specifies the configuration that the project was build "
-      "with, for example 'Debug', 'Release'." },
-    {"-D <var>=<value>", "Set a CPack variable.", \
-    "Set a variable that can be used by the generator."}, \
-    {"--config <config file>", "Specify the config file.",
-    "Specify the config file to use to create the package. By default "
-      "CPackConfig.cmake in the current directory will be used." },
-    {"--verbose,-V","enable verbose output","Run cpack with verbose output."},
-    {"--debug","enable debug output (for CPack developers)",
-     "Run cpack with debug output (for CPack developers)."},
-    {"-P <package name>","override/define CPACK_PACKAGE_NAME",
-     "If the package name is not specified on cpack commmand line then"
-     "CPack.cmake defines it as CMAKE_PROJECT_NAME"},
-    {"-R <package version>","override/define CPACK_PACKAGE_VERSION",
-     "If version is not specified on cpack command line then"
-     "CPack.cmake defines it from CPACK_PACKAGE_VERSION_[MAJOR|MINOR|PATCH]"
-     "look into CPack.cmake for detail"},
-    {"-B <package directory>","override/define CPACK_PACKAGE_DIRECTORY",
-     "The directory where CPack will be doing its packaging work."
-     "The resulting package will be found there. Inside this directory"
-     "CPack creates '_CPack_Packages' sub-directory which is the"
-     "CPack temporary directory."},
-    {"--vendor <vendor name>","override/define CPACK_PACKAGE_VENDOR",
-     "If vendor is not specified on cpack command line "
-     "(or inside CMakeLists.txt) then"
-     "CPack.cmake defines it with a default value"},
-    {"--help-command cmd [file]", "Print help for a single command and exit.",
-    "Full documentation specific to the given command is displayed. "
-    "If a file is specified, the documentation is written into and the output "
-    "format is determined depending on the filename suffix. Supported are man "
-    "page, HTML, DocBook and plain text."},
-    {"--help-command-list [file]", "List available commands and exit.",
-     "The list contains all commands for which help may be obtained by using "
-     "the --help-command argument followed by a command name. "
-    "If a file is specified, the documentation is written into and the output "
-    "format is determined depending on the filename suffix. Supported are man "
-    "page, HTML, DocBook and plain text."},
-    {"--help-commands [file]", "Print help for all commands and exit.",
-     "Full documentation specific for all current command is displayed."
-    "If a file is specified, the documentation is written into and the output "
-    "format is determined depending on the filename suffix. Supported are man "
-    "page, HTML, DocBook and plain text."},
+    {"-G <generator>", "Use the specified generator to generate package."},
+    {"-C <Configuration>", "Specify the project configuration"},
+    {"-D <var>=<value>", "Set a CPack variable."},
+    {"--config <config file>", "Specify the config file."},
+    {"--verbose,-V","enable verbose output"},
+    {"--debug","enable debug output (for CPack developers)"},
+    {"-P <package name>","override/define CPACK_PACKAGE_NAME"},
+    {"-R <package version>","override/define CPACK_PACKAGE_VERSION"},
+    {"-B <package directory>","override/define CPACK_PACKAGE_DIRECTORY"},
+    {"--vendor <vendor name>","override/define CPACK_PACKAGE_VENDOR"},
+    {"--help-command cmd [file]", "Print help for a single command and exit."},
+    {"--help-command-list [file]", "List available commands and exit."},
+    {"--help-commands [file]", "Print help for all commands and exit."},
     {"--help-variable var [file]",
-     "Print help for a single variable and exit.",
-     "Full documentation specific to the given variable is displayed."
-    "If a file is specified, the documentation is written into and the output "
-    "format is determined depending on the filename suffix. Supported are man "
-    "page, HTML, DocBook and plain text."},
-    {"--help-variable-list [file]", "List documented variables and exit.",
-     "The list contains all variables for which help may be obtained by using "
-     "the --help-variable argument followed by a variable name.  If a file is "
-     "specified, the help is written into it."
-    "If a file is specified, the documentation is written into and the output "
-    "format is determined depending on the filename suffix. Supported are man "
-     "page, HTML, DocBook and plain text."},
-    {"--help-variables [file]", "Print help for all variables and exit.",
-     "Full documentation for all variables is displayed."
-    "If a file is specified, the documentation is written into and the output "
-    "format is determined depending on the filename suffix. Supported are man "
-    "page, HTML, DocBook and plain text."},
-    {0,0,0}
+     "Print help for a single variable and exit."},
+    {"--help-variable-list [file]", "List documented variables and exit."},
+    {"--help-variables [file]", "Print help for all variables and exit."},
+    {0,0}
 };
 
 //----------------------------------------------------------------------------
@@ -522,7 +472,6 @@ int main (int argc, char *argv[])
       cmDocumentationEntry e;
       e.Name = generatorIt->first.c_str();
       e.Brief = generatorIt->second.c_str();
-      e.Full = "";
       v.push_back(e);
       }
     doc.SetSection("Generators",v);

Source/CursesDialog/ccmake.cxx

@@ -23,27 +23,27 @@
 #include <form.h>
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationName[][3] =
+static const char * cmDocumentationName[][2] =
 {
   {0,
-   "  ccmake - Curses Interface for CMake.", 0},
-  {0,0,0}
+   "  ccmake - Curses Interface for CMake."},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationUsage[][3] =
+static const char * cmDocumentationUsage[][2] =
 {
   {0,
    "  ccmake <path-to-source>\n"
-   "  ccmake <path-to-existing-build>", 0},
-  {0,0,0}
+   "  ccmake <path-to-existing-build>"},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationOptions[][3] =
+static const char * cmDocumentationOptions[][2] =
 {
   CMAKE_STANDARD_OPTIONS_TABLE,
-  {0,0,0}
+  {0,0}
 };
 
 cmCursesForm* cmCursesForm::CurrentForm=0;

Source/QtDialog/CMakeSetup.cxx

@@ -23,27 +23,27 @@
 #include <cmsys/SystemTools.hxx>
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationName[][3] =
+static const char * cmDocumentationName[][2] =
 {
   {0,
-   "  cmake-gui - CMake GUI.", 0},
-  {0,0,0}
+   "  cmake-gui - CMake GUI."},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationUsage[][3] =
+static const char * cmDocumentationUsage[][2] =
 {
   {0,
    "  cmake-gui [options]\n"
    "  cmake-gui [options] <path-to-source>\n"
-   "  cmake-gui [options] <path-to-existing-build>", 0},
-  {0,0,0}
+   "  cmake-gui [options] <path-to-existing-build>"},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationOptions[][3] =
+static const char * cmDocumentationOptions[][2] =
 {
-  {0,0,0}
+  {0,0}
 };
 
 int main(int argc, char** argv)

Source/cmDocumentation.cxx

@@ -23,35 +23,23 @@
 #include <algorithm>
 
 //----------------------------------------------------------------------------
-static const char *cmDocumentationStandardOptions[][3] =
-{
-  {"--copyright [file]", "Print the CMake copyright and exit.",
-   "If a file is specified, the copyright is written into it."},
-  {"--help,-help,-usage,-h,-H,/?", "Print usage information and exit.",
-   "Usage describes the basic command line interface and its options."},
-  {"--help-full [file]", "Print full help and exit.",
-   "Full help displays most of the documentation provided by the UNIX "
-   "man page.  It is provided for use on non-UNIX platforms, but is "
-   "also convenient if the man page is not installed.  If a file is "
-   "specified, the help is written into it."},
-  {"--help-html [file]", "Print full help in HTML format.",
-   "This option is used by CMake authors to help produce web pages.  "
-   "If a file is specified, the help is written into it."},
-  {"--help-man [file]", "Print full help as a UNIX man page and exit.",
-   "This option is used by the cmake build to generate the UNIX man page.  "
-   "If a file is specified, the help is written into it."},
-  {"--version,-version,/V [file]",
-   "Show program name/version banner and exit.",
-   "If a file is specified, the version is written into it."},
-  {0,0,0}
+static const char *cmDocumentationStandardOptions[][2] =
+{
+  {"--copyright [file]", "Print the CMake copyright and exit."},
+  {"--help,-help,-usage,-h,-H,/?", "Print usage information and exit."},
+  {"--help-full [file]", "Print full help and exit."},
+  {"--help-html [file]", "Print full help in HTML format."},
+  {"--help-man [file]", "Print full help as a UNIX man page and exit."},
+  {"--version,-version,/V [file]"},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char *cmDocumentationGeneratorsHeader[][3] =
+static const char *cmDocumentationGeneratorsHeader[][2] =
 {
   {0,
-   "The following generators are available on this platform:", 0},
-  {0,0,0}
+   "The following generators are available on this platform:"},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
@@ -468,7 +456,7 @@ void cmDocumentation::SetSection(const char *name,
 
 //----------------------------------------------------------------------------
 void cmDocumentation::SetSection(const char *name,
-                                 const char *docs[][3])
+                                 const char *docs[][2])
 {
   cmDocumentationSection *sec =
     new cmDocumentationSection(name,
@@ -490,7 +478,7 @@ void cmDocumentation
 
 //----------------------------------------------------------------------------
 void cmDocumentation::PrependSection(const char *name,
-                                     const char *docs[][3])
+                                     const char *docs[][2])
 {
   cmDocumentationSection *sec = 0;
   if (this->AllSections.find(name) == this->AllSections.end())
@@ -526,7 +514,7 @@ void cmDocumentation::PrependSection(const char *name,
 
 //----------------------------------------------------------------------------
 void cmDocumentation::AppendSection(const char *name,
-                                    const char *docs[][3])
+                                    const char *docs[][2])
 {
   cmDocumentationSection *sec = 0;
   if (this->AllSections.find(name) == this->AllSections.end())

Source/cmDocumentation.h

@@ -65,19 +65,19 @@ public:
   void SetSection(const char *sectionName,
                   std::vector<cmDocumentationEntry> &docs);
   void SetSection(const char *sectionName,
-                  const char *docs[][3]);
+                  const char *docs[][2]);
   void SetSections(std::map<std::string,cmDocumentationSection *>
                    &sections);
 
   /** Add the documentation to the beginning/end of the section */
   void PrependSection(const char *sectionName,
-                      const char *docs[][3]);
+                      const char *docs[][2]);
   void PrependSection(const char *sectionName,
                       std::vector<cmDocumentationEntry> &docs);
   void PrependSection(const char *sectionName,
                       cmDocumentationEntry &docs);
   void AppendSection(const char *sectionName,
-                     const char *docs[][3]);
+                     const char *docs[][2]);
   void AppendSection(const char *sectionName,
                      std::vector<cmDocumentationEntry> &docs);
   void AppendSection(const char *sectionName,

Source/cmDocumentationSection.cxx

@@ -13,69 +13,33 @@
 
 
 //----------------------------------------------------------------------------
-void cmDocumentationSection::Append(const char *data[][3])
+void cmDocumentationSection::Append(const char *data[][2])
 {
   int i = 0;
   while(data[i][1])
     {
     this->Entries.push_back(cmDocumentationEntry(data[i][0],
-                                                 data[i][1],
-                                                 data[i][2]));
+                                                 data[i][1]));
     data += 1;
     }
 }
 
 //----------------------------------------------------------------------------
-void cmDocumentationSection::Prepend(const char *data[][3])
+void cmDocumentationSection::Prepend(const char *data[][2])
 {
   std::vector<cmDocumentationEntry> tmp;
   int i = 0;
   while(data[i][1])
     {
     tmp.push_back(cmDocumentationEntry(data[i][0],
-                                       data[i][1],
-                                       data[i][2]));
+                                       data[i][1]));
     data += 1;
     }
   this->Entries.insert(this->Entries.begin(),tmp.begin(),tmp.end());
 }
 
 //----------------------------------------------------------------------------
-void cmDocumentationSection::Append(const char *n, const char *b,
-                                    const char *f)
+void cmDocumentationSection::Append(const char *n, const char *b)
 {
-  this->Entries.push_back(cmDocumentationEntry(n,b,f));
+  this->Entries.push_back(cmDocumentationEntry(n,b));
 }
-
-#if 0
-//----------------------------------------------------------------------------
-void cmDocumentationSection::Set(const cmDocumentationEntry* header,
-                                 const cmDocumentationEntry* section,
-                                 const cmDocumentationEntry* footer)
-{
-  this->Entries.erase(this->Entries.begin(), this->Entries.end());
-  if(header)
-    {
-    for(const cmDocumentationEntry* op = header; op->brief; ++op)
-      {
-      this->Entries.push_back(*op);
-      }
-    }
-  if(section)
-    {
-    for(const cmDocumentationEntry* op = section; op->brief; ++op)
-      {
-      this->Entries.push_back(*op);
-      }
-    }
-  if(footer)
-    {
-    for(const cmDocumentationEntry* op = footer; op->brief; ++op)
-      {
-      this->Entries.push_back(*op);
-      }
-    }
-  cmDocumentationEntry empty = {0,0,0};
-  this->Entries.push_back(empty);
-}
-#endif

Source/cmDocumentationSection.h

@@ -48,11 +48,11 @@ public:
   { this->Entries.insert(this->Entries.end(),entries.begin(),entries.end()); }
 
   /** Append an entry to this section using NULL terminated chars */
-  void Append(const char *[][3]);
-  void Append(const char *n, const char *b, const char *f);
+  void Append(const char *[][2]);
+  void Append(const char *n, const char *b);
 
   /** prepend some documentation to this section */
-  void Prepend(const char *[][3]);
+  void Prepend(const char *[][2]);
   void Prepend(const std::vector<cmDocumentationEntry> &entries)
   { this->Entries.insert(this->Entries.begin(),
                          entries.begin(),entries.end()); }

Source/cmExtraCodeBlocksGenerator.cxx

@@ -42,13 +42,6 @@ void cmExtraCodeBlocksGenerator
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates CodeBlocks project files.";
-  entry.Full =
-    "Project files for CodeBlocks will be created in the top directory "
-    "and in every subdirectory which features a CMakeLists.txt file "
-    "containing a PROJECT() call. "
-    "Additionally a hierarchy of makefiles is generated into the "
-    "build tree.  The appropriate make program can build the project through "
-    "the default make target.  A \"make install\" target is also provided.";
 }
 
 cmExtraCodeBlocksGenerator::cmExtraCodeBlocksGenerator()

Source/cmExtraEclipseCDT4Generator.cxx

@@ -48,13 +48,6 @@ void cmExtraEclipseCDT4Generator
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates Eclipse CDT 4.0 project files.";
-  entry.Full =
-    "Project files for Eclipse will be created in the top directory. "
-    "In out of source builds, a linked resource to the top level source "
-    "directory will be created. "
-    "Additionally a hierarchy of makefiles is generated into the "
-    "build tree. The appropriate make program can build the project through "
-    "the default make target. A \"make install\" target is also provided.";
 }
 
 //----------------------------------------------------------------------------

Source/cmExtraSublimeTextGenerator.cxx

@@ -45,13 +45,6 @@ void cmExtraSublimeTextGenerator
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates Sublime Text 2 project files.";
-  entry.Full =
-    "Project files for Sublime Text 2 will be created in the top directory "
-    "and in every subdirectory which features a CMakeLists.txt file "
-    "containing a PROJECT() call. "
-    "Additionally Makefiles (or build.ninja files) are generated into the "
-    "build tree.  The appropriate make program can build the project through "
-    "the default make target.  A \"make install\" target is also provided.";
 }
 
 cmExtraSublimeTextGenerator::cmExtraSublimeTextGenerator()

Source/cmGlobalBorlandMakefileGenerator.cxx

@@ -59,5 +59,4 @@ void cmGlobalBorlandMakefileGenerator
 {
   entry.Name = cmGlobalBorlandMakefileGenerator::GetActualName();
   entry.Brief = "Generates Borland makefiles.";
-  entry.Full = "";
 }

Source/cmGlobalJOMMakefileGenerator.cxx

@@ -65,5 +65,4 @@ void cmGlobalJOMMakefileGenerator
 {
   entry.Name = cmGlobalJOMMakefileGenerator::GetActualName();
   entry.Brief = "Generates JOM makefiles.";
-  entry.Full = "";
 }

Source/cmGlobalKdevelopGenerator.cxx

@@ -28,16 +28,6 @@ void cmGlobalKdevelopGenerator
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates KDevelop 3 project files.";
-  entry.Full =
-    "Project files for KDevelop 3 will be created in the top directory "
-    "and in every subdirectory which features a CMakeLists.txt file "
-    "containing a PROJECT() call. "
-    "If you change the settings using KDevelop cmake will try its best "
-    "to keep your changes when regenerating the project files. "
-    "Additionally a hierarchy of UNIX makefiles is generated into the "
-    "build tree.  Any "
-    "standard UNIX-style make program can build the project through the "
-    "default make target.  A \"make install\" target is also provided.";
 }
 
 cmGlobalKdevelopGenerator::cmGlobalKdevelopGenerator()

Source/cmGlobalMSYSMakefileGenerator.cxx

@@ -110,6 +110,4 @@ void cmGlobalMSYSMakefileGenerator
 {
   entry.Name = cmGlobalMSYSMakefileGenerator::GetActualName();
   entry.Brief = "Generates MSYS makefiles.";
-  entry.Full = "The makefiles use /bin/sh as the shell.  "
-    "They require msys to be installed on the machine.";
 }

Source/cmGlobalMinGWMakefileGenerator.cxx

@@ -49,6 +49,4 @@ void cmGlobalMinGWMakefileGenerator
 {
   entry.Name = cmGlobalMinGWMakefileGenerator::GetActualName();
   entry.Brief = "Generates a make file for use with mingw32-make.";
-  entry.Full = "The makefiles generated use cmd.exe as the shell.  "
-    "They do not require msys or a unix shell.";
 }

Source/cmGlobalNMakeMakefileGenerator.cxx

@@ -65,5 +65,4 @@ void cmGlobalNMakeMakefileGenerator
 {
   entry.Name = cmGlobalNMakeMakefileGenerator::GetActualName();
   entry.Brief = "Generates NMake makefiles.";
-  entry.Full = "";
 }

Source/cmGlobalNinjaGenerator.cxx

@@ -470,10 +470,6 @@ void cmGlobalNinjaGenerator
 {
   entry.Name = cmGlobalNinjaGenerator::GetActualName();
   entry.Brief = "Generates build.ninja files (experimental).";
-  entry.Full =
-    "A build.ninja file is generated into the build tree. Recent "
-    "versions of the ninja program can build the project through the "
-    "\"all\" target.  An \"install\" target is also provided.";
 }
 
 // Implemented in all cmGlobaleGenerator sub-classes.

Source/cmGlobalUnixMakefileGenerator3.cxx

@@ -65,10 +65,6 @@ void cmGlobalUnixMakefileGenerator3
 {
   entry.Name = cmGlobalUnixMakefileGenerator3::GetActualName();
   entry.Brief = "Generates standard UNIX makefiles.";
-  entry.Full =
-    "A hierarchy of UNIX makefiles is generated into the build tree.  Any "
-    "standard UNIX-style make program can build the project through the "
-    "default make target.  A \"make install\" target is also provided.";
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio10Generator.cxx

@@ -48,11 +48,6 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry) const {
     entry.Name = "Visual Studio 10";
     entry.Brief = "Generates Visual Studio 10 (2010) project files.";
-    entry.Full =
-      "It is possible to append a space followed by the platform name "
-      "to create project files for a specific target platform. E.g. "
-      "\"Visual Studio 10 Win64\" will create project files for "
-      "the x64 processor; \"Visual Studio 10 IA64\" for Itanium.";
   }
 
   virtual void GetGenerators(std::vector<std::string>& names) const {

Source/cmGlobalVisualStudio11Generator.cxx

@@ -68,11 +68,6 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry) const {
     entry.Name = "Visual Studio 11";
     entry.Brief = "Generates Visual Studio 11 (2012) project files.";
-    entry.Full =
-      "It is possible to append a space followed by the platform name "
-      "to create project files for a specific target platform. E.g. "
-      "\"Visual Studio 11 Win64\" will create project files for "
-      "the x64 processor; \"Visual Studio 11 ARM\" for ARM.";
   }
 
   virtual void GetGenerators(std::vector<std::string>& names) const {

Source/cmGlobalVisualStudio12Generator.cxx

@@ -43,11 +43,6 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry) const {
     entry.Name = "Visual Studio 12";
     entry.Brief = "Generates Visual Studio 12 (2013) project files.";
-    entry.Full =
-      "It is possible to append a space followed by the platform name "
-      "to create project files for a specific target platform. E.g. "
-      "\"Visual Studio 12 Win64\" will create project files for "
-      "the x64 processor; \"Visual Studio 12 ARM\" for ARM.";
   }
 
   virtual void GetGenerators(std::vector<std::string>& names) const {

Source/cmGlobalVisualStudio6Generator.cxx

@@ -405,7 +405,6 @@ void cmGlobalVisualStudio6Generator
 {
   entry.Name = cmGlobalVisualStudio6Generator::GetActualName();
   entry.Brief = "Generates Visual Studio 6 project files.";
-  entry.Full = "";
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio71Generator.cxx

@@ -313,5 +313,4 @@ void cmGlobalVisualStudio71Generator
 {
   entry.Name = cmGlobalVisualStudio71Generator::GetActualName();
   entry.Brief = "Generates Visual Studio .NET 2003 project files.";
-  entry.Full = "";
 }

Source/cmGlobalVisualStudio7Generator.cxx

@@ -841,7 +841,6 @@ void cmGlobalVisualStudio7Generator
 {
   entry.Name = cmGlobalVisualStudio7Generator::GetActualName();
   entry.Brief = "Generates Visual Studio .NET 2002 project files.";
-  entry.Full = "";
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio8Generator.cxx

@@ -65,11 +65,6 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry) const {
     entry.Name = vs8generatorName;
     entry.Brief = "Generates Visual Studio 8 2005 project files.";
-    entry.Full =
-      "It is possible to append a space followed by the platform name "
-      "to create project files for a specific target platform. E.g. "
-      "\"Visual Studio 8 2005 Win64\" will create project files for "
-      "the x64 processor.";
   }
 
   virtual void GetGenerators(std::vector<std::string>& names) const {
@@ -147,7 +142,6 @@ void cmGlobalVisualStudio8Generator
 {
   entry.Name = cmGlobalVisualStudio8Generator::GetActualName();
   entry.Brief = "Generates Visual Studio 8 2005 project files.";
-  entry.Full = "";
 }
 
 //----------------------------------------------------------------------------

Source/cmGlobalVisualStudio9Generator.cxx

@@ -70,11 +70,6 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry) const {
     entry.Name = vs9generatorName;
     entry.Brief = "Generates Visual Studio 9 2008 project files.";
-    entry.Full =
-      "It is possible to append a space followed by the platform name "
-      "to create project files for a specific target platform. E.g. "
-      "\"Visual Studio 9 2008 Win64\" will create project files for "
-      "the x64 processor; \"Visual Studio 9 2008 IA64\" for Itanium.";
   }
 
   virtual void GetGenerators(std::vector<std::string>& names) const {

Source/cmGlobalWatcomWMakeGenerator.cxx

@@ -62,5 +62,4 @@ void cmGlobalWatcomWMakeGenerator
 {
   entry.Name = cmGlobalWatcomWMakeGenerator::GetActualName();
   entry.Brief = "Generates Watcom WMake makefiles.";
-  entry.Full = "";
 }

Source/cmGlobalXCodeGenerator.cxx

@@ -3671,7 +3671,6 @@ void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalXCodeGenerator::GetActualName();
   entry.Brief = "Generate Xcode project files.";
-  entry.Full = "";
 }
 
 //----------------------------------------------------------------------------

Source/cmPropertyDefinition.cxx

@@ -17,7 +17,6 @@ cmDocumentationEntry cmPropertyDefinition::GetDocumentation() const
   cmDocumentationEntry e;
   e.Name = this->Name;
   e.Brief = this->ShortDescription;
-  e.Full = this->FullDescription;
   return e;
 }
 

Source/cmStandardIncludes.h

@@ -321,14 +321,12 @@ struct cmDocumentationEntry
 {
   std::string Name;
   std::string Brief;
-  std::string Full;
   cmDocumentationEntry(){};
-  cmDocumentationEntry(const char *doc[3])
+  cmDocumentationEntry(const char *doc[2])
   { if (doc[0]) this->Name = doc[0];
-  if (doc[1]) this->Brief = doc[1];
-  if (doc[2]) this->Full = doc[2]; };
-  cmDocumentationEntry(const char *n, const char *b, const char *f)
-  { if (n) this->Name = n; if (b) this->Brief = b; if (f) this->Full = f; };
+  if (doc[1]) this->Brief = doc[1];};
+  cmDocumentationEntry(const char *n, const char *b)
+  { if (n) this->Name = n; if (b) this->Brief = b; };
 };
 
 /** Data structure to represent a single command line.  */

Source/cmake.h

@@ -464,43 +464,12 @@ private:
 };
 
 #define CMAKE_STANDARD_OPTIONS_TABLE \
-  {"-C <initial-cache>", "Pre-load a script to populate the cache.", \
-   "When cmake is first run in an empty build tree, it creates a " \
-   "CMakeCache.txt file and populates it with customizable settings " \
-   "for the project.  This option may be used to specify a file from " \
-   "which to load cache entries before the first pass through " \
-   "the project's cmake listfiles.  The loaded entries take priority " \
-   "over the project's default values.  The given file should be a CMake " \
-   "script containing SET commands that use the CACHE option, " \
-   "not a cache-format file."}, \
-  {"-D <var>:<type>=<value>", "Create a cmake cache entry.", \
-   "When cmake is first run in an empty build tree, it creates a " \
-   "CMakeCache.txt file and populates it with customizable settings " \
-   "for the project.  This option may be used to specify a setting " \
-   "that takes priority over the project's default value.  The option " \
-   "may be repeated for as many cache entries as desired."}, \
-  {"-U <globbing_expr>", "Remove matching entries from CMake cache.", \
-   "This option may be used to remove one or more variables from the " \
-   "CMakeCache.txt file, globbing expressions using * and ? are supported. "\
-   "The option may be repeated for as many cache entries as desired.\n" \
-   "Use with care, you can make your CMakeCache.txt non-working."}, \
-  {"-G <generator-name>", "Specify a build system generator.", \
-   "CMake may support multiple native build systems on certain platforms.  " \
-   "A generator is responsible for generating a particular build " \
-   "system.  Possible generator names are specified in the Generators " \
-   "section."},\
-  {"-T <toolset-name>", "Specify toolset name if supported by generator.", \
-   "Some CMake generators support a toolset name to be given to the " \
-   "native build system to choose a compiler.  " \
-   "This is supported only on specific generators:\n" \
-   "  Visual Studio >= 10\n" \
-   "  Xcode >= 3.0\n" \
-   "See native build system documentation for allowed toolset names."}, \
-  {"-Wno-dev", "Suppress developer warnings.",\
-   "Suppress warnings that are meant for the author"\
-   " of the CMakeLists.txt files."},\
-  {"-Wdev", "Enable developer warnings.",\
-   "Enable warnings that are meant for the author"\
-   " of the CMakeLists.txt files."}
+  {"-C <initial-cache>", "Pre-load a script to populate the cache."}, \
+  {"-D <var>:<type>=<value>", "Create a cmake cache entry."}, \
+  {"-U <globbing_expr>", "Remove matching entries from CMake cache."}, \
+  {"-G <generator-name>", "Specify a build system generator."},\
+  {"-T <toolset-name>", "Specify toolset name if supported by generator."}, \
+  {"-Wno-dev", "Suppress developer warnings."},\
+  {"-Wdev", "Enable developer warnings."}
 
 #endif

Source/cmakemain.cxx

@@ -28,20 +28,20 @@
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
 //----------------------------------------------------------------------------
-static const char * cmDocumentationName[][3] =
+static const char * cmDocumentationName[][2] =
 {
   {0,
-   "  cmake - Cross-Platform Makefile Generator.", 0},
-  {0,0,0}
+   "  cmake - Cross-Platform Makefile Generator."},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationUsage[][3] =
+static const char * cmDocumentationUsage[][2] =
 {
   {0,
    "  cmake [options] <path-to-source>\n"
-   "  cmake [options] <path-to-existing-build>", 0},
-  {0,0,0}
+   "  cmake [options] <path-to-existing-build>"},
+  {0,0}
 };
 
 #define CMAKE_BUILD_OPTIONS                                             \
@@ -57,179 +57,50 @@ static const char * cmDocumentationUsage[][3] =
   "  --             = Pass remaining options to the native tool.\n"
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationOptions[][3] =
+static const char * cmDocumentationOptions[][2] =
 {
   CMAKE_STANDARD_OPTIONS_TABLE,
-  {"-E", "CMake command mode.",
-   "For true platform independence, CMake provides a list of commands "
-   "that can be used on all systems. Run with -E help for the usage "
-   "information. Commands available are: chdir, compare_files, copy, "
-   "copy_directory, copy_if_different, echo, echo_append, environment, "
-   "make_directory, md5sum, remove, remove_directory, rename, tar, time, "
-   "touch, touch_nocreate. In addition, some platform specific commands "
-   "are available. "
-   "On Windows: comspec, delete_regv, write_regv. "
-   "On UNIX: create_symlink."},
-  {"-i", "Run in wizard mode.",
-   "Wizard mode runs cmake interactively without a GUI.  The user is "
-   "prompted to answer questions about the project configuration.  "
-   "The answers are used to set cmake cache values."},
-  {"-L[A][H]", "List non-advanced cached variables.",
-   "List cache variables will run CMake and list all the variables from the "
-   "CMake cache that are not marked as INTERNAL or ADVANCED. This will "
-   "effectively display current CMake settings, which can then be changed "
-   "with -D option. Changing some of the variables may result in more "
-   "variables being created. If A is specified, then it will display also "
-   "advanced variables. If H is specified, it will also display help for "
-   "each variable."},
-  {"--build <dir>", "Build a CMake-generated project binary tree.",
-   "This abstracts a native build tool's command-line interface with the "
-   "following options:\n"
-   CMAKE_BUILD_OPTIONS
-   "Run cmake --build with no options for quick help."},
-  {"-N", "View mode only.",
-   "Only load the cache. Do not actually run configure and generate steps."},
-  {"-P <file>", "Process script mode.",
-   "Process the given cmake file as a script written in the CMake language.  "
-   "No configure or generate step is performed and the cache is not"
-   " modified. If variables are defined using -D, this must be done "
-   "before the -P argument."},
-  {"--find-package", "Run in pkg-config like mode.",
-   "Search a package using find_package() and print the resulting flags "
-   "to stdout. This can be used to use cmake instead of pkg-config to find "
-   "installed libraries in plain Makefile-based projects or in "
-   "autoconf-based projects (via share/aclocal/cmake.m4)."},
+  {"-E", "CMake command mode."},
+  {"-i", "Run in wizard mode."},
+  {"-L[A][H]", "List non-advanced cached variables."},
+  {"--build <dir>", "Build a CMake-generated project binary tree."},
+  {"-N", "View mode only."},
+  {"-P <file>", "Process script mode."},
+  {"--find-package", "Run in pkg-config like mode."},
   {"--graphviz=[file]", "Generate graphviz of dependencies, see "
-   "CMakeGraphVizOptions.cmake for more.",
-   "Generate a graphviz input file that will contain all the library and "
-   "executable dependencies in the project. See the documentation for "
-   "CMakeGraphVizOptions.cmake for more details. "},
-  {"--system-information [file]", "Dump information about this system.",
-   "Dump a wide range of information about the current system. If run "
-   "from the top of a binary tree for a CMake project it will dump "
-   "additional information such as the cache, log files etc."},
+   "CMakeGraphVizOptions.cmake for more."},
+  {"--system-information [file]", "Dump information about this system."},
   {"--debug-trycompile", "Do not delete the try_compile build tree. Only "
-   "useful on one try_compile at a time.",
-   "Do not delete the files and directories created for try_compile calls. "
-   "This is useful in debugging failed try_compiles. It may however "
-   "change the results of the try-compiles as old junk from a previous "
-   "try-compile may cause a different test to either pass or fail "
-   "incorrectly.  This option is best used for one try-compile at a time, "
-   "and only when debugging." },
-  {"--debug-output", "Put cmake in a debug mode.",
-   "Print extra stuff during the cmake run like stack traces with "
-   "message(send_error ) calls."},
-  {"--trace", "Put cmake in trace mode.",
-   "Print a trace of all calls made and from where with "
-   "message(send_error ) calls."},
-  {"--warn-uninitialized", "Warn about uninitialized values.",
-   "Print a warning when an uninitialized variable is used."},
-  {"--warn-unused-vars", "Warn about unused variables.",
-   "Find variables that are declared or set, but not used."},
-  {"--no-warn-unused-cli", "Don't warn about command line options.",
-   "Don't find variables that are declared on the command line, but not "
-   "used."},
+   "useful on one try_compile at a time."},
+  {"--debug-output", "Put cmake in a debug mode."},
+  {"--trace", "Put cmake in trace mode."},
+  {"--warn-uninitialized", "Warn about uninitialized values."},
+  {"--warn-unused-vars", "Warn about unused variables."},
+  {"--no-warn-unused-cli", "Don't warn about command line options."},
   {"--check-system-vars", "Find problems with variable usage in system "
-   "files.", "Normally, unused and uninitialized variables are searched for "
-   "only in CMAKE_SOURCE_DIR and CMAKE_BINARY_DIR. This flag tells CMake to "
-   "warn about other files as well."},
-  {"--help-command cmd [file]", "Print help for a single command and exit.",
-   "Full documentation specific to the given command is displayed. "
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-command-list [file]", "List available listfile commands and exit.",
-   "The list contains all commands for which help may be obtained by using "
-   "the --help-command argument followed by a command name. "
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-commands [file]", "Print help for all commands and exit.",
-   "Full documentation specific for all current commands is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-compatcommands [file]", "Print help for compatibility commands. ",
-   "Full documentation specific for all compatibility commands is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-module module [file]", "Print help for a single module and exit.",
-   "Full documentation specific to the given module is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-module-list [file]", "List available modules and exit.",
-   "The list contains all modules for which help may be obtained by using "
-   "the --help-module argument followed by a module name. "
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-modules [file]", "Print help for all modules and exit.",
-   "Full documentation for all modules is displayed. "
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
+   "files."},
+  {"--help-command cmd [file]", "Print help for a single command and exit."},
+  {"--help-command-list [file]", "List available listfile commands and exit."},
+  {"--help-commands [file]", "Print help for all commands and exit."},
+  {"--help-compatcommands [file]", "Print help for compatibility commands. "},
+  {"--help-module module [file]", "Print help for a single module and exit."},
+  {"--help-module-list [file]", "List available modules and exit."},
+  {"--help-modules [file]", "Print help for all modules and exit."},
   {"--help-custom-modules [file]" , "Print help for all custom modules and "
-   "exit.",
-   "Full documentation for all custom modules is displayed. "
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
+   "exit."},
   {"--help-policy cmp [file]",
-   "Print help for a single policy and exit.",
-   "Full documentation specific to the given policy is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-policy-list [file]", "List available policies and exit.",
-   "The list contains all policies for which help may be obtained by using "
-   "the --help-policy argument followed by a policy name. "
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-policies [file]", "Print help for all policies and exit.",
-   "Full documentation for all policies is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
+   "Print help for a single policy and exit."},
+  {"--help-policy-list [file]", "List available policies and exit."},
+  {"--help-policies [file]", "Print help for all policies and exit."},
   {"--help-property prop [file]",
-   "Print help for a single property and exit.",
-   "Full documentation specific to the given property is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-property-list [file]", "List available properties and exit.",
-   "The list contains all properties for which help may be obtained by using "
-   "the --help-property argument followed by a property name.  If a file is "
-   "specified, the help is written into it."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-properties [file]", "Print help for all properties and exit.",
-   "Full documentation for all properties is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
+   "Print help for a single property and exit."},
+  {"--help-property-list [file]", "List available properties and exit."},
+  {"--help-properties [file]", "Print help for all properties and exit."},
   {"--help-variable var [file]",
-   "Print help for a single variable and exit.",
-   "Full documentation specific to the given variable is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-variable-list [file]", "List documented variables and exit.",
-   "The list contains all variables for which help may be obtained by using "
-   "the --help-variable argument followed by a variable name.  If a file is "
-   "specified, the help is written into it."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {"--help-variables [file]", "Print help for all variables and exit.",
-   "Full documentation for all variables is displayed."
-   "If a file is specified, the documentation is written into and the output "
-   "format is determined depending on the filename suffix. Supported are man "
-   "page, HTML, DocBook and plain text."},
-  {0,0,0}
+   "Print help for a single variable and exit."},
+  {"--help-variable-list [file]", "List documented variables and exit."},
+  {"--help-variables [file]", "Print help for all variables and exit."},
+  {0,0}
 };
 
 #endif

Source/ctest.cxx

@@ -20,235 +20,98 @@
 #include "CTest/cmCTestLaunch.h"
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationName[][3] =
+static const char * cmDocumentationName[][2] =
 {
   {0,
-   "  ctest - Testing driver provided by CMake.", 0},
-  {0,0,0}
+   "  ctest - Testing driver provided by CMake."},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
-static const char * cmDocumentationUsage[][3] =
+static const char * cmDocumentationUsage[][2] =
 {
   {0,
-   "  ctest [options]", 0},
-  {0,0,0}
+   "  ctest [options]"},
+  {0,0}
 };
 
 //----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
-static const char * cmDocumentationOptions[][3] =
+static const char * cmDocumentationOptions[][2] =
 {
-  {"-C <cfg>, --build-config <cfg>", "Choose configuration to test.",
-   "Some CMake-generated build trees can have multiple build configurations "
-   "in the same tree.  This option can be used to specify which one should "
-   "be tested.  Example configurations are \"Debug\" and \"Release\"."},
-  {"-V,--verbose", "Enable verbose output from tests.",
-   "Test output is normally suppressed and only summary information is "
-   "displayed.  This option will show all test output."},
-  {"-VV,--extra-verbose", "Enable more verbose output from tests.",
-   "Test output is normally suppressed and only summary information is "
-   "displayed.  This option will show even more test output."},
-  {"--debug", "Displaying more verbose internals of CTest.",
-    "This feature will result in a large number of output that is mostly "
-    "useful for debugging dashboard problems."},
-  {"--output-on-failure", "Output anything outputted by the test program "
-   "if the test should fail.  This option can also be enabled by setting "
-   "the environment variable CTEST_OUTPUT_ON_FAILURE"},
-  {"-F", "Enable failover.", "This option allows ctest to resume a test "
-   "set execution that was previously interrupted.  If no interruption "
-   "occurred, the -F option will have no effect."},
+  {"-C <cfg>, --build-config <cfg>", "Choose configuration to test."},
+  {"-V,--verbose", "Enable verbose output from tests."},
+  {"-VV,--extra-verbose", "Enable more verbose output from tests."},
+  {"--debug", "Displaying more verbose internals of CTest."},
+  {"--output-on-failure"},
+  {"-F", "Enable failover."},
   {"-j <jobs>, --parallel <jobs>", "Run the tests in parallel using the"
-   "given number of jobs.",
-   "This option tells ctest to run the tests in parallel using given "
-   "number of jobs.  This option can also be set by setting "
-   "the environment variable CTEST_PARALLEL_LEVEL."},
-  {"-Q,--quiet", "Make ctest quiet.",
-    "This option will suppress all the output. The output log file will "
-    "still be generated if the --output-log is specified. Options such "
-    "as --verbose, --extra-verbose, and --debug are ignored if --quiet is "
-    "specified."},
-  {"-O <file>, --output-log <file>", "Output to log file",
-   "This option tells ctest to write all its output to a log file."},
-  {"-N,--show-only", "Disable actual execution of tests.",
-   "This option tells ctest to list the tests that would be run but not "
-   "actually run them.  Useful in conjunction with the -R and -E options."},
+   "given number of jobs."},
+  {"-Q,--quiet", "Make ctest quiet."},
+  {"-O <file>, --output-log <file>", "Output to log file"},
+  {"-N,--show-only", "Disable actual execution of tests."},
   {"-L <regex>, --label-regex <regex>", "Run tests with labels matching "
-   "regular expression.",
-   "This option tells ctest to run only the tests whose labels match the "
-   "given regular expression."},
+   "regular expression."},
   {"-R <regex>, --tests-regex <regex>", "Run tests matching regular "
-   "expression.",
-   "This option tells ctest to run only the tests whose names match the "
-   "given regular expression."},
+   "expression."},
   {"-E <regex>, --exclude-regex <regex>", "Exclude tests matching regular "
-   "expression.",
-   "This option tells ctest to NOT run the tests whose names match the "
-   "given regular expression."},
+   "expression."},
   {"-LE <regex>, --label-exclude <regex>", "Exclude tests with labels "
-   "matching regular expression.",
-   "This option tells ctest to NOT run the tests whose labels match the "
-   "given regular expression."},
-  {"-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test",
-   "This option tells ctest to act as a Dart client and perform "
-   "a dashboard test. All tests are <Mode><Test>, where Mode can be "
-   "Experimental, Nightly, and Continuous, and Test can be Start, Update, "
-   "Configure, Build, Test, Coverage, and Submit."},
-  {"-D <var>:<type>=<value>", "Define a variable for script mode",
-   "Pass in variable values on the command line. Use in "
-   "conjunction with -S to pass variable values to a dashboard script. "
-   "Parsing -D arguments as variable values is only attempted if "
-   "the value following -D does not match any of the known dashboard "
-   "types."},
-  {"-M <model>, --test-model <model>", "Sets the model for a dashboard",
-   "This option tells ctest to act as a Dart client "
-   "where the TestModel can be Experimental, "
-   "Nightly, and Continuous. Combining -M and -T is similar to -D"},
+   "matching regular expression."},
+  {"-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test"},
+  {"-D <var>:<type>=<value>", "Define a variable for script mode"},
+  {"-M <model>, --test-model <model>", "Sets the model for a dashboard"},
   {"-T <action>, --test-action <action>", "Sets the dashboard action to "
-   "perform",
-   "This option tells ctest to act as a Dart client "
-   "and perform some action such as start, build, test etc. "
-   "Combining -M and -T is similar to -D"},
-  {"--track <track>", "Specify the track to submit dashboard to",
-   "Submit dashboard to specified track instead of default one. By "
-   "default, the dashboard is submitted to Nightly, Experimental, or "
-   "Continuous track, but by specifying this option, the track can be "
-   "arbitrary."},
+   "perform"},
+  {"--track <track>", "Specify the track to submit dashboard to"},
   {"-S <script>, --script <script>", "Execute a dashboard for a "
-   "configuration",
-   "This option tells ctest to load in a configuration script which sets "
-   "a number of parameters such as the binary and source directories. Then "
-   "ctest will do what is required to create and run a dashboard. This "
-   "option basically sets up a dashboard and then runs ctest -D with the "
-   "appropriate options."},
+   "configuration"},
   {"-SP <script>, --script-new-process <script>", "Execute a dashboard for a "
-   "configuration",
-   "This option does the same operations as -S but it will do them in a "
-   "separate process. This is primarily useful in cases where the script "
-   "may modify the environment and you do not want the modified environment "
-   "to impact other -S scripts."},
-  {"-A <file>, --add-notes <file>", "Add a notes file with submission",
-   "This option tells ctest to include a notes file when submitting "
-   "dashboard. "},
+   "configuration"},
+  {"-A <file>, --add-notes <file>", "Add a notes file with submission"},
   {"-I [Start,End,Stride,test#,test#|Test file], --tests-information",
-   "Run a specific number of tests by number.",
-   "This option causes ctest to run tests starting at number Start, ending "
-   "at number End, and incrementing by Stride. Any additional numbers after "
-   "Stride are considered individual test numbers.  Start, End,or stride "
-   "can be empty.  Optionally a file can be given that contains the same "
-   "syntax as the command line."},
-  {"-U, --union", "Take the Union of -I and -R",
-   "When both -R and -I are specified by default the intersection of "
-   "tests are run. By specifying -U the union of tests is run instead."},
-  {"--rerun-failed", "Run only the tests that failed previously",
-   "This option tells ctest to perform only the tests that failed during its "
-   "previous run. When this option is specified, ctest ignores all other "
-   "options intended to modify the list of tests to run "
-   "(-L, -R, -E, -LE, -I, etc). In the event that CTest runs and no tests "
-   "fail, subsequent calls to ctest with the --rerun-failed option will "
-   "run the set of tests that most recently failed (if any)."},
-  {"--max-width <width>", "Set the max width for a test name to output",
-   "Set the maximum width for each test name to show in the output.  This "
-   "allows the user to widen the output to avoid clipping the test name which "
-   "can be very annoying."},
-  {"--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1.",
-   "This option causes ctest to run tests in either an interactive mode or "
-   "a non-interactive mode. On Windows this means that in non-interactive "
-   "mode, all system debug pop up windows are blocked. In dashboard mode "
-   "(Experimental, Nightly, Continuous), the default is non-interactive.  "
-   "When just running tests not for a dashboard the default is to allow "
-   "popups and interactive "
-   "debugging."},
-  {"--no-label-summary", "Disable timing summary information for labels.",
-   "This option tells ctest not to print summary information for each label "
-   "associated with the tests run. If there are no labels on the "
-   "tests, nothing extra is printed."},
-  {"--build-and-test", "Configure, build and run a test.",
-   "This option tells ctest to configure (i.e. run cmake on), build, and or "
-   "execute a test. The configure and test steps are optional. The arguments "
-   "to this command line are the source and binary directories. By default "
-   "this will run CMake on the Source/Bin directories specified unless "
-   "--build-nocmake is specified. Both --build-makeprogram and "
-   "--build-generator MUST be provided to use --build-and-test. If "
-   "--test-command is specified then that will be run after the build is "
-   "complete. Other options that affect this mode are --build-target "
-   "--build-nocmake, --build-run-dir, "
-   "--build-two-config, --build-exe-dir, --build-project,"
-   "--build-noclean, --build-options"},
-  {"--build-target", "Specify a specific target to build.",
-   "This option goes with the --build-and-test option, if left out the all "
-   "target is built." },
-  {"--build-nocmake", "Run the build without running cmake first.",
-   "Skip the cmake step." },
-  {"--build-run-dir", "Specify directory to run programs from.",
-   "Directory where programs will be after it has been compiled." },
-  {"--build-two-config", "Run CMake twice", "" },
-  {"--build-exe-dir", "Specify the directory for the executable.", "" },
-  {"--build-generator", "Specify the generator to use.", "" },
-  {"--build-generator-toolset", "Specify the generator-specific toolset.",""},
-  {"--build-project", "Specify the name of the project to build.", "" },
-  {"--build-makeprogram", "Specify the make program to use.", "" },
-  {"--build-noclean", "Skip the make clean step.", "" },
+   "Run a specific number of tests by number."},
+  {"-U, --union", "Take the Union of -I and -R"},
+  {"--rerun-failed", "Run only the tests that failed previously"},
+  {"--max-width <width>", "Set the max width for a test name to output"},
+  {"--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1."},
+  {"--no-label-summary", "Disable timing summary information for labels."},
+  {"--build-and-test", "Configure, build and run a test."},
+  {"--build-target", "Specify a specific target to build."},
+  {"--build-nocmake", "Run the build without running cmake first."},
+  {"--build-run-dir", "Specify directory to run programs from."},
+  {"--build-two-config", "Run CMake twice"},
+  {"--build-exe-dir", "Specify the directory for the executable."},
+  {"--build-generator", "Specify the generator to use."},
+  {"--build-generator-toolset", "Specify the generator-specific toolset."},
+  {"--build-project", "Specify the name of the project to build."},
+  {"--build-makeprogram", "Specify the make program to use."},
+  {"--build-noclean", "Skip the make clean step."},
   {"--build-config-sample",
-   "A sample executable to use to determine the configuration",
-   "A sample executable to use to determine the configuration that "
-   "should be used. e.g. Debug/Release/etc" },
-  {"--build-options", "Add extra options to the build step.",
-   "This option must be the last option with the exception of --test-command"
-  },
+   "A sample executable to use to determine the configuration"},
+  {"--build-options", "Add extra options to the build step."},
 
-  {"--test-command", "The test to run with the --build-and-test option.", ""
-  },
-  {"--test-timeout", "The time limit in seconds, internal use only.", ""
-  },
-  {"--tomorrow-tag", "Nightly or experimental starts with next day tag.",
-   "This is useful if the build will not finish in one day." },
+  {"--test-command", "The test to run with the --build-and-test option."},
+  {"--test-timeout", "The time limit in seconds, internal use only."},
+  {"--tomorrow-tag", "Nightly or experimental starts with next day tag."},
   {"--ctest-config", "The configuration file used to initialize CTest state "
-  "when submitting dashboards.",
-   "This option tells CTest to use different initialization file instead of "
-   "CTestConfiguration.tcl. This way multiple initialization files can be "
-   "used for example to submit to multiple dashboards." },
-  {"--overwrite", "Overwrite CTest configuration option.",
-   "By default ctest uses configuration options from configuration file. "
-   "This option will overwrite the configuration option." },
-  {"--extra-submit <file>[;<file>]", "Submit extra files to the dashboard.",
-   "This option will submit extra files to the dashboard." },
-  {"--force-new-ctest-process", "Run child CTest instances as new processes",
-   "By default CTest will run child CTest instances within the same process. "
-   "If this behavior is not desired, this argument will enforce new "
-   "processes for child CTest processes." },
-  {"--schedule-random", "Use a random order for scheduling tests",
-   "This option will run the tests in a random order. It is commonly used to "
-   "detect implicit dependencies in a test suite." },
-  {"--submit-index", "Submit individual dashboard tests with specific index",
-   "This option allows performing the same CTest action (such as test) "
-   "multiple times and submit all stages to the same dashboard (Dart2 "
-   "required). Each execution requires different index." },
-  {"--timeout <seconds>", "Set a global timeout on all tests.",
-   "This option will set a global timeout on all tests that do not already "
-   "have a timeout set on them."},
-  {"--stop-time <time>", "Set a time at which all tests should stop running.",
-   "Set a real time of day at which all tests should timeout. Example: "
-   "7:00:00 -0400. Any time format understood by the curl date parser is "
-   "accepted. Local time is assumed if no timezone is specified."},
-  {"--http1.0", "Submit using HTTP 1.0.",
-  "This option will force CTest to use HTTP 1.0 to submit files to the "
-  "dashboard, instead of HTTP 1.1."},
-  {"--no-compress-output", "Do not compress test output when submitting.",
-   "This flag will turn off automatic compression of test output.  Use this "
-   "to maintain compatibility with an older version of CDash which doesn't "
-   "support compressed test output."},
-  {"--print-labels", "Print all available test labels.",
-   "This option will not run any tests, it will simply print the list of "
-   "all labels associated with the test set."},
-  {"--help-command <cmd> [<file>]", "Show help for a single command and exit.",
-   "Prints the help for the command to stdout or to the specified file." },
-  {"--help-command-list [<file>]", "List available commands and exit.",
-   "Prints the list of all available listfile commands to stdout or the "
-   "specified file." },
-  {"--help-commands [<file>]", "Print help for all commands and exit.",
-   "Prints the help for all commands to stdout or to the specified file." },
-  {0,0,0}
+  "when submitting dashboards."},
+  {"--overwrite", "Overwrite CTest configuration option."},
+  {"--extra-submit <file>[;<file>]", "Submit extra files to the dashboard."},
+  {"--force-new-ctest-process", "Run child CTest instances as new processes"},
+  {"--schedule-random", "Use a random order for scheduling tests"},
+  {"--submit-index", "Submit individual dashboard tests with specific index"},
+  {"--timeout <seconds>", "Set a global timeout on all tests."},
+  {"--stop-time <time>",
+   "Set a time at which all tests should stop running."},
+  {"--http1.0", "Submit using HTTP 1.0."},
+  {"--no-compress-output", "Do not compress test output when submitting."},
+  {"--print-labels", "Print all available test labels."},
+  {"--help-command <cmd> [<file>]",
+   "Show help for a single command and exit."},
+  {"--help-command-list [<file>]", "List available commands and exit."},
+  {"--help-commands [<file>]", "Print help for all commands and exit."},
+  {0,0}
 };
 
 // this is a test driver program for cmCTest.