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

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.
This commit is contained in:
Brad King 2013-09-16 14:04:39 -04:00
parent e33d8d2d77
commit 0c39a757da
33 changed files with 186 additions and 662 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
Source/CPack/cpack.cxx
View File

@ -27,92 +27,42 @@
#include <cmsys/SystemTools.hxx> #include <cmsys/SystemTools.hxx>
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationName[][3] = static const char * cmDocumentationName[][2] =
{ {
{0, {0,
" cpack - Packaging driver provided by CMake.", 0}, " cpack - Packaging driver provided by CMake."},
{0,0,0} {0,0}
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationUsage[][3] = static const char * cmDocumentationUsage[][2] =
{ {
{0, {0,
" cpack -G <generator> [options]", " cpack -G <generator> [options]"},
0}, {0,0}
{0,0,0}
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationOptions[][3] = static const char * cmDocumentationOptions[][2] =
{ {
{"-G <generator>", "Use the specified generator to generate package.", {"-G <generator>", "Use the specified generator to generate package."},
"CPack may support multiple native packaging systems on certain " {"-C <Configuration>", "Specify the project configuration"},
"platforms. A generator is responsible for generating input files for " {"-D <var>=<value>", "Set a CPack variable."},
"particular system and invoking that systems. Possible generator names " {"--config <config file>", "Specify the config file."},
"are specified in the Generators section." }, {"--verbose,-V","enable verbose output"},
{"-C <Configuration>", "Specify the project configuration", {"--debug","enable debug output (for CPack developers)"},
"This option specifies the configuration that the project was build " {"-P <package name>","override/define CPACK_PACKAGE_NAME"},
"with, for example 'Debug', 'Release'." }, {"-R <package version>","override/define CPACK_PACKAGE_VERSION"},
{"-D <var>=<value>", "Set a CPack variable.", \ {"-B <package directory>","override/define CPACK_PACKAGE_DIRECTORY"},
"Set a variable that can be used by the generator."}, \ {"--vendor <vendor name>","override/define CPACK_PACKAGE_VENDOR"},
{"--config <config file>", "Specify the config file.", {"--help-command cmd [file]", "Print help for a single command and exit."},
"Specify the config file to use to create the package. By default " {"--help-command-list [file]", "List available commands and exit."},
"CPackConfig.cmake in the current directory will be used." }, {"--help-commands [file]", "Print help for all commands and exit."},
{"--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."},
{"--help-variable var [file]", {"--help-variable var [file]",
"Print help for a single variable and exit.", "Print help for a single variable and exit."},
"Full documentation specific to the given variable is displayed." {"--help-variable-list [file]", "List documented variables and exit."},
"If a file is specified, the documentation is written into and the output " {"--help-variables [file]", "Print help for all variables and exit."},
"format is determined depending on the filename suffix. Supported are man " {0,0}
"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}
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -522,7 +472,6 @@ int main (int argc, char *argv[])
cmDocumentationEntry e; cmDocumentationEntry e;
e.Name = generatorIt->first.c_str(); e.Name = generatorIt->first.c_str();
e.Brief = generatorIt->second.c_str(); e.Brief = generatorIt->second.c_str();
e.Full = "";
v.push_back(e); v.push_back(e);
} }
doc.SetSection("Generators",v); doc.SetSection("Generators",v);

16
Source/CursesDialog/ccmake.cxx
View File

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

16
Source/QtDialog/CMakeSetup.cxx
View File

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

40
Source/cmDocumentation.cxx
View File

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

6
Source/cmDocumentation.h
View File

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

48
Source/cmDocumentationSection.cxx
View File

@ -13,69 +13,33 @@
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmDocumentationSection::Append(const char *data[][3]) void cmDocumentationSection::Append(const char *data[][2])
{ {
int i = 0; int i = 0;
while(data[i][1]) while(data[i][1])
{ {
this->Entries.push_back(cmDocumentationEntry(data[i][0], this->Entries.push_back(cmDocumentationEntry(data[i][0],
data[i][1], data[i][1]));
data[i][2]));
data += 1; data += 1;
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmDocumentationSection::Prepend(const char *data[][3]) void cmDocumentationSection::Prepend(const char *data[][2])
{ {
std::vector<cmDocumentationEntry> tmp; std::vector<cmDocumentationEntry> tmp;
int i = 0; int i = 0;
while(data[i][1]) while(data[i][1])
{ {
tmp.push_back(cmDocumentationEntry(data[i][0], tmp.push_back(cmDocumentationEntry(data[i][0],
data[i][1], data[i][1]));
data[i][2]));
data += 1; data += 1;
} }
this->Entries.insert(this->Entries.begin(),tmp.begin(),tmp.end()); this->Entries.insert(this->Entries.begin(),tmp.begin(),tmp.end());
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmDocumentationSection::Append(const char *n, const char *b, void cmDocumentationSection::Append(const char *n, const char *b)
const char *f)
{ {
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

6
Source/cmDocumentationSection.h
View File

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

7
Source/cmExtraCodeBlocksGenerator.cxx
View File

@ -42,13 +42,6 @@ void cmExtraCodeBlocksGenerator
{ {
entry.Name = this->GetName(); entry.Name = this->GetName();
entry.Brief = "Generates CodeBlocks project files."; 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() cmExtraCodeBlocksGenerator::cmExtraCodeBlocksGenerator()

7
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -48,13 +48,6 @@ void cmExtraEclipseCDT4Generator
{ {
entry.Name = this->GetName(); entry.Name = this->GetName();
entry.Brief = "Generates Eclipse CDT 4.0 project files."; 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.";
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------

7
Source/cmExtraSublimeTextGenerator.cxx
View File

@ -45,13 +45,6 @@ void cmExtraSublimeTextGenerator
{ {
entry.Name = this->GetName(); entry.Name = this->GetName();
entry.Brief = "Generates Sublime Text 2 project files."; 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() cmExtraSublimeTextGenerator::cmExtraSublimeTextGenerator()

1
Source/cmGlobalBorlandMakefileGenerator.cxx
View File

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

1
Source/cmGlobalJOMMakefileGenerator.cxx
View File

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

10
Source/cmGlobalKdevelopGenerator.cxx
View File

@ -28,16 +28,6 @@ void cmGlobalKdevelopGenerator
{ {
entry.Name = this->GetName(); entry.Name = this->GetName();
entry.Brief = "Generates KDevelop 3 project files."; 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() cmGlobalKdevelopGenerator::cmGlobalKdevelopGenerator()

2
Source/cmGlobalMSYSMakefileGenerator.cxx
View File

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

2
Source/cmGlobalMinGWMakefileGenerator.cxx
View File

@ -49,6 +49,4 @@ void cmGlobalMinGWMakefileGenerator
{ {
entry.Name = cmGlobalMinGWMakefileGenerator::GetActualName(); entry.Name = cmGlobalMinGWMakefileGenerator::GetActualName();
entry.Brief = "Generates a make file for use with mingw32-make."; 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.";
} }

1
Source/cmGlobalNMakeMakefileGenerator.cxx
View File

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

4
Source/cmGlobalNinjaGenerator.cxx
View File

@ -470,10 +470,6 @@ void cmGlobalNinjaGenerator
{ {
entry.Name = cmGlobalNinjaGenerator::GetActualName(); entry.Name = cmGlobalNinjaGenerator::GetActualName();
entry.Brief = "Generates build.ninja files (experimental)."; 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. // Implemented in all cmGlobaleGenerator sub-classes.

4
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -65,10 +65,6 @@ void cmGlobalUnixMakefileGenerator3
{ {
entry.Name = cmGlobalUnixMakefileGenerator3::GetActualName(); entry.Name = cmGlobalUnixMakefileGenerator3::GetActualName();
entry.Brief = "Generates standard UNIX makefiles."; 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.";
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------

5
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -48,11 +48,6 @@ public:
virtual void GetDocumentation(cmDocumentationEntry& entry) const { virtual void GetDocumentation(cmDocumentationEntry& entry) const {
entry.Name = "Visual Studio 10"; entry.Name = "Visual Studio 10";
entry.Brief = "Generates Visual Studio 10 (2010) project files."; 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 { virtual void GetGenerators(std::vector<std::string>& names) const {

5
Source/cmGlobalVisualStudio11Generator.cxx
View File

@ -68,11 +68,6 @@ public:
virtual void GetDocumentation(cmDocumentationEntry& entry) const { virtual void GetDocumentation(cmDocumentationEntry& entry) const {
entry.Name = "Visual Studio 11"; entry.Name = "Visual Studio 11";
entry.Brief = "Generates Visual Studio 11 (2012) project files."; 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 { virtual void GetGenerators(std::vector<std::string>& names) const {

5
Source/cmGlobalVisualStudio12Generator.cxx
View File

@ -43,11 +43,6 @@ public:
virtual void GetDocumentation(cmDocumentationEntry& entry) const { virtual void GetDocumentation(cmDocumentationEntry& entry) const {
entry.Name = "Visual Studio 12"; entry.Name = "Visual Studio 12";
entry.Brief = "Generates Visual Studio 12 (2013) project files."; 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 { virtual void GetGenerators(std::vector<std::string>& names) const {

1
Source/cmGlobalVisualStudio6Generator.cxx
View File

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

1
Source/cmGlobalVisualStudio71Generator.cxx
View File

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

1
Source/cmGlobalVisualStudio7Generator.cxx
View File

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

6
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -65,11 +65,6 @@ public:
virtual void GetDocumentation(cmDocumentationEntry& entry) const { virtual void GetDocumentation(cmDocumentationEntry& entry) const {
entry.Name = vs8generatorName; entry.Name = vs8generatorName;
entry.Brief = "Generates Visual Studio 8 2005 project files."; 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 { virtual void GetGenerators(std::vector<std::string>& names) const {
@ -147,7 +142,6 @@ void cmGlobalVisualStudio8Generator
{ {
entry.Name = cmGlobalVisualStudio8Generator::GetActualName(); entry.Name = cmGlobalVisualStudio8Generator::GetActualName();
entry.Brief = "Generates Visual Studio 8 2005 project files."; entry.Brief = "Generates Visual Studio 8 2005 project files.";
entry.Full = "";
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------

5
Source/cmGlobalVisualStudio9Generator.cxx
View File

@ -70,11 +70,6 @@ public:
virtual void GetDocumentation(cmDocumentationEntry& entry) const { virtual void GetDocumentation(cmDocumentationEntry& entry) const {
entry.Name = vs9generatorName; entry.Name = vs9generatorName;
entry.Brief = "Generates Visual Studio 9 2008 project files."; 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 { virtual void GetGenerators(std::vector<std::string>& names) const {

1
Source/cmGlobalWatcomWMakeGenerator.cxx
View File

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

1
Source/cmGlobalXCodeGenerator.cxx
View File

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

1
Source/cmPropertyDefinition.cxx
View File

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

10
Source/cmStandardIncludes.h
View File

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

45
Source/cmake.h
View File

@ -464,43 +464,12 @@ private:
}; };
#define CMAKE_STANDARD_OPTIONS_TABLE \ #define CMAKE_STANDARD_OPTIONS_TABLE \
{"-C <initial-cache>", "Pre-load a script to populate the cache.", \ {"-C <initial-cache>", "Pre-load a script to populate the cache."}, \
"When cmake is first run in an empty build tree, it creates a " \ {"-D <var>:<type>=<value>", "Create a cmake cache entry."}, \
"CMakeCache.txt file and populates it with customizable settings " \ {"-U <globbing_expr>", "Remove matching entries from CMake cache."}, \
"for the project. This option may be used to specify a file from " \ {"-G <generator-name>", "Specify a build system generator."},\
"which to load cache entries before the first pass through " \ {"-T <toolset-name>", "Specify toolset name if supported by generator."}, \
"the project's cmake listfiles. The loaded entries take priority " \ {"-Wno-dev", "Suppress developer warnings."},\
"over the project's default values. The given file should be a CMake " \ {"-Wdev", "Enable developer warnings."}
"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."}
#endif #endif

211
Source/cmakemain.cxx
View File

@ -28,20 +28,20 @@
#ifdef CMAKE_BUILD_WITH_CMAKE #ifdef CMAKE_BUILD_WITH_CMAKE
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationName[][3] = static const char * cmDocumentationName[][2] =
{ {
{0, {0,
" cmake - Cross-Platform Makefile Generator.", 0}, " cmake - Cross-Platform Makefile Generator."},
{0,0,0} {0,0}
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationUsage[][3] = static const char * cmDocumentationUsage[][2] =
{ {
{0, {0,
" cmake [options] <path-to-source>\n" " cmake [options] <path-to-source>\n"
" cmake [options] <path-to-existing-build>", 0}, " cmake [options] <path-to-existing-build>"},
{0,0,0} {0,0}
}; };
#define CMAKE_BUILD_OPTIONS \ #define CMAKE_BUILD_OPTIONS \
@ -57,179 +57,50 @@ static const char * cmDocumentationUsage[][3] =
" -- = Pass remaining options to the native tool.\n" " -- = Pass remaining options to the native tool.\n"
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationOptions[][3] = static const char * cmDocumentationOptions[][2] =
{ {
CMAKE_STANDARD_OPTIONS_TABLE, CMAKE_STANDARD_OPTIONS_TABLE,
{"-E", "CMake command mode.", {"-E", "CMake command mode."},
"For true platform independence, CMake provides a list of commands " {"-i", "Run in wizard mode."},
"that can be used on all systems. Run with -E help for the usage " {"-L[A][H]", "List non-advanced cached variables."},
"information. Commands available are: chdir, compare_files, copy, " {"--build <dir>", "Build a CMake-generated project binary tree."},
"copy_directory, copy_if_different, echo, echo_append, environment, " {"-N", "View mode only."},
"make_directory, md5sum, remove, remove_directory, rename, tar, time, " {"-P <file>", "Process script mode."},
"touch, touch_nocreate. In addition, some platform specific commands " {"--find-package", "Run in pkg-config like mode."},
"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)."},
{"--graphviz=[file]", "Generate graphviz of dependencies, see " {"--graphviz=[file]", "Generate graphviz of dependencies, see "
"CMakeGraphVizOptions.cmake for more.", "CMakeGraphVizOptions.cmake for more."},
"Generate a graphviz input file that will contain all the library and " {"--system-information [file]", "Dump information about this system."},
"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."},
{"--debug-trycompile", "Do not delete the try_compile build tree. Only " {"--debug-trycompile", "Do not delete the try_compile build tree. Only "
"useful on one try_compile at a time.", "useful on one try_compile at a time."},
"Do not delete the files and directories created for try_compile calls. " {"--debug-output", "Put cmake in a debug mode."},
"This is useful in debugging failed try_compiles. It may however " {"--trace", "Put cmake in trace mode."},
"change the results of the try-compiles as old junk from a previous " {"--warn-uninitialized", "Warn about uninitialized values."},
"try-compile may cause a different test to either pass or fail " {"--warn-unused-vars", "Warn about unused variables."},
"incorrectly. This option is best used for one try-compile at a time, " {"--no-warn-unused-cli", "Don't warn about command line options."},
"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."},
{"--check-system-vars", "Find problems with variable usage in system " {"--check-system-vars", "Find problems with variable usage in system "
"files.", "Normally, unused and uninitialized variables are searched for " "files."},
"only in CMAKE_SOURCE_DIR and CMAKE_BINARY_DIR. This flag tells CMake to " {"--help-command cmd [file]", "Print help for a single command and exit."},
"warn about other files as well."}, {"--help-command-list [file]", "List available listfile commands and exit."},
{"--help-command cmd [file]", "Print help for a single command and exit.", {"--help-commands [file]", "Print help for all commands and exit."},
"Full documentation specific to the given command is displayed. " {"--help-compatcommands [file]", "Print help for compatibility commands. "},
"If a file is specified, the documentation is written into and the output " {"--help-module module [file]", "Print help for a single module and exit."},
"format is determined depending on the filename suffix. Supported are man " {"--help-module-list [file]", "List available modules and exit."},
"page, HTML, DocBook and plain text."}, {"--help-modules [file]", "Print help for all modules and exit."},
{"--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."},
{"--help-custom-modules [file]" , "Print help for all custom modules and " {"--help-custom-modules [file]" , "Print help for all custom modules and "
"exit.", "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."},
{"--help-policy cmp [file]", {"--help-policy cmp [file]",
"Print help for a single policy and exit.", "Print help for a single policy and exit."},
"Full documentation specific to the given policy is displayed." {"--help-policy-list [file]", "List available policies and exit."},
"If a file is specified, the documentation is written into and the output " {"--help-policies [file]", "Print help for all policies and exit."},
"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."},
{"--help-property prop [file]", {"--help-property prop [file]",
"Print help for a single property and exit.", "Print help for a single property and exit."},
"Full documentation specific to the given property is displayed." {"--help-property-list [file]", "List available properties and exit."},
"If a file is specified, the documentation is written into and the output " {"--help-properties [file]", "Print help for all properties and exit."},
"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."},
{"--help-variable var [file]", {"--help-variable var [file]",
"Print help for a single variable and exit.", "Print help for a single variable and exit."},
"Full documentation specific to the given variable is displayed." {"--help-variable-list [file]", "List documented variables and exit."},
"If a file is specified, the documentation is written into and the output " {"--help-variables [file]", "Print help for all variables and exit."},
"format is determined depending on the filename suffix. Supported are man " {0,0}
"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}
}; };
#endif #endif

273
Source/ctest.cxx
View File

@ -20,235 +20,98 @@
#include "CTest/cmCTestLaunch.h" #include "CTest/cmCTestLaunch.h"
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationName[][3] = static const char * cmDocumentationName[][2] =
{ {
{0, {0,
" ctest - Testing driver provided by CMake.", 0}, " ctest - Testing driver provided by CMake."},
{0,0,0} {0,0}
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationUsage[][3] = static const char * cmDocumentationUsage[][2] =
{ {
{0, {0,
" ctest [options]", 0}, " ctest [options]"},
{0,0,0} {0,0}
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const char * cmDocumentationOptions[][3] = static const char * cmDocumentationOptions[][2] =
{ {
{"-C <cfg>, --build-config <cfg>", "Choose configuration to test.", {"-C <cfg>, --build-config <cfg>", "Choose configuration to test."},
"Some CMake-generated build trees can have multiple build configurations " {"-V,--verbose", "Enable verbose output from tests."},
"in the same tree. This option can be used to specify which one should " {"-VV,--extra-verbose", "Enable more verbose output from tests."},
"be tested. Example configurations are \"Debug\" and \"Release\"."}, {"--debug", "Displaying more verbose internals of CTest."},
{"-V,--verbose", "Enable verbose output from tests.", {"--output-on-failure"},
"Test output is normally suppressed and only summary information is " {"-F", "Enable failover."},
"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."},
{"-j <jobs>, --parallel <jobs>", "Run the tests in parallel using the" {"-j <jobs>, --parallel <jobs>", "Run the tests in parallel using the"
"given number of jobs.", "given number of jobs."},
"This option tells ctest to run the tests in parallel using given " {"-Q,--quiet", "Make ctest quiet."},
"number of jobs. This option can also be set by setting " {"-O <file>, --output-log <file>", "Output to log file"},
"the environment variable CTEST_PARALLEL_LEVEL."}, {"-N,--show-only", "Disable actual execution of tests."},
{"-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."},
{"-L <regex>, --label-regex <regex>", "Run tests with labels matching " {"-L <regex>, --label-regex <regex>", "Run tests with labels matching "
"regular expression.", "regular expression."},
"This option tells ctest to run only the tests whose labels match the "
"given regular expression."},
{"-R <regex>, --tests-regex <regex>", "Run tests matching regular " {"-R <regex>, --tests-regex <regex>", "Run tests matching regular "
"expression.", "expression."},
"This option tells ctest to run only the tests whose names match the "
"given regular expression."},
{"-E <regex>, --exclude-regex <regex>", "Exclude tests matching regular " {"-E <regex>, --exclude-regex <regex>", "Exclude tests matching regular "
"expression.", "expression."},
"This option tells ctest to NOT run the tests whose names match the "
"given regular expression."},
{"-LE <regex>, --label-exclude <regex>", "Exclude tests with labels " {"-LE <regex>, --label-exclude <regex>", "Exclude tests with labels "
"matching regular expression.", "matching regular expression."},
"This option tells ctest to NOT run the tests whose labels match the " {"-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test"},
"given regular expression."}, {"-D <var>:<type>=<value>", "Define a variable for script mode"},
{"-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test", {"-M <model>, --test-model <model>", "Sets the model for a dashboard"},
"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"},
{"-T <action>, --test-action <action>", "Sets the dashboard action to " {"-T <action>, --test-action <action>", "Sets the dashboard action to "
"perform", "perform"},
"This option tells ctest to act as a Dart client " {"--track <track>", "Specify the track to submit dashboard to"},
"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."},
{"-S <script>, --script <script>", "Execute a dashboard for a " {"-S <script>, --script <script>", "Execute a dashboard for a "
"configuration", "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."},
{"-SP <script>, --script-new-process <script>", "Execute a dashboard for a " {"-SP <script>, --script-new-process <script>", "Execute a dashboard for a "
"configuration", "configuration"},
"This option does the same operations as -S but it will do them in a " {"-A <file>, --add-notes <file>", "Add a notes file with submission"},
"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. "},
{"-I [Start,End,Stride,test#,test#|Test file], --tests-information", {"-I [Start,End,Stride,test#,test#|Test file], --tests-information",
"Run a specific number of tests by number.", "Run a specific number of tests by number."},
"This option causes ctest to run tests starting at number Start, ending " {"-U, --union", "Take the Union of -I and -R"},
"at number End, and incrementing by Stride. Any additional numbers after " {"--rerun-failed", "Run only the tests that failed previously"},
"Stride are considered individual test numbers. Start, End,or stride " {"--max-width <width>", "Set the max width for a test name to output"},
"can be empty. Optionally a file can be given that contains the same " {"--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1."},
"syntax as the command line."}, {"--no-label-summary", "Disable timing summary information for labels."},
{"-U, --union", "Take the Union of -I and -R", {"--build-and-test", "Configure, build and run a test."},
"When both -R and -I are specified by default the intersection of " {"--build-target", "Specify a specific target to build."},
"tests are run. By specifying -U the union of tests is run instead."}, {"--build-nocmake", "Run the build without running cmake first."},
{"--rerun-failed", "Run only the tests that failed previously", {"--build-run-dir", "Specify directory to run programs from."},
"This option tells ctest to perform only the tests that failed during its " {"--build-two-config", "Run CMake twice"},
"previous run. When this option is specified, ctest ignores all other " {"--build-exe-dir", "Specify the directory for the executable."},
"options intended to modify the list of tests to run " {"--build-generator", "Specify the generator to use."},
"(-L, -R, -E, -LE, -I, etc). In the event that CTest runs and no tests " {"--build-generator-toolset", "Specify the generator-specific toolset."},
"fail, subsequent calls to ctest with the --rerun-failed option will " {"--build-project", "Specify the name of the project to build."},
"run the set of tests that most recently failed (if any)."}, {"--build-makeprogram", "Specify the make program to use."},
{"--max-width <width>", "Set the max width for a test name to output", {"--build-noclean", "Skip the make clean step."},
"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.", "" },
{"--build-config-sample", {"--build-config-sample",
"A sample executable to use to determine the configuration", "A sample executable to use to determine the configuration"},
"A sample executable to use to determine the configuration that " {"--build-options", "Add extra options to the build step."},
"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"
},
{"--test-command", "The test to run with the --build-and-test option.", "" {"--test-command", "The test to run with the --build-and-test option."},
}, {"--test-timeout", "The time limit in seconds, internal use only."},
{"--test-timeout", "The time limit in seconds, internal use only.", "" {"--tomorrow-tag", "Nightly or experimental starts with next day tag."},
},
{"--tomorrow-tag", "Nightly or experimental starts with next day tag.",
"This is useful if the build will not finish in one day." },
{"--ctest-config", "The configuration file used to initialize CTest state " {"--ctest-config", "The configuration file used to initialize CTest state "
"when submitting dashboards.", "when submitting dashboards."},
"This option tells CTest to use different initialization file instead of " {"--overwrite", "Overwrite CTest configuration option."},
"CTestConfiguration.tcl. This way multiple initialization files can be " {"--extra-submit <file>[;<file>]", "Submit extra files to the dashboard."},
"used for example to submit to multiple dashboards." }, {"--force-new-ctest-process", "Run child CTest instances as new processes"},
{"--overwrite", "Overwrite CTest configuration option.", {"--schedule-random", "Use a random order for scheduling tests"},
"By default ctest uses configuration options from configuration file. " {"--submit-index", "Submit individual dashboard tests with specific index"},
"This option will overwrite the configuration option." }, {"--timeout <seconds>", "Set a global timeout on all tests."},
{"--extra-submit <file>[;<file>]", "Submit extra files to the dashboard.", {"--stop-time <time>",
"This option will submit extra files to the dashboard." }, "Set a time at which all tests should stop running."},
{"--force-new-ctest-process", "Run child CTest instances as new processes", {"--http1.0", "Submit using HTTP 1.0."},
"By default CTest will run child CTest instances within the same process. " {"--no-compress-output", "Do not compress test output when submitting."},
"If this behavior is not desired, this argument will enforce new " {"--print-labels", "Print all available test labels."},
"processes for child CTest processes." }, {"--help-command <cmd> [<file>]",
{"--schedule-random", "Use a random order for scheduling tests", "Show help for a single command and exit."},
"This option will run the tests in a random order. It is commonly used to " {"--help-command-list [<file>]", "List available commands and exit."},
"detect implicit dependencies in a test suite." }, {"--help-commands [<file>]", "Print help for all commands and exit."},
{"--submit-index", "Submit individual dashboard tests with specific index", {0,0}
"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}
}; };
// this is a test driver program for cmCTest. // this is a test driver program for cmCTest.