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

ENH: change to make the documentation class more generic, about halfway there, also provides secitons for Variables now

This commit is contained in:
Ken Martin 2007-10-22 12:49:09 -04:00
parent cfb84d8562
commit 6cdf032505
44 changed files with 924 additions and 929 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Source/CMakeLists.txt
View File

@ -113,6 +113,7 @@ SET(SRCS
cmDocumentationFormatterMan.cxx
cmDocumentationFormatterText.cxx
cmDocumentationFormatterUsage.cxx
cmDocumentationSection.cxx
cmDocumentVariables.cxx
cmDynamicLoader.cxx
cmDynamicLoader.h

28
Source/CPack/cpack.cxx
View File

@ -31,7 +31,7 @@
#include <cmsys/CommandLineArguments.hxx>
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
static const char * cmDocumentationName[][3] =
{
{0,
" cpack - Packaging driver provided by CMake.", 0},
@ -39,7 +39,7 @@ static const cmDocumentationEntry cmDocumentationName[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
static const char * cmDocumentationUsage[][3] =
{
{0,
" cpack -G <generator> [options]",
@ -48,7 +48,7 @@ static const cmDocumentationEntry cmDocumentationUsage[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDescription[] =
static const char * cmDocumentationDescription[][3] =
{
{0,
"The \"cpack\" executable is the CMake packaging program. "
@ -60,7 +60,7 @@ static const cmDocumentationEntry cmDocumentationDescription[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationOptions[] =
static const char * cmDocumentationOptions[][3] =
{
{"-G <generator>", "Use the specified generator to generate package.",
"CPack may support multiple native packaging systems on certain "
@ -79,7 +79,7 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationSeeAlso[] =
static const char * cmDocumentationSeeAlso[][3] =
{
{0, "cmake", 0},
{0, "ccmake", 0},
@ -447,10 +447,10 @@ int main (int argc, char *argv[])
doc.CheckOptions(argc, argv);
// Construct and print requested documentation.
doc.SetName("cpack");
doc.SetNameSection(cmDocumentationName);
doc.SetUsageSection(cmDocumentationUsage);
doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetOptionsSection(cmDocumentationOptions);
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.SetSection("Description",cmDocumentationDescription);
doc.SetSection("Options",cmDocumentationOptions);
std::vector<cmDocumentationEntry> v;
cmCPackGenerators::DescriptionsMap::const_iterator generatorIt;
@ -459,14 +459,12 @@ int main (int argc, char *argv[])
++ generatorIt )
{
cmDocumentationEntry e;
e.name = generatorIt->first.c_str();
e.brief = generatorIt->second.c_str();
e.full = "";
e.Name = generatorIt->first.c_str();
e.Brief = generatorIt->second.c_str();
e.Full = "";
v.push_back(e);
}
cmDocumentationEntry empty = {0,0,0};
v.push_back(empty);
doc.SetGeneratorsSection(&v[0]);
doc.SetSection("Generators",v);
doc.SetSeeAlsoList(cmDocumentationSeeAlso);
#undef cout

24
Source/CursesDialog/ccmake.cxx
View File

@ -28,7 +28,7 @@
#include <form.h>
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
static const char * cmDocumentationName[][3] =
{
{0,
" ccmake - Curses Interface for CMake.", 0},
@ -36,7 +36,7 @@ static const cmDocumentationEntry cmDocumentationName[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
static const char * cmDocumentationUsage[][3] =
{
{0,
" ccmake <path-to-source>\n"
@ -45,7 +45,7 @@ static const cmDocumentationEntry cmDocumentationUsage[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDescription[] =
static const char * cmDocumentationDescription[][3] =
{
{0,
"The \"ccmake\" executable is the CMake curses interface. Project "
@ -57,14 +57,14 @@ static const cmDocumentationEntry cmDocumentationDescription[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationOptions[] =
static const char * cmDocumentationOptions[][3] =
{
CMAKE_STANDARD_OPTIONS_TABLE,
{0,0,0}
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationSeeAlso[] =
static const char * cmDocumentationSeeAlso[][3] =
{
{0, "cmake", 0},
{0, "ctest", 0},
@ -116,13 +116,13 @@ int main(int argc, char** argv)
hcm.GetCommandDocumentation(compatCommands, false, true);
hcm.GetGeneratorDocumentation(generators);
doc.SetName("ccmake");
doc.SetNameSection(cmDocumentationName);
doc.SetUsageSection(cmDocumentationUsage);
doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetGeneratorsSection(&generators[0]);
doc.SetOptionsSection(cmDocumentationOptions);
doc.SetCommandsSection(&commands[0]);
doc.SetCompatCommandsSection(&compatCommands[0]);
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.SetSection("Description",cmDocumentationDescription);
doc.SetSection("Generators",generators);
doc.SetSection("Options",cmDocumentationOptions);
doc.SetSection("Command",commands);
doc.SetSection("Compatibility Commands",compatCommands);
doc.SetSeeAlsoList(cmDocumentationSeeAlso);
return doc.PrintRequestedDocumentation(std::cout)? 0:1;
}

22
Source/MFCDialog/CMakeSetup.cpp
View File

@ -10,7 +10,7 @@
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
static const char * cmDocumentationName[][3] =
{
{0,
" CMakeSetup - CMake Windows GUI.", 0},
@ -18,7 +18,7 @@ static const cmDocumentationEntry cmDocumentationName[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
static const char * cmDocumentationUsage[][3] =
{
{0,
" CMakeSetup [options]\n"
@ -28,7 +28,7 @@ static const cmDocumentationEntry cmDocumentationUsage[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDescription[] =
static const char * cmDocumentationDescription[][3] =
{
{0,
"The \"CMakeSetup\" executable is the CMake Windows GUI. Project "
@ -40,7 +40,7 @@ static const cmDocumentationEntry cmDocumentationDescription[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationOptions[] =
static const char * cmDocumentationOptions[][3] =
{
{"-A[on|off]", "Enable/disable display of advanced cache values.",
"There are two categories of CMake cache values: non-advanced and "
@ -121,13 +121,13 @@ BOOL CMakeSetup::InitInstance()
hcm.GetCommandDocumentation(compatCommands, false, true);
hcm.GetGeneratorDocumentation(generators);
doc.SetName("cmake");
doc.SetNameSection(cmDocumentationName);
doc.SetUsageSection(cmDocumentationUsage);
doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetGeneratorsSection(&generators[0]);
doc.SetOptionsSection(cmDocumentationOptions);
doc.SetCommandsSection(&commands[0]);
doc.SetCompatCommandsSection(&compatCommands[0]);
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.SetSection("Description",cmDocumentationDescription);
doc.SetSection("Generators",generators);
doc.SetSection("Options",cmDocumentationOptions);
doc.SetSection("Commands",commands);
doc.SetSection("Compatilbility Commands", compatCommands);
return (doc.PrintRequestedDocumentation(std::cout)? 0:1);
}

218
Source/cmDocumentVariables.cxx
View File

@ -11,19 +11,22 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"This is the full path to the CMake executable cmake which is "
"useful from custom commands that want to use the cmake -E "
"option for portable system commands. "
"(e.g. /usr/local/bin/cmake");
"(e.g. /usr/local/bin/cmake", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_BINARY_DIR", cmProperty::VARIABLE,
"The path to the top level of the build tree.",
"This is the full path to the top level of the current CMake "
"build tree. For an in-source build, this would be the same "
"as CMAKE_SOURCE_DIR. ");
"as CMAKE_SOURCE_DIR. ", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_SOURCE_DIR", cmProperty::VARIABLE,
"The path to the top level of the source tree.",
"This is the full path to the top level of the current CMake "
"source tree. For an in-source build, this would be the same "
"as CMAKE_BINARY_DIR. ");
"as CMAKE_BINARY_DIR. ", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CURRENT_BINARY_DIR", cmProperty::VARIABLE,
"The path to the binary directory currently being processed.",
@ -32,22 +35,26 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"add_subdirectory will create a binary directory in the build "
"tree, and as it is being processed this variable will be set. "
"For in-source builds this is the current source directory "
"being processed.");
"being processed.", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CURRENT_SOURCE_DIR", cmProperty::VARIABLE,
"The path to the source directory currently being processed.",
"This the full path to the source directory that is currently "
"being processed by cmake. ");
"being processed by cmake. ", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CURRENT_LIST_FILE", cmProperty::VARIABLE,
"The path to the file currently being processed.",
"This the full path to the file that is currently "
"being processed by cmake. ");
"being processed by cmake. ", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CURRENT_LIST_LINE", cmProperty::VARIABLE,
"The line number of the current file being processed.",
"This is the line number of the file currently being"
" processed by cmake.");
" processed by cmake.", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_BUILD_TOOL", cmProperty::VARIABLE,
"Tool used for the acutal build process.",
@ -59,27 +66,31 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"and for Visual Studio 7 it set to devenv. For "
"Nmake Makefiles the value is nmake. This can be "
"useful for adding special flags and commands based"
" on the final build environment. ");
" on the final build environment. ", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CACHEFILE_DIR", cmProperty::VARIABLE,
"The directory with the CMakeCache.txt file.",
"This is the full path to the directory that has the "
"CMakeCache.txt file in it. This is the same as "
"CMAKE_BINARY_DIR.");
"CMAKE_BINARY_DIR.", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CACHE_MAJOR_VERSION", cmProperty::VARIABLE,
"Major version of CMake used to create the CMakeCache.txt file",
"This is stores the major version of CMake used to "
"write a CMake cache file. It is only different when "
"a different version of CMake is run on a previously "
"created cache file.");
"created cache file.", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CACHE_MINOR_VERSION", cmProperty::VARIABLE,
"Minor version of CMake used to create the CMakeCache.txt file",
"This is stores the minor version of CMake used to "
"write a CMake cache file. It is only different when "
"a different version of CMake is run on a previously "
"created cache file.");
"created cache file.", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CACHE_RELEASE_VERSION", cmProperty::VARIABLE,
@ -87,7 +98,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"This is stores the release version of CMake used to "
"write a CMake cache file. It is only different when "
"a different version of CMake is run on a previously "
"created cache file.");
"created cache file.", false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CFG_INTDIR", cmProperty::VARIABLE,
@ -111,7 +123,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"compiler. If it has a value, it will be the "
"intermediate directory used to build the file. "
"This way an executable or a library can find files "
"that are located in the build directory.");
"that are located in the build directory.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_CTEST_COMMAND", cmProperty::VARIABLE,
@ -119,128 +132,150 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"This is the full path to the CTest executable ctest "
"which is useful from custom commands that want "
" to use the cmake -E option for portable system "
"commands.");
"commands.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_DL_LIBS", cmProperty::VARIABLE,
"Name of library containing dlopen and dlcose.",
"The name of the library that has dlopen and "
"dlclose in it, usually -ldl on most UNIX machines.");
"dlclose in it, usually -ldl on most UNIX machines.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_EDIT_COMMAND", cmProperty::VARIABLE,
"Full path to CMakeSetup or ccmake.",
"This is the full path to the CMake executable "
"that can graphically edit the cache. For example,"
" CMakeSetup, ccmake, or cmake -i.");
" CMakeSetup, ccmake, or cmake -i.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_GENERATOR", cmProperty::VARIABLE,
"The generator used to build the project.",
"The name of the generator that is being used to generate the "
"build files. (e.g. \"Unix Makefiles\", "
"\"Visual Studio 6\", etc.)");
"\"Visual Studio 6\", etc.)",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_HOME_DIRECTORY", cmProperty::VARIABLE,
"Path to top of source tree.",
"This is the path to the top level of the source tree.");
"This is the path to the top level of the source tree.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_LINK_LIBRARY_SUFFIX", cmProperty::VARIABLE,
"The suffix for libraries that you link to.",
"The suffix to use for the end of a library, .lib on Windows.");
"The suffix to use for the end of a library, .lib on Windows.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_MAJOR_VERSION", cmProperty::VARIABLE,
"The Major version of cmake (i.e. the 2 in 2.X.X)",
"This specifies the major version of the CMake executable"
" being run.");
" being run.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_MAKE_PROGRAM", cmProperty::VARIABLE,
"See CMAKE_BUILD_TOOL.",
"This variable is around for backwards compatibility, "
"see CMAKE_BUILD_TOOL.");
"see CMAKE_BUILD_TOOL.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_MINOR_VERSION", cmProperty::VARIABLE,
"The Minor version of cmake (i.e. the 4 in X.4.X).",
"This specifies the minor version of the CMake"
" executable being run.");
" executable being run.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_PROJECT_NAME", cmProperty::VARIABLE,
"The name of the current project.",
"This specifies name of the current project from"
" the closest inherited PROJECT command.");
" the closest inherited PROJECT command.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_RANLIB", cmProperty::VARIABLE,
"Name of randomizing tool for static libraries.",
"This specifies name of the program that randomizes "
"libraries on UNIX, not used on Windows, but may be present.");
"libraries on UNIX, not used on Windows, but may be present.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_ROOT", cmProperty::VARIABLE,
"Install directory for running cmake.",
"This is the install root for the running CMake and"
" the Modules directory can be found here. This is"
" commonly used in this format: ${CMAKE_ROOT}/Modules");
" commonly used in this format: ${CMAKE_ROOT}/Modules",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_SIZEOF_VOID_P", cmProperty::VARIABLE,
"Size of a void pointer.",
"This is set to the size of a pointer on the machine, "
"and is determined by a try compile. If a 64 bit size "
"is found, then the library search path is modified to "
"look for 64 bit libraries first.");
"look for 64 bit libraries first.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_SKIP_RPATH", cmProperty::VARIABLE,
"If true, do not add run time path information.",
"If this is set to TRUE, then the rpath information "
"is not added to compiled executables. The default"
"is to add rpath information if the platform supports it."
"This allows for easy running from the build tree.");
"This allows for easy running from the build tree.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_SOURCE_DIR", cmProperty::VARIABLE,
"Source directory for project.",
"This is the top level source directory for the project. "
"It corresponds to the source directory given to "
"CMakeSetup or ccmake.");
"CMakeSetup or ccmake.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_STANDARD_LIBRARIES", cmProperty::VARIABLE,
"Libraries linked into every executable and shared library.",
"This is the list of libraries that are linked "
"into all executables and libraries.");
"into all executables and libraries.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_USING_VC_FREE_TOOLS", cmProperty::VARIABLE,
"True if free visual studio tools being used.",
"This is set to true if the compiler is Visual "
"Studio free tools.");
"Studio free tools.",false,
"Variables that Provide Information");
cm->DefineProperty
("CMAKE_VERBOSE_MAKEFILE", cmProperty::VARIABLE,
"Create verbose makefiles if on.",
"This variable defaults to false. You can set "
"this variable to true to make CMake produce verbose "
"makefiles that show each command line as it is used.");
"makefiles that show each command line as it is used.",false,
"Variables that Provide Information");
cm->DefineProperty
("PROJECT_BINARY_DIR", cmProperty::VARIABLE,
"Full path to build directory for project.",
"This is the binary directory of the most recent "
"PROJECT command.");
"PROJECT command.",false,"Variables that Provide Information");
cm->DefineProperty
("PROJECT_NAME", cmProperty::VARIABLE,
"Name of the project given to the project command.",
"This is the name given to the most "
"recent PROJECT command. ");
"recent PROJECT command. ",false,
"Variables that Provide Information");
cm->DefineProperty
("PROJECT_SOURCE_DIR", cmProperty::VARIABLE,
"Top level source directory for the current project.",
"This is the source directory of the most recent "
"PROJECT command.");
"PROJECT command.",false,
"Variables that Provide Information");
cm->DefineProperty
("[Project name]_BINARY_DIR", cmProperty::VARIABLE,
"Top level binary directory for the named project.",
"A variable is created with the name used in the PROJECT "
"command, and is the binary directory for the project. "
" This can be useful when SUBDIR is used to connect "
"several projects.");
"several projects.",false,
"Variables that Provide Information");
cm->DefineProperty
("[Project name]_SOURCE_DIR", cmProperty::VARIABLE,
"Top level source directory for the named project.",
"A variable is created with the name used in the PROJECT "
"command, and is the source directory for the project."
" This can be useful when add_subdirectory "
"is used to connect several projects.");
"is used to connect several projects.",false,
"Variables that Provide Information");
// Variables defined by cmake, that change the behavior
// of cmake
@ -255,7 +290,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"variables with the name "
" CMAKE_C_FLAGS_[Debug|Release|RelWithDebInfo|MinSizeRel]."
" For example, if CMAKE_BUILD_TYPE is Debug, then "
"CMAKE_C_FLAGS_DEBUG will be added to the CMAKE_C_FLAGS.");
"CMAKE_C_FLAGS_DEBUG will be added to the CMAKE_C_FLAGS.",false,
"Variables That Change Behavior");
cm->DefineProperty
("CMAKE_BACKWARDS_COMPATIBILITY", cmProperty::VARIABLE,
@ -267,7 +303,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
" CMake to support deprecated commands of CMake in projects"
" that were written to use older versions of CMake. This "
"can be set by the user or set at the beginning of a "
"CMakeLists file.");
"CMakeLists file.",false,
"Variables That Change Behavior");
cm->DefineProperty
("CMAKE_INSTALL_PREFIX", cmProperty::VARIABLE,
@ -275,7 +312,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"If \"make install\" is invoked or INSTALL is built"
", this directory is pre-pended onto all install "
"directories. This variable defaults to /usr/local"
" on UNIX and c:/Program Files on Windows.");
" on UNIX and c:/Program Files on Windows.",false,
"Variables That Change Behavior");
cm->DefineProperty
("CMAKE_USER_MAKE_RULES_OVERRIDE", cmProperty::VARIABLE,
"Specify a file that can change the build rule variables.",
@ -284,7 +322,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"after all the system settings have been set, but "
"before they have been used. This would allow you "
"to override any variables that need to be changed "
"for some special project. ");
"for some special project. ",false,
"Variables That Change Behavior");
cm->DefineProperty
("BUILD_SHARED_LIBS", cmProperty::VARIABLE,
@ -294,13 +333,15 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"static library. This variable is often added to projects "
"as an OPTION so that each user of a project can decide if "
"they want to build the project using shared or static "
"libraries.");
"libraries.",false,
"Variables That Change Behavior");
cm->DefineProperty
("CMAKE_NOT_USING_CONFIG_FLAGS", cmProperty::VARIABLE,
"Skip _BUILD_TYPE flags if true.",
"This is an internal flag used by the generators in "
"CMake to tell CMake to skip the _BUILD_TYPE flags.");
"CMake to tell CMake to skip the _BUILD_TYPE flags.",false,
"Variables That Change Behavior");
cm->DefineProperty
("CMAKE_MFC_FLAG", cmProperty::VARIABLE,
@ -313,7 +354,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"dialog uses MFC and the CMakeLists.txt looks like this:\n"
"ADD_DEFINITIONS(-D_AFXDLL)\n"
"set(CMAKE_MFC_FLAG 2)\n"
"add_executable(CMakeSetup WIN32 ${SRCS})\n");
"add_executable(CMakeSetup WIN32 ${SRCS})\n",false,
"Variables That Change Behavior");
// Variables defined by CMake that describe the system
@ -325,7 +367,8 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"and CMAKE_SYSTEM_VERSION, like this "
"${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_VERSION}. "
"If CMAKE_SYSTEM_VERSION is not set, then "
"CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.");
"CMAKE_SYSTEM is the same as CMAKE_SYSTEM_NAME.",false,
"Variables That Describe the System");
cm->DefineProperty
("CMAKE_SYSTEM_NAME", cmProperty::VARIABLE,
"Name of the OS CMake is running on.",
@ -334,47 +377,55 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"have the uname command, this variable is set "
"to the output of uname -s. Linux, Windows, "
" and Darwin for Mac OSX are the values found "
" on the big three operating systems." );
" on the big three operating systems." ,false,
"Variables That Describe the System");
cm->DefineProperty
("CMAKE_SYSTEM_PROCESSOR", cmProperty::VARIABLE,
"The name of the CPU CMake is running on.",
"On systems that support uname, this variable is "
"set to the output of uname -p, on windows it is "
"set to the value of the environment variable "
"PROCESSOR_ARCHITECTURE");
"PROCESSOR_ARCHITECTURE",false,
"Variables That Describe the System");
cm->DefineProperty
("CMAKE_SYSTEM_VERSION", cmProperty::VARIABLE,
"OS version.",
"A numeric version string for the system, on "
"systems that support uname, this variable is "
"set to the output of uname -r. On other "
"systems this is set to major-minor version numbers.");
"systems this is set to major-minor version numbers.",false,
"Variables That Describe the System");
cm->DefineProperty
("APPLE", cmProperty::VARIABLE,
"True if running on Mac OSX.",
"Set to true on Mac OSX.");
"Set to true on Mac OSX.",false,
"Variables That Describe the System");
cm->DefineProperty
("BORLAND", cmProperty::VARIABLE,
"True of the borland compiler is being used.",
"This is set to true if the Borland compiler is being used.");
"This is set to true if the Borland compiler is being used.",false,
"Variables That Describe the System");
cm->DefineProperty
("CYGWIN", cmProperty::VARIABLE,
"True for cygwin.",
"Set to true when using CYGWIN.");
"Set to true when using CYGWIN.",false,
"Variables That Describe the System");
cm->DefineProperty
("UNIX", cmProperty::VARIABLE,
"True for UNIX and UNIX like operating systems.",
"Set to true when the system is UNIX or UNIX like "
"(i.e. APPLE and CYGWIN).");
"(i.e. APPLE and CYGWIN).",false,
"Variables That Describe the System");
cm->DefineProperty
("WIN32", cmProperty::VARIABLE,
"Tru on windows systems, including win64.",
"Set to true when the system is Windows and on cygwin.");
"Set to true when the system is Windows and on cygwin.",false,
"Variables That Describe the System");
// Variables that affect the building of object files and
// targets.
@ -382,28 +433,33 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
cm->DefineProperty
("CMAKE_EXE_LINKER_FLAGS", cmProperty::VARIABLE,
"Linker flags used to create executables.",
"Flags used by the linker when creating an executable.");
"Flags used by the linker when creating an executable.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_EXE_LINKER_FLAGS_[CMAKE_BUILD_TYPE]", cmProperty::VARIABLE,
"Flag used when linking an executable.",
"Same as CMAKE_C_FLAGS_* but used by the linker "
"when creating executables.");
"when creating executables.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_LIBRARY_PATH_FLAG", cmProperty::VARIABLE,
"The flag used to add a library search path to a compiler.",
"The flag used to specify a library directory to the compiler. "
"On most compilers this is \"-L\".");
"On most compilers this is \"-L\".",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_LINK_DEF_FILE_FLAG ", cmProperty::VARIABLE,
"Linker flag used to specify a .def file for dll creation.",
"The flag used to add a .def file when creating "
"a dll on Windows, this is only defined on Windows.");
"a dll on Windows, this is only defined on Windows.",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_LINK_LIBRARY_FLAG", cmProperty::VARIABLE,
"Flag used to link a library into an executable.",
"The flag used to specify a library to link to an executable. "
"On most compilers this is \"-l\".");
"On most compilers this is \"-l\".",false,
"Variables that Control the Build");
cm->DefineProperty
("CMAKE_USE_RELATIVE_PATHS", cmProperty::VARIABLE,
"Use relative paths (May not work!).",
@ -413,17 +469,20 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
"projects, and relative paths are used when possible. "
"In general, it is not possible to move CMake generated"
" makefiles to a different location regardless "
"of the value of this variable.");
"of the value of this variable.",false,
"Variables that Control the Build");
cm->DefineProperty
("EXECUTABLE_OUTPUT_PATH", cmProperty::VARIABLE,
"Location for all executables in a project.",
"If set, this is the directory where all executables "
"built during the build process will be placed.");
"built during the build process will be placed.",false,
"Variables that Control the Build");
cm->DefineProperty
("LIBRARY_OUTPUT_PATH", cmProperty::VARIABLE,
"Location for all libraries in a project.",
"If set, this is the directory where all the libraries "
"built during the build process will be placed.");
"built during the build process will be placed.",false,
"Variables that Control the Build");
// Variables defined when the a language is enabled These variables will
// also be defined whenever CMake has loaded its support for compiling (LANG)
@ -434,87 +493,96 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
("CMAKE_<LANG>_COMPILER", cmProperty::VARIABLE,
"The full path to the compiler for LANG.",
"This is the command that will be used as the <LANG> compiler. "
"Once set, you can not change this variable.");
"Once set, you can not change this variable.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_COMPILER_IS_GNU<LANG>", cmProperty::VARIABLE,
"True if the compiler is GNU.",
"If the selected <LANG> compiler is the GNU "
"compiler then this is TRUE, if not it is FALSE. ");
"compiler then this is TRUE, if not it is FALSE.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_FLAGS_DEBUG", cmProperty::VARIABLE,
"Flags for Debug build type or configuration.",
"<LANG> flags used when CMAKE_BUILD_TYPE is Debug.");
"<LANG> flags used when CMAKE_BUILD_TYPE is Debug.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_FLAGS_MINSIZEREL", cmProperty::VARIABLE,
"Flags for MinSizeRel build type or configuration.",
"<LANG> flags used when CMAKE_BUILD_TYPE is MinSizeRel."
"Short for minimum size release.");
"Short for minimum size release.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_FLAGS_RELEASE", cmProperty::VARIABLE,
"Flags for Release build type or configuration.",
"<LANG> flags used when CMAKE_BUILD_TYPE is Release");
"<LANG> flags used when CMAKE_BUILD_TYPE is Release",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_FLAGS_RELWITHDEBINFO", cmProperty::VARIABLE,
"Flags for RelWithDebInfo type or configuration.",
"<LANG> flags used when CMAKE_BUILD_TYPE is RelWithDebInfo. "
"Short for Release With Debug Information.");
"Short for Release With Debug Information.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_COMPILE_OBJECT", cmProperty::VARIABLE,
"Rule variable to compile a single object file.",
"This is a rule variable that tells CMake how to "
"compile a single object file for for the language <LANG>.");
"compile a single object file for for the language <LANG>.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_CREATE_SHARED_LIBRARY", cmProperty::VARIABLE,
"Rule variable to create a shared library.",
"This is a rule variable that tells CMake how to "
"create a shared library for the language <LANG>.");
"create a shared library for the language <LANG>.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_CREATE_SHARED_MODULE", cmProperty::VARIABLE,
"Rule variable to create a shared module.",
"This is a rule variable that tells CMake how to "
"create a shared library for the language <LANG>.");
"create a shared library for the language <LANG>.",false,
"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_CREATE_STATIC_LIBRARY", cmProperty::VARIABLE,
"Rule variable to create a static library.",
"This is a rule variable that tells CMake how "
"to create a static library for the language <LANG>.");
"to create a static library for the language <LANG>.",false,"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_IGNORE_EXTENSIONS", cmProperty::VARIABLE,
"File extensions that should be ignored by the build.",
"This is a list of file extensions that may be "
"part of a project for a given language but are not compiled. ");
"part of a project for a given language but are not compiled. ",false,"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_LINKER_PREFERENCE", cmProperty::VARIABLE,
"Determine if a language should be used for linking.",
"If this is \"Preferred\" then if there is a mixed "
"language shared library or executable, then this "
"languages linker command will be used.");
"languages linker command will be used.",false,"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_LINK_EXECUTABLE ", cmProperty::VARIABLE,
"Rule variable to link and executable.",
"Rule variable to link and executable for the given language.");
"Rule variable to link and executable for the given language.",false,"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_OUTPUT_EXTENSION", cmProperty::VARIABLE,
"Extension for the output of a compile for a single file.",
"This is the extension for an object file for "
"the given <LANG>. For example .obj for C on Windows.");
"the given <LANG>. For example .obj for C on Windows.",false,"Variables for Languages");
cm->DefineProperty
("CMAKE_<LANG>_SOURCE_FILE_EXTENSIONS", cmProperty::VARIABLE,
"Extensions of source files for the given language.",
"This is the list of extensions for a "
"given languages source files.");
"given languages source files.",false,"Variables for Languages");
}

