BUG: revert doc changes since VS7 cannot compile them, will implement them in a different manner

Source/CPack/cpack.cxx

@@ -33,30 +33,30 @@
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationName[] =
 {
-  {"",
-   "  cpack - Packaging driver provided by CMake.", ""},
-  {"","",""}
+  {0,
+   "  cpack - Packaging driver provided by CMake.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationUsage[] =
 {
-  {"",
+  {0,
    "  cpack -G <generator> [options]",
-   ""},
-  {"","",""}
+   0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationDescription[] =
 {
-  {"",
+  {0,
    "The \"cpack\" executable is the CMake packaging program.  "
    "CMake-generated build trees created for projects that use "
    "the INSTALL_* commands have packaging support.  "
-   "This program will generate the package.", ""},
+   "This program will generate the package.", 0},
   CMAKE_STANDARD_INTRODUCTION,
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
@@ -75,15 +75,15 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
     {"--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." },
-    {"","",""}
+    {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationSeeAlso[] =
 {
-    {"", "cmake", ""},
-    {"", "ccmake", ""},
-    {"", "", ""}
+    {0, "cmake", 0},
+    {0, "ccmake", 0},
+    {0, 0, 0}
 };
 
 //----------------------------------------------------------------------------
@@ -464,7 +464,7 @@ int main (int argc, char *argv[])
       e.full = "";
       v.push_back(e);
       }
-    cmDocumentationEntry empty = {"","",""};
+    cmDocumentationEntry empty = {0,0,0};
     v.push_back(empty);
     doc.SetGeneratorsSection(&v[0]);
 

Source/MFCDialog/CMakeSetup.cpp

@@ -12,31 +12,31 @@
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationName[] =
 {
-  {"",
-   "  CMakeSetup - CMake Windows GUI.", ""},
-  {"","",""}
+  {0,
+   "  CMakeSetup - CMake Windows GUI.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationUsage[] =
 {
-  {"",
+  {0,
    "  CMakeSetup [options]\n"
    "  CMakeSetup [options] <path-to-source>\n"
-   "  CMakeSetup [options] <path-to-existing-build>", ""},
-  {"","",""}
+   "  CMakeSetup [options] <path-to-existing-build>", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationDescription[] =
 {
-  {"",
+  {0,
    "The \"CMakeSetup\" executable is the CMake Windows GUI.  Project "
    "configuration settings may be specified interactively.  "
    "Brief instructions are provided at the bottom of the "
-   "window when the program is running.", ""},
+   "window when the program is running.", 0},
   CMAKE_STANDARD_INTRODUCTION,
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
@@ -47,7 +47,7 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
    "advanced.  Most users will not need to change the advanced options.  "
    "The CMakeSetup GUI contains a checkbox to enable/disable display of "
    "advanced options.  This command line flag changes its default setting."},
-  {"","",""}
+  {0,0,0}
 };
 
 #ifdef _DEBUG

Source/cmDocumentation.cxx

@@ -21,7 +21,7 @@
 #include <cmsys/Directory.hxx>
 
 
-const cmDocumentationEntry cmDocumentation::cmSection::EmptySection ={"","",""};
+const cmDocumentationEntry cmDocumentation::cmSection::EmptySection ={0,0,0};
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationStandardOptions[] =
@@ -43,165 +43,165 @@ static const cmDocumentationEntry cmDocumentationStandardOptions[] =
    "If a file is specified, the help is written into it."},
   {"--version [file]", "Show program name/version banner and exit.",
    "If a file is specified, the version is written into it."},
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmModulesDocumentationDescription[] =
 {
-  {"",
+  {0,
   "  CMake Modules - Modules coming with CMake, the Cross-Platform Makefile "
-  "Generator.", ""},
+  "Generator.", 0},
 //  CMAKE_DOCUMENTATION_OVERVIEW,
-  {"",
+  {0,
   "This is the documentation for the modules and scripts coming with CMake. "
   "Using these modules you can check the computer system for "
   "installed software packages, features of the compiler and the "
-  "existance of headers to name just a few.", ""},
-  {"","",""}
+  "existance of headers to name just a few.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmCustomModulesDocumentationDescription[] =
 {
-  {"",
-  "  Custom CMake Modules - Additional Modules for CMake.", ""},
+  {0,
+  "  Custom CMake Modules - Additional Modules for CMake.", 0},
 //  CMAKE_DOCUMENTATION_OVERVIEW,
-  {"",
+  {0,
   "This is the documentation for additional modules and scripts for CMake. "
   "Using these modules you can check the computer system for "
   "installed software packages, features of the compiler and the "
-  "existance of headers to name just a few.", ""},
-  {"","",""}
+  "existance of headers to name just a few.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmPropertiesDocumentationDescription[] =
 {
-  {"",
+  {0,
    "  CMake Properties - Properties supported by CMake, "
-   "the Cross-Platform Makefile Generator.", ""},
+   "the Cross-Platform Makefile Generator.", 0},
 //  CMAKE_DOCUMENTATION_OVERVIEW,
-  {"",
+  {0,
    "This is the documentation for the properties supported by CMake. "
    "Properties can have different scopes. They can either be assigned to a "
    "source file, a directory, a target or globally to CMake. By modifying the "
    "values of properties the behaviour of the buildsystem can be customized.",
-   ""},
-  {"","",""}
+   0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmCompatCommandsDocumentationDescription[] =
 {
-  {"",
+  {0,
    "  CMake Compatibility Listfile Commands - "
-   "Obsolete commands supported by CMake for compatibility.", ""},
+   "Obsolete commands supported by CMake for compatibility.", 0},
 //  CMAKE_DOCUMENTATION_OVERVIEW,
-  {"",
+  {0,
   "This is the documentation for now obsolete listfile commands from previous "
   "CMake versions, which are still supported for compatibility reasons. You "
-  "should instead use the newer, faster and shinier new commands. ;-)", ""},
-  {"","",""}
+  "should instead use the newer, faster and shinier new commands. ;-)", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationCommandsHeader[] =
 {
-  {"",
-   "The following commands are available in CMakeLists.txt code:", ""},
-  {"","",""}
+  {0,
+   "The following commands are available in CMakeLists.txt code:", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationGlobalPropertiesHeader[] =
 {
-  {"",
-   "The following global properties are available in CMakeLists.txt code:", ""},
-  {"","",""}
+  {0,
+   "The following global properties are available in CMakeLists.txt code:", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationDirectoryPropertiesHeader[] =
 {
-  {""
+  {0
    ,"The following directory properties are available in CMakeLists.txt code:"
-   ,""},
-  {"","",""}
+   ,0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationTargetPropertiesHeader[] =
 {
-  {"",
-   "The following target properties are available in CMakeLists.txt code:", ""},
-  {"","",""}
+  {0,
+   "The following target properties are available in CMakeLists.txt code:", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationTestPropertiesHeader[] =
 {
-  {""
+  {0
    ,"The following properties for tests are available in CMakeLists.txt code:"
-   ,""},
-  {"","",""}
+   ,0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationSourceFilePropertiesHeader[] =
 {
-  {""
+  {0
   ,"The following source file properties are available in CMakeLists.txt code:"
-  , ""},
-  {"","",""}
+  , 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationVariablePropertiesHeader[] =
 {
-  {"", "The following variables are available in CMakeLists.txt code:", ""},
-  {"","",""}
+  {0, "The following variables are available in CMakeLists.txt code:", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry 
                              cmDocumentationCachedVariablePropertiesHeader[] =
 {
-  {"","The following cache variables are available in CMakeLists.txt code:", ""},
-  {"","",""}
+  {0,"The following cache variables are available in CMakeLists.txt code:", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationModulesHeader[] =
 {
-  {"",
+  {0,
    "The following modules are provided with CMake. "
-   "They can be used with INCLUDE(ModuleName).", ""},
-  {"","",""}
+   "They can be used with INCLUDE(ModuleName).", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationCustomModulesHeader[] =
 {
-  {"",
+  {0,
    "The following modules are also available for CMake. "
-   "They can be used with INCLUDE(ModuleName).", ""},
-  {"","",""}
+   "They can be used with INCLUDE(ModuleName).", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationGeneratorsHeader[] =
 {
-  {"",
-   "The following generators are available on this platform:", ""},
-  {"","",""}
+  {0,
+   "The following generators are available on this platform:", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationStandardSeeAlso[] =
 {
-  {"",
-   "The following resources are available to get help using CMake:", ""},
+  {0,
+   "The following resources are available to get help using CMake:", 0},
   {"Home Page",
    "http://www.cmake.org",
    "The primary starting point for learning about CMake."},
@@ -218,51 +218,51 @@ static const cmDocumentationEntry cmDocumentationStandardSeeAlso[] =
    "The list is member-post-only but one may sign up on the CMake web page. "
    "Please first read the full documentation at "
    "http://www.cmake.org before posting questions to the list."},
-  {"",
+  {0,
    "Summary of helpful links:\n"
    "  Home: http://www.cmake.org\n"
    "  Docs: http://www.cmake.org/HTML/Documentation.html\n"
    "  Mail: http://www.cmake.org/HTML/MailingLists.html\n"
    "  FAQ:  http://www.cmake.org/Wiki/CMake_FAQ\n"
-   , ""},
-  {"","",""}
+   , 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 const cmDocumentationEntry cmDocumentationAuthor[] =
 {
-  {"",
-   "This manual page was generated by the \"--help-man\" option.", ""},
-  {"","",""}
+  {0,
+   "This manual page was generated by the \"--help-man\" option.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 const cmDocumentationEntry cmDocumentationCopyright[] =
 {
-  {"",
+  {0,
    "Copyright (c) 2002 Kitware, Inc., Insight Consortium.  "
-   "All rights reserved.", ""},
-  {"",
+   "All rights reserved.", 0},
+  {0,
    "Redistribution and use in source and binary forms, with or without "
    "modification, are permitted provided that the following conditions are "
-   "met:", ""},
+   "met:", 0},
   {"",
    "Redistributions of source code must retain the above copyright notice, "
-   "this list of conditions and the following disclaimer.", ""},
+   "this list of conditions and the following disclaimer.", 0},
   {"",
    "Redistributions in binary form must reproduce the above copyright "
    "notice, this list of conditions and the following disclaimer in the "
    "documentation and/or other materials provided with the distribution.",
-   ""},
+   0},
   {"",
    "The names of Kitware, Inc., the Insight Consortium, or the names of "
    "any consortium members, or of any contributors, may not be used to "
    "endorse or promote products derived from this software without "
-   "specific prior written permission.", ""},
+   "specific prior written permission.", 0},
   {"",
    "Modified source versions must be plainly marked as such, and must "
-   "not be misrepresented as being the original software.", ""},
-  {"",
+   "not be misrepresented as being the original software.", 0},
+  {0,
    "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "
    "``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "
    "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR "
@@ -273,8 +273,8 @@ const cmDocumentationEntry cmDocumentationCopyright[] =
    "PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF "
    "LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING "
    "NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS "
-   "SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.", ""},
-  {"", "", ""}
+   "SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.", 0},
+  {0, 0, 0}
 };
 
 //----------------------------------------------------------------------------
@@ -332,18 +332,18 @@ cmDocumentation::~cmDocumentation()
 bool cmDocumentation::PrintCopyright(std::ostream& os)
 {
   for(const cmDocumentationEntry* op = cmDocumentationCopyright;
-      op->brief.size(); ++op)
+      op->brief; ++op)
     {
-    if(op->name.size())
+    if(op->name)
       {
       os << " * ";
       this->TextFormatter.SetIndent("    ");
-      this->TextFormatter.PrintColumn(os, op->brief.c_str());
+      this->TextFormatter.PrintColumn(os, op->brief);
       }
     else
       {
       this->TextFormatter.SetIndent("");
-      this->TextFormatter.PrintColumn(os, op->brief.c_str());
+      this->TextFormatter.PrintColumn(os, op->brief);
       }
     os << "\n";
     }
@@ -441,7 +441,7 @@ bool cmDocumentation::CreateModulesSection()
     {
     this->ModulesSection.Append(cmDocumentationModulesHeader[0]);
     this->CreateModuleDocsForDir(dir, this->ModulesSection);
-    cmDocumentationEntry e = { "", "", "" };
+    cmDocumentationEntry e = { 0, 0, 0 };
     this->ModulesSection.Append(e);
     }
   return true;
@@ -475,7 +475,7 @@ bool cmDocumentation::CreateCustomModulesSection()
 
   if(sectionHasHeader)
     {
-    cmDocumentationEntry e = { "", "", "" };
+    cmDocumentationEntry e = { 0, 0, 0 };
     this->CustomModulesSection.Append(e);
     }
   return true;
@@ -927,20 +927,20 @@ void cmDocumentation::SetSeeAlsoList(const cmDocumentationEntry* also)
 {
   this->SeeAlsoSection.Clear();
   this->SeeAlsoString = ".B ";
-  for(const cmDocumentationEntry* i = also; i->brief.size(); ++i)
+  for(const cmDocumentationEntry* i = also; i->brief; ++i)
     {
     this->SeeAlsoString += i->brief;
-    this->SeeAlsoString += (i+1)->brief.size() ? "(1), ":"(1)";    
+    this->SeeAlsoString += (i+1)->brief? "(1), ":"(1)";    
     }
-  cmDocumentationEntry e = {"", "", ""};
+  cmDocumentationEntry e = {0, 0, 0};
   e.brief = this->SeeAlsoString.c_str();
   this->SeeAlsoSection.Append(e);
   for(const cmDocumentationEntry* i = cmDocumentationStandardSeeAlso;
-      i->brief.size(); ++i)
+      i->brief; ++i)
     {
     this->SeeAlsoSection.Append(*i);
     }
-  e.brief = "";
+  e.brief = 0;
   this->SeeAlsoSection.Append(e);
 }
 
@@ -958,9 +958,9 @@ bool cmDocumentation::PrintDocumentationSingle(std::ostream& os)
     return false;
     }
   for(const cmDocumentationEntry* entry = this->CommandsSection.GetEntries();
-      entry->brief.size(); ++entry)
+      entry->brief; ++entry)
     {
-    if(entry->name.size() && this->CurrentArgument == entry->name)
+    if(entry->name && this->CurrentArgument == entry->name)
       {
       this->PrintDocumentationCommand(os, entry);
       return true;
@@ -968,10 +968,10 @@ bool cmDocumentation::PrintDocumentationSingle(std::ostream& os)
     }
   for(const cmDocumentationEntry* 
       entry = this->CompatCommandsSection.GetEntries();
-      entry->brief.size(); 
+      entry->brief; 
       ++entry)
     {
-    if(entry->name.size() && this->CurrentArgument == entry->name)
+    if(entry->name && this->CurrentArgument == entry->name)
       {
       this->PrintDocumentationCommand(os, entry);
       return true;
@@ -1061,10 +1061,9 @@ bool cmDocumentation::PrintDocumentationSingleProperty(std::ostream& os)
       ++sectionIt)
     {
     for(const cmDocumentationEntry* 
-        entry = sectionIt->second->GetEntries(); entry->brief.size(); 
-        ++entry)
+        entry = sectionIt->second->GetEntries(); entry->brief; ++entry)
       {
-      if(entry->name.size() && this->CurrentArgument == entry->name)
+      if(entry->name && this->CurrentArgument == entry->name)
         {
         this->PrintDocumentationCommand(os, entry);
         return true;
@@ -1087,9 +1086,9 @@ bool cmDocumentation::PrintDocumentationList(std::ostream& os)
     return false;
     }
   for(const cmDocumentationEntry* entry = this->CommandsSection.GetEntries();
-      entry->brief.size(); ++entry)
+      entry->brief; ++entry)
     {
-    if(entry->name.size())
+    if(entry->name)
       {
       os << entry->name << std::endl;
       }
@@ -1097,10 +1096,10 @@ bool cmDocumentation::PrintDocumentationList(std::ostream& os)
   os << "\nCompatibility commands:" << std::endl;
   for(const cmDocumentationEntry* 
       entry = this->CompatCommandsSection.GetEntries();
-      entry->brief.size(); 
+      entry->brief; 
       ++entry)
     {
-    if(entry->name.size())
+    if(entry->name)
       {
       os << entry->name << std::endl;
       }
@@ -1118,10 +1117,10 @@ bool cmDocumentation::PrintPropertyList(std::ostream& os)
     }
   for(const cmDocumentationEntry* 
       entry = this->GlobalPropertiesSection.GetEntries();
-      entry->brief.size(); 
+      entry->brief; 
       ++entry)
     {
-    if(entry->name.size())
+    if(entry->name)
       {
       os << entry->name << std::endl;
       }
@@ -1133,10 +1132,9 @@ bool cmDocumentation::PrintPropertyList(std::ostream& os)
       ++sectionIt)
     {
     for(const cmDocumentationEntry* 
-        entry = sectionIt->second->GetEntries(); 
-        entry->brief.size(); ++entry)
+        entry = sectionIt->second->GetEntries(); entry->brief; ++entry)
       {
-      if(entry->name.size())
+      if(entry->name)
         {
         os << entry->name << std::endl;
         }
@@ -1157,9 +1155,9 @@ bool cmDocumentation::PrintModuleList(std::ostream& os)
     return false;
     }
   for(const cmDocumentationEntry* entry = this->ModulesSection.GetEntries();
-      entry->brief.size(); ++entry)
+      entry->brief; ++entry)
     {
-    if(entry->name.size())
+    if(entry->name)
       {
       os << entry->name << std::endl;
       }
@@ -1169,10 +1167,9 @@ bool cmDocumentation::PrintModuleList(std::ostream& os)
     {
     os << "\nCUSTOM MODULES\n" << std::endl;
     for(const cmDocumentationEntry* 
-        entry = this->CustomModulesSection.GetEntries(); 
-        entry->brief.size(); ++entry)
+        entry = this->CustomModulesSection.GetEntries(); entry->brief; ++entry)
       {
-      if(entry->name.size())
+      if(entry->name)
         {
         os << entry->name << std::endl;
         }
@@ -1256,7 +1253,7 @@ void cmDocumentation::PrintDocumentationCommand(std::ostream& os,
   cmDocumentationEntry singleCommandSection[3] =
     {
       {entry->name, entry->brief, entry->full},
-      {"","",""}
+      {0,0,0}
     };
   this->ClearSections();
   this->AddSection(0, &singleCommandSection[0]);
@@ -1410,26 +1407,26 @@ void cmDocumentation::cmSection::Set(const cmDocumentationEntry* header,
   this->Entries.erase(this->Entries.begin(), this->Entries.end());
   if(header)
     {
-    for(const cmDocumentationEntry* op = header; op->brief.size(); ++op)
+    for(const cmDocumentationEntry* op = header; op->brief; ++op)
       {
       this->Entries.push_back(*op);
       }
     }
   if(section)
     {
-    for(const cmDocumentationEntry* op = section; op->brief.size(); ++op)
+    for(const cmDocumentationEntry* op = section; op->brief; ++op)
       {
       this->Entries.push_back(*op);
       }
     }
   if(footer)
     {
-    for(const cmDocumentationEntry* op = footer; op->brief.size(); ++op)
+    for(const cmDocumentationEntry* op = footer; op->brief; ++op)
       {
       this->Entries.push_back(*op);
       }
     }
-  cmDocumentationEntry empty = {"","",""};
+  cmDocumentationEntry empty = {0,0,0};
   this->Entries.push_back(empty);
 }
 

Source/cmDocumentationFormatterHTML.cxx

@@ -33,13 +33,13 @@ static void cmDocumentationPrintHTMLChar(std::ostream& os, char c)
   // Use an escape sequence if necessary.
   static cmDocumentationEntry escapes[] =
   {
-    {"<", "&lt;", ""},
-    {">", "&gt;", ""},
-    {"&", "&amp;", ""},
-    {"\n", "<br>", ""},
-    {"","",""}
+    {"<", "&lt;", 0},
+    {">", "&gt;", 0},
+    {"&", "&amp;", 0},
+    {"\n", "<br>", 0},
+    {0,0,0}
   };
-  for(const cmDocumentationEntry* op = escapes; op->name.size(); ++op)
+  for(const cmDocumentationEntry* op = escapes; op->name; ++op)
     {
     if(op->name[0] == c)
       {
@@ -97,25 +97,25 @@ void cmDocumentationFormatterHTML::PrintSection(std::ostream& os,
     os << "<h2>" << name << "</h2>\n";
     }
   if(!section) { return; }
-  for(const cmDocumentationEntry* op = section; op->brief.size();)
+  for(const cmDocumentationEntry* op = section; op->brief;)
     {
-    if(op->name.size())
+    if(op->name)
       {
       os << "<ul>\n";
-      for(;op->name.size();++op)
+      for(;op->name;++op)
         {
         os << "  <li>\n";
         if(op->name[0])
           {
           os << "    <b><code>";
-          this->PrintHTMLEscapes(os, op->name.c_str());
+          this->PrintHTMLEscapes(os, op->name);
           os << "</code></b>: ";
           }
-        this->PrintHTMLEscapes(os, op->brief.c_str());
-        if(op->full.size())
+        this->PrintHTMLEscapes(os, op->brief);
+        if(op->full)
           {
           os << "<br>\n    ";
-          this->PrintFormatted(os, op->full.c_str());
+          this->PrintFormatted(os, op->full);
           }
         os << "\n";
         os << "  </li>\n";
@@ -124,7 +124,7 @@ void cmDocumentationFormatterHTML::PrintSection(std::ostream& os,
       }
     else
       {
-      this->PrintFormatted(os, op->brief.c_str());
+      this->PrintFormatted(os, op->brief);
       os << "\n";
       ++op;
       }

Source/cmDocumentationFormatterMan.cxx

@@ -35,19 +35,19 @@ void cmDocumentationFormatterMan::PrintSection(std::ostream& os,
     os << ".SH " << name << "\n";
     }
   if(!section) { return; }
-  for(const cmDocumentationEntry* op = section; op->brief.size(); ++op)
+  for(const cmDocumentationEntry* op = section; op->brief; ++op)
     {
-    if(op->name.size())
+    if(op->name)
       {
       os << ".TP\n"
          << ".B " << (op->name[0]?op->name:"*") << "\n";
-      this->PrintFormatted(os, op->brief.c_str());
-      this->PrintFormatted(os, op->full.c_str());
+      this->PrintFormatted(os, op->brief);
+      this->PrintFormatted(os, op->full);
       }
     else
       {
       os << ".PP\n";
-      this->PrintFormatted(os, op->brief.c_str());
+      this->PrintFormatted(os, op->brief);
       }
     }
 }

Source/cmDocumentationFormatterText.cxx

@@ -36,26 +36,26 @@ void cmDocumentationFormatterText::PrintSection(std::ostream& os,
     os << name << "\n\n";
     }
   if(!section) { return; }
-  for(const cmDocumentationEntry* op = section; op->brief.size(); ++op)
+  for(const cmDocumentationEntry* op = section; op->brief; ++op)
     {
-    if(op->name.size())
+    if(op->name)
       {
       if(op->name[0])
         {
         os << "  " << op->name << "\n";
         }
       this->TextIndent = "       ";
-      this->PrintFormatted(os, op->brief.c_str());
-      if(op->full.size())
+      this->PrintFormatted(os, op->brief);
+      if(op->full)
         {
         os << "\n";
-        this->PrintFormatted(os, op->full.c_str());
+        this->PrintFormatted(os, op->full);
         }
       }
     else
       {
       this->TextIndent = "";
-      this->PrintFormatted(os, op->brief.c_str());
+      this->PrintFormatted(os, op->brief);
       }
     os << "\n";
     }

Source/cmDocumentationFormatterUsage.cxx

@@ -31,31 +31,31 @@ void cmDocumentationFormatterUsage::PrintSection(std::ostream& os,
     os << name << "\n";
     }
   if(!section) { return; }
-  for(const cmDocumentationEntry* op = section; op->brief.size(); ++op)
+  for(const cmDocumentationEntry* op = section; op->brief; ++op)
     {
-    if(op->name.size())
+    if(op->name)
       {
       os << "  " << op->name;
       this->TextIndent = "                                ";
       int align = static_cast<int>(strlen(this->TextIndent))-4;
-      for(int i = static_cast<int>(op->name.size()); i < align; ++i)
+      for(int i = static_cast<int>(strlen(op->name)); i < align; ++i)
         {
         os << " ";
         }
-      if ( op->name.size() > strlen(this->TextIndent)-4 )
+      if ( strlen(op->name) > strlen(this->TextIndent)-4 )
         {
         os << "\n";
         os.write(this->TextIndent, strlen(this->TextIndent)-2);
         }
       os << "= ";
-      this->PrintColumn(os, op->brief.c_str());
+      this->PrintColumn(os, op->brief);
       os << "\n";
       }
     else
       {
       os << "\n";
       this->TextIndent = "";
-      this->PrintFormatted(os, op->brief.c_str());
+      this->PrintFormatted(os, op->brief);
       }
     }
   os << "\n";

Source/cmDumpDocumentation.cxx

@@ -25,35 +25,35 @@
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationName[] =
 {
-  {"",
-   "  DumpDocumentation - Dump documentation for CMake.", ""},
-  {"","",""}
+  {0,
+   "  DumpDocumentation - Dump documentation for CMake.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationUsage[] =
 {
-  {"",
-   "  DumpDocumentation [filename]", ""},
-  {"","",""}
+  {0,
+   "  DumpDocumentation [filename]", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationDescription[] =
 {
-  {"",
+  {0,
    "The \"DumpDocumentation\" executable is only available in the build "
-   "tree.  It is used for testing, coverage, and documentation.", ""},
+   "tree.  It is used for testing, coverage, and documentation.", 0},
   CMAKE_STANDARD_INTRODUCTION,
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationOptions[] =
 {
   {"--all-for-coverage", 
-   "Dump all documentation to stdout.  For testing.", ""},
-  {"","",""}
+   "Dump all documentation to stdout.  For testing.", 0},
+  {0,0,0}
 };
 
 

Source/cmPropertyDefinition.cxx

@@ -22,8 +22,8 @@ cmDocumentationEntry cmPropertyDefinition::GetDocumentation() const
   cmDocumentationEntry e;
   e.name = this->Name.c_str();
   e.brief = 
-    this->ShortDescription.size() ? this->ShortDescription.c_str() : "";
-  e.full = this->FullDescription.size() ? this->FullDescription.c_str() : "";
+    this->ShortDescription.size() ? this->ShortDescription.c_str() : 0;
+  e.full = this->FullDescription.size() ? this->FullDescription.c_str() : 0;
   return e;
 }
 

Source/cmPropertyDefinitionMap.cxx

@@ -45,7 +45,7 @@ void cmPropertyDefinitionMap
       j != this->end(); ++j)
     {
     cmDocumentationEntry e = j->second.GetDocumentation();
-    if (e.brief.size())
+    if (e.brief)
       {
       v.push_back(e);
       }

Source/cmStandardIncludes.h

@@ -316,9 +316,9 @@ extern void operator << (std::ostream&, const cmOStringStream&);
 /** Standard documentation entry for cmDocumentation's formatting.  */
 struct cmDocumentationEntry
 {
-  std::string name;
-  std::string brief;
-  std::string full;
+  const char* name;
+  const char* brief;
+  const char* full;
 };
 
 /** Data structure to represent a single command line.  */

Source/cmake.cxx

@@ -2262,7 +2262,7 @@ void cmake::GetCommandDocumentation(std::vector<cmDocumentationEntry>& v,
       };
     v.push_back(e);
     }
-  cmDocumentationEntry empty = {"","",""};
+  cmDocumentationEntry empty = {0,0,0};
   v.push_back(empty);
 }
 
@@ -2271,7 +2271,7 @@ void cmake::GetPropertiesDocumentation(std::vector<cmDocumentationEntry>& v,
 {
   // get the properties for cmake
   this->PropertyDefinitions[type].GetPropertiesDocumentation(v);
-  cmDocumentationEntry empty = {"","",""};
+  cmDocumentationEntry empty = {0,0,0};
   v.push_back(empty);
 }
 
@@ -2296,7 +2296,7 @@ void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
     delete generator;
     v.push_back(e);
     }
-  cmDocumentationEntry empty = {"","",""};
+  cmDocumentationEntry empty = {0,0,0};
   v.push_back(empty);
 }
 

Source/cmake.h

@@ -428,11 +428,11 @@ private:
    "section."}
 
 #define CMAKE_STANDARD_INTRODUCTION \
-  {"", \
+  {0, \
    "CMake is a cross-platform build system generator.  Projects " \
    "specify their build process with platform-independent CMake listfiles " \
    "included in each directory of a source tree with the name " \
    "CMakeLists.txt. " \
    "Users build a project by using CMake to generate a build system " \
-   "for a native tool on their platform.", ""}
+   "for a native tool on their platform.", 0}
 #endif

Source/cmakemain.cxx

@@ -34,31 +34,31 @@
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationName[] =
 {
-  {"",
-   "  cmake - Cross-Platform Makefile Generator.", ""},
-  {"","",""}
+  {0,
+   "  cmake - Cross-Platform Makefile Generator.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationUsage[] =
 {
-  {"",
+  {0,
    "  cmake [options] <path-to-source>\n"
-   "  cmake [options] <path-to-existing-build>", ""},
-  {"","",""}
+   "  cmake [options] <path-to-existing-build>", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationDescription[] =
 {
-  {"",
+  {0,
    "The \"cmake\" executable is the CMake command-line interface.  It may "
    "be used to configure projects in scripts.  Project configuration "
    "settings "
    "may be specified on the command line with the -D option.  The -i option "
-   "will cause cmake to interactively prompt for such settings.", ""},
+   "will cause cmake to interactively prompt for such settings.", 0},
   CMAKE_STANDARD_INTRODUCTION,
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
@@ -162,25 +162,25 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
    "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 and plain text."},
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationSeeAlso[] =
 {
-  {"", "ccmake", ""},
-  {"", "ctest", ""},
-  {"", "", ""}
+  {0, "ccmake", 0},
+  {0, "ctest", 0},
+  {0, 0, 0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationNOTE[] =
 {
-  {"",
+  {0,
    "CMake no longer configures a project when run with no arguments.  "
    "In order to configure the project in the current directory, run\n"
-   "  cmake .", ""},
-  {"","",""}
+   "  cmake .", 0},
+  {0,0,0}
 };
 #endif
 

Source/ctest.cxx

@@ -25,28 +25,28 @@
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationName[] =
 {
-  {"",
-   "  ctest - Testing driver provided by CMake.", ""},
-  {"","",""}
+  {0,
+   "  ctest - Testing driver provided by CMake.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationUsage[] =
 {
-  {"",
-   "  ctest [options]", ""},
-  {"","",""}
+  {0,
+   "  ctest [options]", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationDescription[] =
 {
-  {"",
+  {0,
    "The \"ctest\" executable is the CMake test driver program.  "
    "CMake-generated build trees created for projects that use "
    "the ENABLE_TESTING and ADD_TEST commands have testing support.  "
-   "This program will run the tests and report results.", ""},
-  {"","",""}
+   "This program will run the tests and report results.", 0},
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
@@ -194,15 +194,15 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
    "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." },
-  {"","",""}
+  {0,0,0}
 };
 
 //----------------------------------------------------------------------------
 static const cmDocumentationEntry cmDocumentationSeeAlso[] =
 {
-  {"", "cmake", ""},
-  {"", "ccmake", ""},
-  {"", "", ""}
+  {0, "cmake", 0},
+  {0, "ccmake", 0},
+  {0, 0, 0}
 };
 
 // this is a test driver program for cmCTest.