kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: make documentation entries actually store their data

This commit is contained in:
Ken Martin 2007-10-09 09:55:42 -04:00
parent b02cbf5fad
commit 18ce24c748
15 changed files with 215 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
Source/CPack/cpack.cxx
View File

@ -33,30 +33,30 @@
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
{
{0,
" cpack - Packaging driver provided by CMake.", 0},
{0,0,0}
{"",
" cpack - Packaging driver provided by CMake.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
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.", 0},
"This program will generate the package.", ""},
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[] =
{
{0, "cmake", 0},
{0, "ccmake", 0},
{0, 0, 0}
{"", "cmake", ""},
{"", "ccmake", ""},
{"", "", ""}
};
//----------------------------------------------------------------------------
@ -464,7 +464,7 @@ int main (int argc, char *argv[])
e.full = "";
v.push_back(e);
}
cmDocumentationEntry empty = {0,0,0};
cmDocumentationEntry empty = {"","",""};
v.push_back(empty);
doc.SetGeneratorsSection(&v[0]);

20
Source/MFCDialog/CMakeSetup.cpp
View File

@ -12,31 +12,31 @@
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
{
{0,
" CMakeSetup - CMake Windows GUI.", 0},
{0,0,0}
{"",
" CMakeSetup - CMake Windows GUI.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
{
{0,
{"",
" CMakeSetup [options]\n"
" CMakeSetup [options] <path-to-source>\n"
" CMakeSetup [options] <path-to-existing-build>", 0},
{0,0,0}
" CMakeSetup [options] <path-to-existing-build>", ""},
{"","",""}
};
//----------------------------------------------------------------------------
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.", 0},
"window when the program is running.", ""},
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

215
Source/cmDocumentation.cxx
View File

@ -21,7 +21,7 @@
#include <cmsys/Directory.hxx>
const cmDocumentationEntry cmDocumentation::cmSection::EmptySection ={0,0,0};
const cmDocumentationEntry cmDocumentation::cmSection::EmptySection ={"","",""};
//----------------------------------------------------------------------------
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.", 0},
"Generator.", ""},
// 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.", 0},
{0,0,0}
"existance of headers to name just a few.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmCustomModulesDocumentationDescription[] =
{
{0,
" Custom CMake Modules - Additional Modules for CMake.", 0},
{"",
" Custom CMake Modules - Additional Modules for CMake.", ""},
// 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.", 0},
{0,0,0}
"existance of headers to name just a few.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmPropertiesDocumentationDescription[] =
{
{0,
{"",
" CMake Properties - Properties supported by CMake, "
"the Cross-Platform Makefile Generator.", 0},
"the Cross-Platform Makefile Generator.", ""},
// 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.", 0},
"Obsolete commands supported by CMake for compatibility.", ""},
// 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. ;-)", 0},
{0,0,0}
"should instead use the newer, faster and shinier new commands. ;-)", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationCommandsHeader[] =
{
{0,
"The following commands are available in CMakeLists.txt code:", 0},
{0,0,0}
{"",
"The following commands are available in CMakeLists.txt code:", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationGlobalPropertiesHeader[] =
{
{0,
"The following global properties are available in CMakeLists.txt code:", 0},
{0,0,0}
{"",
"The following global properties are available in CMakeLists.txt code:", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDirectoryPropertiesHeader[] =
{
{0
{""
,"The following directory properties are available in CMakeLists.txt code:"
,0},
{0,0,0}
,""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationTargetPropertiesHeader[] =
{
{0,
"The following target properties are available in CMakeLists.txt code:", 0},
{0,0,0}
{"",
"The following target properties are available in CMakeLists.txt code:", ""},
{"","",""}
};
//----------------------------------------------------------------------------
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[] =
{
{0, "The following variables are available in CMakeLists.txt code:", 0},
{0,0,0}
{"", "The following variables are available in CMakeLists.txt code:", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry
cmDocumentationCachedVariablePropertiesHeader[] =
{
{0,"The following cache variables are available in CMakeLists.txt code:", 0},
{0,0,0}
{"","The following cache variables are available in CMakeLists.txt code:", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationModulesHeader[] =
{
{0,
{"",
"The following modules are provided with CMake. "
"They can be used with INCLUDE(ModuleName).", 0},
{0,0,0}
"They can be used with INCLUDE(ModuleName).", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationCustomModulesHeader[] =
{
{0,
{"",
"The following modules are also available for CMake. "
"They can be used with INCLUDE(ModuleName).", 0},
{0,0,0}
"They can be used with INCLUDE(ModuleName).", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationGeneratorsHeader[] =
{
{0,
"The following generators are available on this platform:", 0},
{0,0,0}
{"",
"The following generators are available on this platform:", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationStandardSeeAlso[] =
{
{0,
"The following resources are available to get help using CMake:", 0},
{"",
"The following resources are available to get help using CMake:", ""},
{"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[] =
{
{0,
"This manual page was generated by the \"--help-man\" option.", 0},
{0,0,0}
{"",
"This manual page was generated by the \"--help-man\" option.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
const cmDocumentationEntry cmDocumentationCopyright[] =
{
{0,
{"",
"Copyright (c) 2002 Kitware, Inc., Insight Consortium. "
"All rights reserved.", 0},
{0,
"All rights reserved.", ""},
{"",
"Redistribution and use in source and binary forms, with or without "
"modification, are permitted provided that the following conditions are "
"met:", 0},
"met:", ""},
{"",
"Redistributions of source code must retain the above copyright notice, "
"this list of conditions and the following disclaimer.", 0},
"this list of conditions and the following disclaimer.", ""},
{"",
"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.", 0},
"specific prior written permission.", ""},
{"",
"Modified source versions must be plainly marked as such, and must "
"not be misrepresented as being the original software.", 0},
{0,
"not be misrepresented as being the original software.", ""},
{"",
"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.", 0},
{0, 0, 0}
"SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.", ""},
{"", "", ""}
};
//----------------------------------------------------------------------------
@ -332,18 +332,18 @@ cmDocumentation::~cmDocumentation()
bool cmDocumentation::PrintCopyright(std::ostream& os)
{
for(const cmDocumentationEntry* op = cmDocumentationCopyright;
op->brief; ++op)
op->brief.size(); ++op)
{
if(op->name)
if(op->name.size())
{
os << " * ";
this->TextFormatter.SetIndent(" ");
this->TextFormatter.PrintColumn(os, op->brief);
this->TextFormatter.PrintColumn(os, op->brief.c_str());
}
else
{
this->TextFormatter.SetIndent("");
this->TextFormatter.PrintColumn(os, op->brief);
this->TextFormatter.PrintColumn(os, op->brief.c_str());
}
os << "\n";
}
@ -441,7 +441,7 @@ bool cmDocumentation::CreateModulesSection()
{
this->ModulesSection.Append(cmDocumentationModulesHeader[0]);
this->CreateModuleDocsForDir(dir, this->ModulesSection);
cmDocumentationEntry e = { 0, 0, 0 };
cmDocumentationEntry e = { "", "", "" };
this->ModulesSection.Append(e);
}
return true;
@ -475,7 +475,7 @@ bool cmDocumentation::CreateCustomModulesSection()
if(sectionHasHeader)
{
cmDocumentationEntry e = { 0, 0, 0 };
cmDocumentationEntry e = { "", "", "" };
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; ++i)
for(const cmDocumentationEntry* i = also; i->brief.size(); ++i)
{
this->SeeAlsoString += i->brief;
this->SeeAlsoString += (i+1)->brief? "(1), ":"(1)";
this->SeeAlsoString += (i+1)->brief.size() ? "(1), ":"(1)";
}
cmDocumentationEntry e = {0, 0, 0};
cmDocumentationEntry e = {"", "", ""};
e.brief = this->SeeAlsoString.c_str();
this->SeeAlsoSection.Append(e);
for(const cmDocumentationEntry* i = cmDocumentationStandardSeeAlso;
i->brief; ++i)
i->brief.size(); ++i)
{
this->SeeAlsoSection.Append(*i);
}
e.brief = 0;
e.brief = "";
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; ++entry)
entry->brief.size(); ++entry)
{
if(entry->name && this->CurrentArgument == entry->name)
if(entry->name.size() && 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;
entry->brief.size();
++entry)
{
if(entry->name && this->CurrentArgument == entry->name)
if(entry->name.size() && this->CurrentArgument == entry->name)
{
this->PrintDocumentationCommand(os, entry);
return true;
@ -1061,9 +1061,10 @@ bool cmDocumentation::PrintDocumentationSingleProperty(std::ostream& os)
++sectionIt)
{
for(const cmDocumentationEntry*
entry = sectionIt->second->GetEntries(); entry->brief; ++entry)
entry = sectionIt->second->GetEntries(); entry->brief.size();
++entry)
{
if(entry->name && this->CurrentArgument == entry->name)
if(entry->name.size() && this->CurrentArgument == entry->name)
{
this->PrintDocumentationCommand(os, entry);
return true;
@ -1086,9 +1087,9 @@ bool cmDocumentation::PrintDocumentationList(std::ostream& os)
return false;
}
for(const cmDocumentationEntry* entry = this->CommandsSection.GetEntries();
entry->brief; ++entry)
entry->brief.size(); ++entry)
{
if(entry->name)
if(entry->name.size())
{
os << entry->name << std::endl;
}
@ -1096,10 +1097,10 @@ bool cmDocumentation::PrintDocumentationList(std::ostream& os)
os << "\nCompatibility commands:" << std::endl;
for(const cmDocumentationEntry*
entry = this->CompatCommandsSection.GetEntries();
entry->brief;
entry->brief.size();
++entry)
{
if(entry->name)
if(entry->name.size())
{
os << entry->name << std::endl;
}
@ -1117,10 +1118,10 @@ bool cmDocumentation::PrintPropertyList(std::ostream& os)
}
for(const cmDocumentationEntry*
entry = this->GlobalPropertiesSection.GetEntries();
entry->brief;
entry->brief.size();
++entry)
{
if(entry->name)
if(entry->name.size())
{
os << entry->name << std::endl;
}
@ -1132,9 +1133,10 @@ bool cmDocumentation::PrintPropertyList(std::ostream& os)
++sectionIt)
{
for(const cmDocumentationEntry*
entry = sectionIt->second->GetEntries(); entry->brief; ++entry)
entry = sectionIt->second->GetEntries();
entry->brief.size(); ++entry)
{
if(entry->name)
if(entry->name.size())
{
os << entry->name << std::endl;
}
@ -1155,9 +1157,9 @@ bool cmDocumentation::PrintModuleList(std::ostream& os)
return false;
}
for(const cmDocumentationEntry* entry = this->ModulesSection.GetEntries();
entry->brief; ++entry)
entry->brief.size(); ++entry)
{
if(entry->name)
if(entry->name.size())
{
os << entry->name << std::endl;
}
@ -1167,9 +1169,10 @@ bool cmDocumentation::PrintModuleList(std::ostream& os)
{
os << "\nCUSTOM MODULES\n" << std::endl;
for(const cmDocumentationEntry*
entry = this->CustomModulesSection.GetEntries(); entry->brief; ++entry)
entry = this->CustomModulesSection.GetEntries();
entry->brief.size(); ++entry)
{
if(entry->name)
if(entry->name.size())
{
os << entry->name << std::endl;
}
@ -1253,7 +1256,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]);
@ -1407,26 +1410,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; ++op)
for(const cmDocumentationEntry* op = header; op->brief.size(); ++op)
{
this->Entries.push_back(*op);
}
}
if(section)
{
for(const cmDocumentationEntry* op = section; op->brief; ++op)
for(const cmDocumentationEntry* op = section; op->brief.size(); ++op)
{
this->Entries.push_back(*op);
}
}
if(footer)
{
for(const cmDocumentationEntry* op = footer; op->brief; ++op)
for(const cmDocumentationEntry* op = footer; op->brief.size(); ++op)
{
this->Entries.push_back(*op);
}
}
cmDocumentationEntry empty = {0,0,0};
cmDocumentationEntry empty = {"","",""};
this->Entries.push_back(empty);
}

28
Source/cmDocumentationFormatterHTML.cxx
View File

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

10
Source/cmDocumentationFormatterMan.cxx
View File

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

12
Source/cmDocumentationFormatterText.cxx
View File

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

12
Source/cmDocumentationFormatterUsage.cxx
View File

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

22
Source/cmDumpDocumentation.cxx
View File

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

4
Source/cmPropertyDefinition.cxx
View File

@ -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() : 0;
e.full = this->FullDescription.size() ? this->FullDescription.c_str() : 0;
this->ShortDescription.size() ? this->ShortDescription.c_str() : "";
e.full = this->FullDescription.size() ? this->FullDescription.c_str() : "";
return e;
}

2
Source/cmPropertyDefinitionMap.cxx
View File

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

6
Source/cmStandardIncludes.h
View File

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

6
Source/cmake.cxx
View File

@ -2262,7 +2262,7 @@ void cmake::GetCommandDocumentation(std::vector<cmDocumentationEntry>& v,
};
v.push_back(e);
}
cmDocumentationEntry empty = {0,0,0};
cmDocumentationEntry empty = {"","",""};
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 = {0,0,0};
cmDocumentationEntry empty = {"","",""};
v.push_back(empty);
}
@ -2296,7 +2296,7 @@ void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
delete generator;
v.push_back(e);
}
cmDocumentationEntry empty = {0,0,0};
cmDocumentationEntry empty = {"","",""};
v.push_back(empty);
}

4
Source/cmake.h
View File

@ -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.", 0}
"for a native tool on their platform.", ""}
#endif

32
Source/cmakemain.cxx
View File

@ -34,31 +34,31 @@
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
{
{0,
" cmake - Cross-Platform Makefile Generator.", 0},
{0,0,0}
{"",
" cmake - Cross-Platform Makefile Generator.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
{
{0,
{"",
" cmake [options] <path-to-source>\n"
" cmake [options] <path-to-existing-build>", 0},
{0,0,0}
" cmake [options] <path-to-existing-build>", ""},
{"","",""}
};
//----------------------------------------------------------------------------
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.", 0},
"will cause cmake to interactively prompt for such settings.", ""},
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[] =
{
{0, "ccmake", 0},
{0, "ctest", 0},
{0, 0, 0}
{"", "ccmake", ""},
{"", "ctest", ""},
{"", "", ""}
};
//----------------------------------------------------------------------------
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 .", 0},
{0,0,0}
" cmake .", ""},
{"","",""}
};
#endif

26
Source/ctest.cxx
View File

@ -25,28 +25,28 @@
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
{
{0,
" ctest - Testing driver provided by CMake.", 0},
{0,0,0}
{"",
" ctest - Testing driver provided by CMake.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
{
{0,
" ctest [options]", 0},
{0,0,0}
{"",
" ctest [options]", ""},
{"","",""}
};
//----------------------------------------------------------------------------
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.", 0},
{0,0,0}
"This program will run the tests and report results.", ""},
{"","",""}
};
//----------------------------------------------------------------------------
@ -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[] =
{
{0, "cmake", 0},
{0, "ccmake", 0},
{0, 0, 0}
{"", "cmake", ""},
{"", "ccmake", ""},
{"", "", ""}
};
// this is a test driver program for cmCTest.