761
Source/cmDocumentation.cxx
View File

File diff suppressed because it is too large Load Diff

147
Source/cmDocumentation.h
View File

@ -24,7 +24,7 @@
#include "cmDocumentationFormatterMan.h"
#include "cmDocumentationFormatterText.h"
#include "cmDocumentationFormatterUsage.h"
#include "cmDocumentationSection.h"
namespace cmsys
{
@ -62,78 +62,16 @@ public:
/** Set the program name for standard document generation. */
void SetName(const char* name);
/** Set the program name section for standard document
* generation. */
void SetNameSection(const cmDocumentationEntry*);
/** Set the program usage for standard document generation. */
void SetUsageSection(const cmDocumentationEntry*);
/** Set the program description for standard document generation. */
void SetDescriptionSection(const cmDocumentationEntry*);
/** Set the program options for standard document generation. */
void SetOptionsSection(const cmDocumentationEntry*);
/** Set the listfile commands for standard document generation. */
void SetCommandsSection(const cmDocumentationEntry*);
/** Set the listfile compat. commands for standard document generation. */
void SetCompatCommandsSection(const cmDocumentationEntry*);
/** Set the global properties for standard document generation. */
void SetPropertiesSection(const cmDocumentationEntry*,
cmProperty::ScopeType type);
/** Set the generator descriptions for standard document generation. */
void SetGeneratorsSection(const cmDocumentationEntry*);
/** Set the see-also list of references to the other tools. */
void SetSeeAlsoList(const cmDocumentationEntry*);
// Low-level interface for custom documents:
/** Internal class representing a section of the documentation.
* Cares e.g. for the different section titles in the different
* output formats.
*/
class cmSection
{
public:
/** Create a cmSection, with a special name for man-output mode. */
cmSection(const char* name, const char* manName)
:Name(name), ManName(manName) {}
/** Has any content been added to this section or is it empty ? */
bool IsEmpty() const
{ return this->Entries.empty(); }
/** Clear contents. */
void Clear()
{ this->Entries.clear(); }
/** Return the name of this section for the given output form. */
const char* GetName(Form form) const
{ return (form==ManForm?this->ManName.c_str():this->Name.c_str()); }
/** Return a pointer to the first entry of this section. */
const cmDocumentationEntry *GetEntries() const
{ return this->Entries.empty()?&this->EmptySection:&this->Entries[0];}
/** Append an entry to this section. */
void Append(const cmDocumentationEntry& entry)
{ this->Entries.push_back(entry); }
/** Set the contents of this section. */
void Set(const cmDocumentationEntry* header,
const cmDocumentationEntry* section,
const cmDocumentationEntry* footer);
private:
std::string Name;
std::string ManName;
std::vector<cmDocumentationEntry> Entries;
static const cmDocumentationEntry EmptySection;
};
/** Set a section of the documentation. Typical sections include Name,
Usage, Description, Options, SeeAlso */
void SetSection(const char *sectionName,
cmDocumentationSection *section);
void SetSection(const char *sectionName,
std::vector<cmDocumentationEntry> &docs);
void SetSection(const char *sectionName,
const char *docs[][3]);
void SetSections(std::map<std::string,cmDocumentationSection *>
&sections);
/**
* Print documentation in the given form. All previously added
@ -148,14 +86,12 @@ public:
void Print(std::ostream& os);
/**
* Add a section of documentation. The cmDocumentationEntry pointer
* should point at an array terminated by an all zero ({0,0,0})
* entry. This can be used to generate custom help documents.
* Add a section of documentation. This can be used to generate custom help
* documents.
*/
void AddSection(const char* name, const cmDocumentationEntry* d);
/** Convenience function, does the same as above */
void AddSection(const cmSection& section);
void AddSectionToPrint(const char *section);
void SetSeeAlsoList(const char *data[][3]);
/** Clear all previously added sections of help. */
void ClearSections();
@ -172,16 +108,18 @@ private:
void SetForm(Form f);
bool CreateSingleModule(const char* fname,
const char* moduleName,
cmSection &moduleSection);
void CreateModuleDocsForDir(cmsys::Directory& dir, cmSection &moduleSection);
const char* moduleName,
cmDocumentationSection &sec);
void CreateModuleDocsForDir(cmsys::Directory& dir,
cmDocumentationSection &moduleSection);
bool CreateModulesSection();
bool CreateCustomModulesSection();
void CreateFullDocumentation();
bool PrintCopyright(std::ostream& os);
bool PrintVersion(std::ostream& os);
bool PrintDocumentationList(std::ostream& os);
bool PrintModuleList(std::ostream& os);
bool PrintPropertyList(std::ostream& os);
bool PrintDocumentationGeneric(std::ostream& os, const char *section);
bool PrintDocumentationList(std::ostream& os, const char *section);
bool PrintDocumentationSingle(std::ostream& os);
bool PrintDocumentationSingleModule(std::ostream& os);
bool PrintDocumentationSingleProperty(std::ostream& os);
@ -193,52 +131,21 @@ private:
bool PrintDocumentationCurrentCommands(std::ostream& os);
bool PrintDocumentationCompatCommands(std::ostream& os);
void PrintDocumentationCommand(std::ostream& os,
const cmDocumentationEntry* entry);
const cmDocumentationEntry &entry);
void CreateUsageDocumentation();
void CreateFullDocumentation();
void CreateCurrentCommandsDocumentation();
void CreateCompatCommandsDocumentation();
void CreateModulesDocumentation();
void CreateCustomModulesDocumentation();
void CreatePropertiesDocumentation();
void SetSection(const cmDocumentationEntry* header,
const cmDocumentationEntry* section,
const cmDocumentationEntry* footer,
std::vector<cmDocumentationEntry>&);
const char* GetNameString() const;
bool IsOption(const char* arg) const;
std::string NameString;
cmSection NameSection;
cmSection UsageSection;
cmSection DescriptionSection;
cmSection OptionsSection;
cmSection CommandsSection;
cmSection CompatCommandsSection;
cmSection ModulesSection;
cmSection CustomModulesSection;
cmSection GeneratorsSection;
cmSection SeeAlsoSection;
cmSection CopyrightSection;
cmSection AuthorSection;
cmSection GlobalPropertiesSection;
cmSection DirectoryPropertiesSection;
cmSection TargetPropertiesSection;
cmSection TestPropertiesSection;
cmSection SourceFilePropertiesSection;
cmSection VariablePropertiesSection;
cmSection CachedVariablePropertiesSection;
std::map<cmProperty::ScopeType, cmSection*> PropertySections;
std::map<std::string,cmDocumentationSection*> AllSections;
std::string SeeAlsoString;
std::string CMakeRoot;
std::string CMakeModulePath;
std::set<std::string> ModulesFound;
std::vector< char* > ModuleStrings;
std::vector< const char* > Names;
std::vector< const cmDocumentationEntry* > Sections;
std::vector<const cmDocumentationSection *> PrintSections;
std::string CurrentArgument;
struct RequestedHelpItem

4
Source/cmDocumentationFormatter.h
View File

@ -39,6 +39,8 @@ public:
enum Form { TextForm, HTMLForm, ManForm, UsageForm };
};
class cmDocumentationSection;
/** Base class for printing the documentation in the various supported
formats. */
class cmDocumentationFormatter
@ -53,7 +55,7 @@ public:
virtual void PrintHeader(const char* /*name*/, std::ostream& /*os*/) {}
virtual void PrintFooter(std::ostream& /*os*/) {}
virtual void PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const cmDocumentationSection& section,
const char* name) = 0;
virtual void PrintPreformatted(std::ostream& os, const char* text) = 0;
virtual void PrintParagraph(std::ostream& os, const char* text) = 0;

63
Source/cmDocumentationFormatterHTML.cxx
View File

@ -15,6 +15,7 @@
=========================================================================*/
#include "cmDocumentationFormatterHTML.h"
#include "cmDocumentationSection.h"
//----------------------------------------------------------------------------
static bool cmDocumentationIsHyperlinkChar(char c)
@ -31,25 +32,21 @@ static bool cmDocumentationIsHyperlinkChar(char c)
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}
};
for(const cmDocumentationEntry* op = escapes; op->name; ++op)
{
if(op->name[0] == c)
{
os << op->brief;
return;
}
}
std::map<char,std::string> escapes;
escapes['<'] = "&lt;";
escapes['>'] = "&gt;";
escapes['&'] = "&amp;";
escapes['\n'] = "<br>";
// No escape sequence is needed.
os << c;
if (escapes.find(c) == escapes.end())
{
// No escape sequence is needed.
os << c;
return;
}
os << escapes[c];
return;
}
//----------------------------------------------------------------------------
@ -88,34 +85,38 @@ cmDocumentationFormatterHTML::cmDocumentationFormatterHTML()
{
}
void cmDocumentationFormatterHTML::PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const char* name)
void cmDocumentationFormatterHTML
::PrintSection(std::ostream& os,
const cmDocumentationSection &section,
const char* name)
{
if(name)
{
os << "<h2>" << name << "</h2>\n";
}
if(!section) { return; }
for(const cmDocumentationEntry* op = section; op->brief;)
const std::vector<cmDocumentationEntry> &entries =
section.GetEntries();
for(std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
op != entries.end();)
{
if(op->name)
if(op->Name.size())
{
os << "<ul>\n";
for(;op->name;++op)
for(;op != entries.end() && op->Name.size(); ++op)
{
os << " <li>\n";
if(op->name[0])
if(op->Name.size())
{
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 +125,7 @@ void cmDocumentationFormatterHTML::PrintSection(std::ostream& os,
}
else
{
this->PrintFormatted(os, op->brief);
this->PrintFormatted(os, op->Brief.c_str());
os << "\n";
++op;
}

2
Source/cmDocumentationFormatterHTML.h
View File

@ -33,7 +33,7 @@ public:
virtual void PrintHeader(const char* name, std::ostream& os);
virtual void PrintFooter(std::ostream& os);
virtual void PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const cmDocumentationSection& section,
const char* name);
virtual void PrintPreformatted(std::ostream& os, const char* text);
virtual void PrintParagraph(std::ostream& os, const char* text);

25
Source/cmDocumentationFormatterMan.cxx
View File

@ -16,6 +16,7 @@
=========================================================================*/
#include "cmDocumentationFormatterMan.h"
#include "cmDocumentationSection.h"
#include "cmSystemTools.h"
#include "cmVersion.h"
@ -26,28 +27,32 @@ cmDocumentationFormatterMan::cmDocumentationFormatterMan()
{
}
void cmDocumentationFormatterMan::PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const char* name)
void cmDocumentationFormatterMan
::PrintSection(std::ostream& os,
const cmDocumentationSection &section,
const char* name)
{
if(name)
{
os << ".SH " << name << "\n";
}
if(!section) { return; }
for(const cmDocumentationEntry* op = section; op->brief; ++op)
const std::vector<cmDocumentationEntry> &entries =
section.GetEntries();
for(std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
op != entries.end(); ++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);
<< ".B " << (op->Name.size()?op->Name.c_str():"*") << "\n";
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());
}
}
}

2
Source/cmDocumentationFormatterMan.h
View File

@ -32,7 +32,7 @@ public:
virtual void PrintHeader(const char* name, std::ostream& os);
virtual void PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const cmDocumentationSection& section,
const char* name);
virtual void PrintPreformatted(std::ostream& os, const char* text);
virtual void PrintParagraph(std::ostream& os, const char* text);

30
Source/cmDocumentationFormatterText.cxx
View File

@ -16,6 +16,7 @@
=========================================================================*/
#include "cmDocumentationFormatterText.h"
#include "cmDocumentationSection.h"
cmDocumentationFormatterText::cmDocumentationFormatterText()
:cmDocumentationFormatter()
@ -24,9 +25,10 @@ cmDocumentationFormatterText::cmDocumentationFormatterText()
{
}
void cmDocumentationFormatterText::PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const char* name)
void cmDocumentationFormatterText
::PrintSection(std::ostream& os,
const cmDocumentationSection &section,
const char* name)
{
if(name)
{
@ -35,27 +37,27 @@ void cmDocumentationFormatterText::PrintSection(std::ostream& os,
"---------------------------------------\n";
os << name << "\n\n";
}
if(!section) { return; }
for(const cmDocumentationEntry* op = section; op->brief; ++op)
const std::vector<cmDocumentationEntry> &entries =
section.GetEntries();
for(std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
op != entries.end(); ++op)
{
if(op->name)
if(op->Name.size())
{
if(op->name[0])
{
os << " " << op->name << "\n";
}
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";
}

2
Source/cmDocumentationFormatterText.h
View File

@ -31,7 +31,7 @@ public:
{ return cmDocumentationEnums::TextForm;}
virtual void PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const cmDocumentationSection& section,
const char* name);
virtual void PrintPreformatted(std::ostream& os, const char* text);
virtual void PrintParagraph(std::ostream& os, const char* text);

27
Source/cmDocumentationFormatterUsage.cxx
View File

@ -16,46 +16,51 @@
=========================================================================*/
#include "cmDocumentationFormatterUsage.h"
#include "cmDocumentationSection.h"
cmDocumentationFormatterUsage::cmDocumentationFormatterUsage()
:cmDocumentationFormatterText()
{
}
void cmDocumentationFormatterUsage::PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const char* name)
void cmDocumentationFormatterUsage
::PrintSection(std::ostream& os,
const cmDocumentationSection &section,
const char* name)
{
if(name)
{
os << name << "\n";
}
if(!section) { return; }
for(const cmDocumentationEntry* op = section; op->brief; ++op)
const std::vector<cmDocumentationEntry> &entries =
section.GetEntries();
for(std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
op != entries.end(); ++op)
{
if(op->name)
if(op->Name.size())
{
os << " " << op->name;
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";

2
Source/cmDocumentationFormatterUsage.h
View File

@ -29,7 +29,7 @@ public:
{ return cmDocumentationEnums::UsageForm;}
virtual void PrintSection(std::ostream& os,
const cmDocumentationEntry* section,
const cmDocumentationSection& section,
const char* name);
};

71
Source/cmDocumentationSection.cxx Normal file
View File

@ -0,0 +1,71 @@
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "cmDocumentationSection.h"
//----------------------------------------------------------------------------
void cmDocumentationSection::Append(const char *data[][3])
{
int i = 0;
while(data[i][1])
{
this->Entries.push_back(cmDocumentationEntry(data[i][0],
data[i][1],
data[i][2]));
data += 1;
}
}
//----------------------------------------------------------------------------
void cmDocumentationSection::Append(const char *n, const char *b,
const char *f)
{
this->Entries.push_back(cmDocumentationEntry(n,b,f));
}
#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

71
Source/cmDocumentationSection.h Normal file
View File

@ -0,0 +1,71 @@
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef _cmDocumentationSection_h
#define _cmDocumentationSection_h
#include "cmStandardIncludes.h"
#include "cmDocumentationFormatter.h"
// Low-level interface for custom documents:
/** Internal class representing a section of the documentation.
* Cares e.g. for the different section titles in the different
* output formats.
*/
class cmDocumentationSection
{
public:
/** Create a cmSection, with a special name for man-output mode. */
cmDocumentationSection(const char* name, const char* manName)
:Name(name), ManName(manName) {}
/** Has any content been added to this section or is it empty ? */
bool IsEmpty() const { return this->Entries.empty(); }
/** Clear contents. */
void Clear() { this->Entries.clear(); }
/** Return the name of this section for the given output form. */
const char* GetName(cmDocumentationEnums::Form form) const
{ return (form==cmDocumentationEnums::ManForm ?
this->ManName.c_str() : this->Name.c_str()); }
/** Return a pointer to the first entry of this section. */
const std::vector<cmDocumentationEntry> &GetEntries() const
{ return this->Entries; }
/** Append an entry to this section. */
void Append(const cmDocumentationEntry& entry)
{ this->Entries.push_back(entry); }
void Append(const std::vector<cmDocumentationEntry> &entries)
{ this->Entries.insert(this->Entries.end(),entries.begin(),entries.end()); }
/** Append an entry to this section using NULL terminated chars */
void Append(const char *[][3]);
void Append(const char *n, const char *b, const char *f);
/** Set the contents of this section. */
// void Set(const std::vector<cmDocumentationEntry> header,
// const std::vector<cmDocumentationEntry> section,
// const std::vector<cmDocumentationEntry> footer);
private:
std::string Name;
std::string ManName;
std::vector<cmDocumentationEntry> Entries;
};
#endif

22
Source/cmDumpDocumentation.cxx
View File

@ -23,7 +23,7 @@
#include "cmVersion.h"
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
static const char *cmDocumentationName[][3] =
{
{0,
" DumpDocumentation - Dump documentation for CMake.", 0},
@ -31,7 +31,7 @@ static const cmDocumentationEntry cmDocumentationName[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
static const char *cmDocumentationUsage[][3] =
{
{0,
" DumpDocumentation [filename]", 0},
@ -39,7 +39,7 @@ static const cmDocumentationEntry cmDocumentationUsage[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDescription[] =
static const char *cmDocumentationDescription[][3] =
{
{0,
"The \"DumpDocumentation\" executable is only available in the build "
@ -49,7 +49,7 @@ static const cmDocumentationEntry cmDocumentationDescription[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationOptions[] =
static const char *cmDocumentationOptions[][3] =
{
{"--all-for-coverage",
"Dump all documentation to stdout. For testing.", 0},
@ -74,7 +74,7 @@ int DumpHTML(const char* outname)
cmOStringStream str;
str << "Documentation for Commands of CMake "
<< cmVersion::GetCMakeVersion();
doc.AddSection(str.str().c_str(), &commands[0]);
doc.SetSection(str.str().c_str(), commands);
doc.Print(cmDocumentation::HTMLForm, fout);
return 0;
@ -88,12 +88,12 @@ int DumpForCoverageToStream(std::ostream& out)
std::vector<cmDocumentationEntry> generators;
cmi.GetCommandDocumentation(commands);
cmi.GetGeneratorDocumentation(generators);
doc.SetNameSection(cmDocumentationName);
doc.SetUsageSection(cmDocumentationUsage);
doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetOptionsSection(cmDocumentationOptions);
doc.SetCommandsSection(&commands[0]);
doc.SetGeneratorsSection(&generators[0]);
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.SetSection("Description",cmDocumentationDescription);
doc.SetSection("options",cmDocumentationOptions);
doc.SetSection("Commands",commands);
doc.SetSection("Generators",generators);
doc.PrintDocumentation(cmDocumentation::Usage, out);
doc.PrintDocumentation(cmDocumentation::Full, out);
return 0;

6
Source/cmExtraCodeBlocksGenerator.cxx
View File

@ -45,9 +45,9 @@ http://forums.codeblocks.org/index.php/topic,6789.0.html
void cmExtraCodeBlocksGenerator
::GetDocumentation(cmDocumentationEntry& entry, const char*) const
{
entry.name = this->GetName();
entry.brief = "Generates CodeBlocks project files.";
entry.full =
entry.Name = this->GetName();
entry.Brief = "Generates CodeBlocks project files.";
entry.Full =
"Project files for CodeBlocks will be created in the top directory "
"and in every subdirectory which features a CMakeLists.txt file "
"containing a PROJECT() call. "

6
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -45,9 +45,9 @@ cmExtraEclipseCDT4Generator
void cmExtraEclipseCDT4Generator
::GetDocumentation(cmDocumentationEntry& entry, const char*) const
{
entry.name = this->GetName();
entry.brief = "Generates Eclipse CDT 4.0 project files.";
entry.full =
entry.Name = this->GetName();
entry.Brief = "Generates Eclipse CDT 4.0 project files.";
entry.Full =
"Project files for Eclipse will be created in the top directory "
"and will have a linked resource to every subdirectory which "
"features a CMakeLists.txt file containing a PROJECT() call."

6
Source/cmGlobalBorlandMakefileGenerator.cxx
View File

@ -62,7 +62,7 @@ cmLocalGenerator *cmGlobalBorlandMakefileGenerator::CreateLocalGenerator()
void cmGlobalBorlandMakefileGenerator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Borland makefiles.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Borland makefiles.";
entry.Full = "";
}

6
Source/cmGlobalGenerator.cxx
View File

@ -1140,9 +1140,9 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen )
//----------------------------------------------------------------------------
void cmGlobalGenerator::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "";
entry.Full = "";
}
bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,

6
Source/cmGlobalMSYSMakefileGenerator.cxx
View File

@ -103,8 +103,8 @@ cmLocalGenerator *cmGlobalMSYSMakefileGenerator::CreateLocalGenerator()
void cmGlobalMSYSMakefileGenerator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates MSYS makefiles.";
entry.full = "The makefiles use /bin/sh as the shell. "
entry.Name = this->GetName();
entry.Brief = "Generates MSYS makefiles.";
entry.Full = "The makefiles use /bin/sh as the shell. "
"They require msys to be installed on the machine.";
}

6
Source/cmGlobalMinGWMakefileGenerator.cxx
View File

@ -83,8 +83,8 @@ cmLocalGenerator *cmGlobalMinGWMakefileGenerator::CreateLocalGenerator()
void cmGlobalMinGWMakefileGenerator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates a make file for use with mingw32-make.";
entry.full = "The makefiles generated use cmd.exe as the shell. "
entry.Name = this->GetName();
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.";
}

6
Source/cmGlobalNMakeMakefileGenerator.cxx
View File

@ -55,7 +55,7 @@ cmLocalGenerator *cmGlobalNMakeMakefileGenerator::CreateLocalGenerator()
void cmGlobalNMakeMakefileGenerator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates NMake makefiles.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates NMake makefiles.";
entry.Full = "";
}

6
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -104,9 +104,9 @@ cmLocalGenerator *cmGlobalUnixMakefileGenerator3::CreateLocalGenerator()
void cmGlobalUnixMakefileGenerator3
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates standard UNIX makefiles.";
entry.full =
entry.Name = this->GetName();
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.";

6
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -483,9 +483,9 @@ void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout)
void cmGlobalVisualStudio6Generator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Visual Studio 6 project files.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio 6 project files.";
entry.Full = "";
}
//----------------------------------------------------------------------------

6
Source/cmGlobalVisualStudio71Generator.cxx
View File

@ -446,7 +446,7 @@ void cmGlobalVisualStudio71Generator::WriteSLNHeader(std::ostream& fout)
void cmGlobalVisualStudio71Generator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Visual Studio .NET 2003 project files.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio .NET 2003 project files.";
entry.Full = "";
}

6
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -733,9 +733,9 @@ std::vector<std::string> *cmGlobalVisualStudio7Generator::GetConfigurations()
void cmGlobalVisualStudio7Generator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Visual Studio .NET 2002 project files.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio .NET 2002 project files.";
entry.Full = "";
}
// make sure "special" targets have GUID's

6
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -53,9 +53,9 @@ void cmGlobalVisualStudio8Generator::WriteSLNHeader(std::ostream& fout)
void cmGlobalVisualStudio8Generator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Visual Studio .NET 2005 project files.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio .NET 2005 project files.";
entry.Full = "";
}
//----------------------------------------------------------------------------

6
Source/cmGlobalVisualStudio8Win64Generator.cxx
View File

@ -42,9 +42,9 @@ cmLocalGenerator *cmGlobalVisualStudio8Win64Generator::CreateLocalGenerator()
void cmGlobalVisualStudio8Win64Generator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Visual Studio .NET 2005 Win64 project files.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio .NET 2005 Win64 project files.";
entry.Full = "";
}
void cmGlobalVisualStudio8Win64Generator

6
Source/cmGlobalVisualStudio9Generator.cxx
View File

@ -48,9 +48,9 @@ cmLocalGenerator *cmGlobalVisualStudio9Generator::CreateLocalGenerator()
void cmGlobalVisualStudio9Generator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Visual Studio 9 2008 project files.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio 9 2008 project files.";
entry.Full = "";
}
void cmGlobalVisualStudio9Generator

6
Source/cmGlobalWatcomWMakeGenerator.cxx
View File

@ -65,7 +65,7 @@ cmLocalGenerator *cmGlobalWatcomWMakeGenerator::CreateLocalGenerator()
void cmGlobalWatcomWMakeGenerator
::GetDocumentation(cmDocumentationEntry& entry) const
{
entry.name = this->GetName();
entry.brief = "Generates Watcom WMake makefiles.";
entry.full = "";
entry.Name = this->GetName();
entry.Brief = "Generates Watcom WMake makefiles.";
entry.Full = "";
}

20
Source/cmMakefile.cxx
View File

@ -1215,6 +1215,17 @@ void cmMakefile::AddDefinition(const char* name, const char* value)
{
return;
}
#ifdef CMAKE_STRICT
if (!this->CMakeInstance->IsPropertyDefined(name,cmProperty::VARIABLE))
{
std::string msg = "Variable ";
msg += name;
msg += " set yet not defined!";
cmSystemTools::Error(msg.c_str());
}
#endif
this->TemporaryDefinitionKey = name;
this->Definitions[this->TemporaryDefinitionKey] = value;
@ -1669,6 +1680,15 @@ bool cmMakefile::IsDefinitionSet(const char* name) const
const char* cmMakefile::GetDefinition(const char* name) const
{
#ifdef CMAKE_STRICT
if (!this->CMakeInstance->IsPropertyDefined(name,cmProperty::VARIABLE))
{
std::string msg = "Variable ";
msg += name;
msg += " queried yet undefined!";
cmSystemTools::Error(msg.c_str());
}
#endif
const char* def = 0;
DefinitionMap::const_iterator pos = this->Definitions.find(name);
if(pos != this->Definitions.end())

12
Source/cmPropertyDefinition.cxx
View File

@ -20,10 +20,9 @@
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;
e.Name = this->Name;
e.Brief = this->ShortDescription;
e.Full = this->FullDescription;
return e;
}
@ -31,6 +30,7 @@ void cmPropertyDefinition
::DefineProperty(const char *name, cmProperty::ScopeType scope,
const char *shortDescription,
const char *fullDescription,
const char *sec,
bool chain)
{
this->Name = name;
@ -44,5 +44,9 @@ void cmPropertyDefinition
{
this->FullDescription = fullDescription;
}
if (sec)
{
this->DocumentationSection = sec;
}
}

10
Source/cmPropertyDefinition.h
View File

@ -26,6 +26,7 @@ public:
void DefineProperty(const char *name, cmProperty::ScopeType scope,
const char *ShortDescription,
const char *FullDescription,
const char *DocumentationSection,
bool chained);
// get the documentation string
@ -37,10 +38,19 @@ public:
// is it chained?
bool IsChained() {return this->Chained; };
// Get the section if any
const std::string &GetDocumentationSection() const {
return this->DocumentationSection; };
// get the scope
cmProperty::ScopeType GetScope() const {
return this->Scope; };
protected:
std::string Name;
std::string ShortDescription;
std::string FullDescription;
std::string DocumentationSection;
cmProperty::ScopeType Scope;
bool Chained;
};

51
Source/cmPropertyDefinitionMap.cxx
View File

@ -16,12 +16,13 @@
=========================================================================*/
#include "cmPropertyDefinitionMap.h"
#include "cmSystemTools.h"
#include "cmDocumentationSection.h"
void cmPropertyDefinitionMap
::DefineProperty(const char *name, cmProperty::ScopeType scope,
const char *ShortDescription,
const char *FullDescription,
const char *DocumentationSection,
bool chain)
{
if (!name)
@ -34,21 +35,59 @@ void cmPropertyDefinitionMap
if (it == this->end())
{
prop = &(*this)[name];
prop->DefineProperty(name,scope,ShortDescription, FullDescription, chain);
prop->DefineProperty(name,scope,ShortDescription, FullDescription,
DocumentationSection, chain);
}
}
void cmPropertyDefinitionMap
::GetPropertiesDocumentation(std::vector<cmDocumentationEntry>& v) const
::GetPropertiesDocumentation(std::map<std::string,
cmDocumentationSection *>& v) const
{
for(cmPropertyDefinitionMap::const_iterator j = this->begin();
j != this->end(); ++j)
{
cmDocumentationEntry e = j->second.GetDocumentation();
if (e.brief)
// add a section if needed
std::string secName = j->second.GetDocumentationSection();
// if a section was not specified then use the scope
if (!secName.size())
{
v.push_back(e);
switch (j->second.GetScope())
{
case cmProperty::GLOBAL:
secName = "Properties of Global Scope";
break;
case cmProperty::TARGET:
secName = "Properties on Targets";
break;
case cmProperty::SOURCE_FILE:
secName = "Properties on Source Files";
break;
case cmProperty::DIRECTORY:
secName = "Properties on Directories";
break;
case cmProperty::TEST:
secName = "Properties on Tests";
break;
case cmProperty::VARIABLE:
secName = "Variables";
break;
case cmProperty::CACHED_VARIABLE:
secName = "Cached Variables";
break;
default:
secName = "Properties of Unknown Scope";
break;
}
}
if (!v[secName])
{
v[secName] = new
cmDocumentationSection(secName.c_str(),
cmSystemTools::UpperCase(secName).c_str());
}
cmDocumentationEntry e = j->second.GetDocumentation();
v[secName]->Append(e);
}
}

6
Source/cmPropertyDefinitionMap.h
View File

@ -19,6 +19,8 @@
#include "cmPropertyDefinition.h"
class cmDocumentationSection;
class cmPropertyDefinitionMap :
public std::map<cmStdString,cmPropertyDefinition>
{
@ -27,6 +29,7 @@ public:
void DefineProperty(const char *name, cmProperty::ScopeType scope,
const char *ShortDescription,
const char *FullDescription,
const char *DocumentaitonSection,
bool chain);
// has a named property been defined
@ -35,7 +38,8 @@ public:
// is a named property set to chain
bool IsPropertyChained(const char *name);
void GetPropertiesDocumentation(std::vector<cmDocumentationEntry>& v) const;
void GetPropertiesDocumentation(std::map<std::string,
cmDocumentationSection *>&) const;
};
#endif

13
Source/cmStandardIncludes.h
View File

@ -316,9 +316,16 @@ 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;
cmDocumentationEntry(){};
cmDocumentationEntry(const char *doc[3])
{ if (doc[0]) this->Name = doc[0];
if (doc[1]) this->Brief = doc[1];
if (doc[2]) this->Full = doc[2]; };
cmDocumentationEntry(const char *n, const char *b, const char *f)
{ if (n) this->Name = n; if (b) this->Brief = b; if (f) this->Full = f; };
};
/** Data structure to represent a single command line. */

44
Source/cmake.cxx
View File

@ -2249,31 +2249,29 @@ void cmake::GetCommandDocumentation(std::vector<cmDocumentationEntry>& v,
for(RegisteredCommandsMap::const_iterator j = this->Commands.begin();
j != this->Commands.end(); ++j)
{
if ((( withCompatCommands == false) && ( (*j).second->IsDiscouraged()))
if ((( withCompatCommands == false) && ( (*j).second->IsDiscouraged()))
|| ((withCurrentCommands == false) && (!(*j).second->IsDiscouraged())))
{
continue;
}
cmDocumentationEntry e =
{
(*j).second->GetName(),
(*j).second->GetTerseDocumentation(),
(*j).second->GetFullDocumentation()
};
continue;
}
cmDocumentationEntry e((*j).second->GetName(),
(*j).second->GetTerseDocumentation(),
(*j).second->GetFullDocumentation());
v.push_back(e);
}
cmDocumentationEntry empty = {0,0,0};
v.push_back(empty);
}
void cmake::GetPropertiesDocumentation(std::vector<cmDocumentationEntry>& v,
cmProperty::ScopeType type)
void cmake::GetPropertiesDocumentation(std::map<std::string,
cmDocumentationSection *>& v)
{
// get the properties for cmake
this->PropertyDefinitions[type].GetPropertiesDocumentation(v);
cmDocumentationEntry empty = {0,0,0};
v.push_back(empty);
// loop over the properties and put them into the doc structure
std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>::iterator i;
i = this->PropertyDefinitions.begin();
for (;i != this->PropertyDefinitions.end(); ++i)
{
i->second.GetPropertiesDocumentation(v);
}
}
void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
@ -2293,12 +2291,10 @@ void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
cmDocumentationEntry e;
cmExternalMakefileProjectGenerator* generator = (i->second)();
generator->GetDocumentation(e, i->first.c_str());
e.name = i->first.c_str();
e.Name = i->first;
delete generator;
v.push_back(e);
}
cmDocumentationEntry empty = {0,0,0};
v.push_back(empty);
}
void cmake::AddWrittenFile(const char* file)
@ -3089,10 +3085,12 @@ void cmake::DefineProperties(cmake *cm)
void cmake::DefineProperty(const char *name, cmProperty::ScopeType scope,
const char *ShortDescription,
const char *FullDescription,
bool chained)
bool chained, const char *docSection)
{
this->PropertyDefinitions[scope].DefineProperty(name,scope,ShortDescription,
FullDescription, chained);
FullDescription,
docSection,
chained);
}
bool cmake::IsPropertyDefined(const char *name, cmProperty::ScopeType scope)

8
Source/cmake.h
View File

@ -52,6 +52,7 @@ class cmCommand;
class cmVariableWatch;
class cmFileTimeComparison;
class cmExternalMakefileProjectGenerator;
class cmDocumentationSection;
class cmake
{
@ -250,8 +251,8 @@ class cmake
void GetCommandDocumentation(std::vector<cmDocumentationEntry>& entries,
bool withCurrentCommands = true,
bool withCompatCommands = true) const;
void GetPropertiesDocumentation(std::vector<cmDocumentationEntry>&,
cmProperty::ScopeType type);
void GetPropertiesDocumentation(std::map<std::string,
cmDocumentationSection *>&);
void GetGeneratorDocumentation(std::vector<cmDocumentationEntry>&);
///! Set/Get a property of this target file
@ -308,7 +309,8 @@ class cmake
void DefineProperty(const char *name, cmProperty::ScopeType scope,
const char *ShortDescription,
const char *FullDescription,
bool chain = false);
bool chain = false,
const char *variableGroup = 0);
// Is a property defined?
bool IsPropertyDefined(const char *name, cmProperty::ScopeType scope);

57
Source/cmakemain.cxx
View File

@ -32,7 +32,7 @@
#ifdef CMAKE_BUILD_WITH_CMAKE
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
static const char * cmDocumentationName[][3] =
{
{0,
" cmake - Cross-Platform Makefile Generator.", 0},
@ -40,7 +40,7 @@ static const cmDocumentationEntry cmDocumentationName[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
static const char * cmDocumentationUsage[][3] =
{
{0,
" cmake [options] <path-to-source>\n"
@ -49,7 +49,7 @@ static const cmDocumentationEntry cmDocumentationUsage[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDescription[] =
static const char * cmDocumentationDescription[][3] =
{
{0,
"The \"cmake\" executable is the CMake command-line interface. It may "
@ -62,7 +62,7 @@ static const cmDocumentationEntry cmDocumentationDescription[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationOptions[] =
static const char * cmDocumentationOptions[][3] =
{
CMAKE_STANDARD_OPTIONS_TABLE,
{"-E", "CMake command mode.",
@ -166,7 +166,7 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationSeeAlso[] =
static const char * cmDocumentationSeeAlso[][3] =
{
{0, "ccmake", 0},
{0, "ctest", 0},
@ -174,7 +174,7 @@ static const cmDocumentationEntry cmDocumentationSeeAlso[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationNOTE[] =
static const char * cmDocumentationNOTE[][3] =
{
{0,
"CMake no longer configures a project when run with no arguments. "
@ -300,43 +300,24 @@ int do_cmake(int ac, char** av)
std::vector<cmDocumentationEntry> commands;
std::vector<cmDocumentationEntry> compatCommands;
std::vector<cmDocumentationEntry> globalProperties;
std::vector<cmDocumentationEntry> dirProperties;
std::vector<cmDocumentationEntry> targetProperties;
std::vector<cmDocumentationEntry> testProperties;
std::vector<cmDocumentationEntry> sourceFileProperties;
std::vector<cmDocumentationEntry> variableProperties;
std::vector<cmDocumentationEntry> cachedVariableProperties;
std::map<std::string,cmDocumentationSection *> propDocs;
std::vector<cmDocumentationEntry> generators;
hcm.GetCommandDocumentation(commands, true, false);
hcm.GetCommandDocumentation(compatCommands, false, true);
hcm.GetPropertiesDocumentation(globalProperties, cmProperty::GLOBAL);
hcm.GetPropertiesDocumentation(dirProperties, cmProperty::DIRECTORY);
hcm.GetPropertiesDocumentation(targetProperties, cmProperty::TARGET);
hcm.GetPropertiesDocumentation(testProperties, cmProperty::TEST);
hcm.GetPropertiesDocumentation(sourceFileProperties,
cmProperty::SOURCE_FILE);
hcm.GetPropertiesDocumentation(variableProperties, cmProperty::VARIABLE);
hcm.GetPropertiesDocumentation(cachedVariableProperties,
cmProperty::CACHED_VARIABLE);
hcm.GetPropertiesDocumentation(propDocs);
hcm.GetGeneratorDocumentation(generators);
doc.SetName("cmake");
doc.SetNameSection(cmDocumentationName);
doc.SetUsageSection(cmDocumentationUsage);
doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetGeneratorsSection(&generators[0]);
doc.SetOptionsSection(cmDocumentationOptions);
doc.SetCommandsSection(&commands[0]);
doc.SetCompatCommandsSection(&compatCommands[0]);
doc.SetPropertiesSection(&globalProperties[0], cmProperty::GLOBAL);
doc.SetPropertiesSection(&dirProperties[0], cmProperty::DIRECTORY);
doc.SetPropertiesSection(&targetProperties[0], cmProperty::TARGET);
doc.SetPropertiesSection(&testProperties[0], cmProperty::TEST);
doc.SetPropertiesSection(&sourceFileProperties[0],cmProperty::SOURCE_FILE);
doc.SetPropertiesSection(&variableProperties[0],cmProperty::VARIABLE);
doc.SetPropertiesSection(&cachedVariableProperties[0],
cmProperty::CACHED_VARIABLE);
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.SetSection("Description",cmDocumentationDescription);
doc.SetSection("Generators",generators);
doc.SetSection("Options",cmDocumentationOptions);
doc.SetSection("Commands",commands);
doc.SetSection("Compatibility Commands",compatCommands);
doc.SetSections(propDocs);
doc.SetSeeAlsoList(cmDocumentationSeeAlso);
int result = doc.PrintRequestedDocumentation(std::cout)? 0:1;
@ -348,7 +329,7 @@ int do_cmake(int ac, char** av)
if((ac == 1) && cmSystemTools::FileExists("CMakeLists.txt"))
{
doc.ClearSections();
doc.AddSection("NOTE", cmDocumentationNOTE);
doc.SetSection("NOTE", cmDocumentationNOTE);
doc.Print(cmDocumentation::UsageForm, std::cerr);
return 1;
}

20
Source/ctest.cxx
View File

@ -23,7 +23,7 @@
#include "CTest/cmCTestScriptHandler.h"
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationName[] =
static const char * cmDocumentationName[][3] =
{
{0,
" ctest - Testing driver provided by CMake.", 0},
@ -31,7 +31,7 @@ static const cmDocumentationEntry cmDocumentationName[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationUsage[] =
static const char * cmDocumentationUsage[][3] =
{
{0,
" ctest [options]", 0},
@ -39,7 +39,7 @@ static const cmDocumentationEntry cmDocumentationUsage[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationDescription[] =
static const char * cmDocumentationDescription[][3] =
{
{0,
"The \"ctest\" executable is the CMake test driver program. "
@ -50,7 +50,7 @@ static const cmDocumentationEntry cmDocumentationDescription[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationOptions[] =
static const char * cmDocumentationOptions[][3] =
{
{"-C <cfg>, --build-config <cfg>", "Choose configuration to test.",
"Some CMake-generated build trees can have multiple build configurations "
@ -198,7 +198,7 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
};
//----------------------------------------------------------------------------
static const cmDocumentationEntry cmDocumentationSeeAlso[] =
static const char * cmDocumentationSeeAlso[][3] =
{
{0, "cmake", 0},
{0, "ccmake", 0},
@ -244,11 +244,11 @@ int main (int argc, char *argv[])
ch->GetCommandDocumentation(commands);
doc.SetName("ctest");
doc.SetNameSection(cmDocumentationName);
doc.SetUsageSection(cmDocumentationUsage);
doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetOptionsSection(cmDocumentationOptions);
doc.SetCommandsSection(&commands[0]);
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.SetSection("Description",cmDocumentationDescription);
doc.SetSection("Options",cmDocumentationOptions);
doc.SetSection("Commands",commands);
doc.SetSeeAlsoList(cmDocumentationSeeAlso);
#ifdef cout
# undef cout