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

Source/CMakeLists.txt

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

Source/CPack/cpack.cxx

@@ -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.SetSection("Name",cmDocumentationName);
-    doc.SetUsageSection(cmDocumentationUsage);
+    doc.SetSection("Usage",cmDocumentationUsage);
-    doc.SetDescriptionSection(cmDocumentationDescription);
+    doc.SetSection("Description",cmDocumentationDescription);
-    doc.SetOptionsSection(cmDocumentationOptions);
+    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.Name = generatorIt->first.c_str();
-      e.brief = generatorIt->second.c_str();
+      e.Brief = generatorIt->second.c_str();
-      e.full = "";
+      e.Full = "";
       v.push_back(e);
       }
-    cmDocumentationEntry empty = {0,0,0};
+    doc.SetSection("Generators",v);
-    v.push_back(empty);
-    doc.SetGeneratorsSection(&v[0]);
 
     doc.SetSeeAlsoList(cmDocumentationSeeAlso);
 #undef cout

Source/CursesDialog/ccmake.cxx

@@ -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.SetSection("Name",cmDocumentationName);
-    doc.SetUsageSection(cmDocumentationUsage);
+    doc.SetSection("Usage",cmDocumentationUsage);
-    doc.SetDescriptionSection(cmDocumentationDescription);
+    doc.SetSection("Description",cmDocumentationDescription);
-    doc.SetGeneratorsSection(&generators[0]);
+    doc.SetSection("Generators",generators);
-    doc.SetOptionsSection(cmDocumentationOptions);
+    doc.SetSection("Options",cmDocumentationOptions);
-    doc.SetCommandsSection(&commands[0]);
+    doc.SetSection("Command",commands);
-    doc.SetCompatCommandsSection(&compatCommands[0]);
+    doc.SetSection("Compatibility Commands",compatCommands);
     doc.SetSeeAlsoList(cmDocumentationSeeAlso);
     return doc.PrintRequestedDocumentation(std::cout)? 0:1;
     }  

Source/MFCDialog/CMakeSetup.cpp

@@ -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.SetSection("Name",cmDocumentationName);
-    doc.SetUsageSection(cmDocumentationUsage);
+    doc.SetSection("Usage",cmDocumentationUsage);
-    doc.SetDescriptionSection(cmDocumentationDescription);
+    doc.SetSection("Description",cmDocumentationDescription);
-    doc.SetGeneratorsSection(&generators[0]);
+    doc.SetSection("Generators",generators);
-    doc.SetOptionsSection(cmDocumentationOptions);
+    doc.SetSection("Options",cmDocumentationOptions);
-    doc.SetCommandsSection(&commands[0]);
+    doc.SetSection("Commands",commands);
-    doc.SetCompatCommandsSection(&compatCommands[0]);
+    doc.SetSection("Compatilbility Commands", compatCommands);
 
     return (doc.PrintRequestedDocumentation(std::cout)? 0:1);
     }

Source/cmDocumentVariables.cxx

@@ -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");
 }

Source/cmDocumentation.h

@@ -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
+  /** Set a section of the documentation. Typical sections include Name,
-   * generation.  */
+      Usage, Description, Options, SeeAlso */
-  void SetNameSection(const cmDocumentationEntry*);
+  void SetSection(const char *sectionName,
-
+                  cmDocumentationSection *section);
-  /** Set the program usage for standard document generation.  */
+  void SetSection(const char *sectionName,
-  void SetUsageSection(const cmDocumentationEntry*);
+                  std::vector<cmDocumentationEntry> &docs);
-
+  void SetSection(const char *sectionName,
-  /** Set the program description for standard document generation.  */
+                  const char *docs[][3]);
-  void SetDescriptionSection(const cmDocumentationEntry*);
+  void SetSections(std::map<std::string,cmDocumentationSection *>
-
+                   &sections);
-  /** 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;
-  };
 
   /**
    * 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
+   * Add a section of documentation. This can be used to generate custom help
-   * should point at an array terminated by an all zero ({0,0,0})
+   * documents.
-   * entry.  This can be used to generate custom help documents.
    */
-  void AddSection(const char* name, const cmDocumentationEntry* d);
+  void AddSectionToPrint(const char *section);
-  
+
-  /** Convenience function, does the same as above */
+  void SetSeeAlsoList(const char *data[][3]);
-  void AddSection(const cmSection& section);
 
   /** 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, 
+                          const char* moduleName,
-                          cmSection &moduleSection);
+                          cmDocumentationSection &sec);
-  void CreateModuleDocsForDir(cmsys::Directory& dir, cmSection &moduleSection);
+  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 PrintDocumentationGeneric(std::ostream& os, const char *section);
-  bool PrintModuleList(std::ostream& os);
+  bool PrintDocumentationList(std::ostream& os, const char *section);
-  bool PrintPropertyList(std::ostream& os);
   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;
+  std::map<std::string,cmDocumentationSection*> AllSections;
-  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::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 cmDocumentationSection *> PrintSections;
-  std::vector< const cmDocumentationEntry* > Sections;
   std::string CurrentArgument;
 
   struct RequestedHelpItem

Source/cmDocumentationFormatter.h

@@ -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;

Source/cmDocumentationFormatterHTML.cxx

@@ -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[] =
+  std::map<char,std::string> escapes;
-  {
+  escapes['<'] = "&lt;";
-    {"<", "&lt;", 0},
+  escapes['>'] = "&gt;";
-    {">", "&gt;", 0},
+  escapes['&'] = "&amp;";
-    {"&", "&amp;", 0},
+  escapes['\n'] = "<br>";
-    {"\n", "<br>", 0},
-    {0,0,0}
-  };
-  for(const cmDocumentationEntry* op = escapes; op->name; ++op)
-    {
-    if(op->name[0] == c)
-      {
-      os << op->brief;
-      return;
-      }
-    }
 
-  // No escape sequence is needed.
+  if (escapes.find(c) == escapes.end())
-  os << c;
+    {
+    // No escape sequence is needed.
+    os << c;
+    return;
+    }
+    
+  os << escapes[c];
+  return;
 }
 
 //----------------------------------------------------------------------------
@@ -88,34 +85,38 @@ cmDocumentationFormatterHTML::cmDocumentationFormatterHTML()
 {
 }
 
-void cmDocumentationFormatterHTML::PrintSection(std::ostream& os,
+void cmDocumentationFormatterHTML
-                                           const cmDocumentationEntry* section,
+::PrintSection(std::ostream& os,
-                                           const char* name)
+               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);
+        this->PrintHTMLEscapes(os, op->Brief.c_str());
-        if(op->full)
+        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;
       }

Source/cmDocumentationFormatterHTML.h

@@ -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);

Source/cmDocumentationFormatterMan.cxx

@@ -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,
+void cmDocumentationFormatterMan
-                  const cmDocumentationEntry* section,
+::PrintSection(std::ostream& os,
-                  const char* name)
+               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";
+         << ".B " << (op->Name.size()?op->Name.c_str():"*") << "\n";
-      this->PrintFormatted(os, op->brief);
+      this->PrintFormatted(os, op->Brief.c_str());
-      this->PrintFormatted(os, op->full);
+      this->PrintFormatted(os, op->Full.c_str());
       }
     else
       {
       os << ".PP\n";
-      this->PrintFormatted(os, op->brief);
+      this->PrintFormatted(os, op->Brief.c_str());
       }
     }
 }

Source/cmDocumentationFormatterMan.h

@@ -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);

Source/cmDocumentationFormatterText.cxx

@@ -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,
+void cmDocumentationFormatterText
-                  const cmDocumentationEntry* section,
+::PrintSection(std::ostream& os,
-                  const char* name)
+               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);
+      this->PrintFormatted(os, op->Brief.c_str());
-      if(op->full)
+      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";
     }

Source/cmDocumentationFormatterText.h

@@ -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);

Source/cmDocumentationFormatterUsage.cxx

@@ -16,46 +16,51 @@
 =========================================================================*/
 
 #include "cmDocumentationFormatterUsage.h"
+#include "cmDocumentationSection.h"
 
 cmDocumentationFormatterUsage::cmDocumentationFormatterUsage()
 :cmDocumentationFormatterText()
 {
 }
 
-void cmDocumentationFormatterUsage::PrintSection(std::ostream& os,
+void cmDocumentationFormatterUsage
-                    const cmDocumentationEntry* section,
+::PrintSection(std::ostream& os,
-                    const char* name)
+               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";

Source/cmDocumentationFormatterUsage.h

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

Source/cmDocumentationSection.cxx

@@ -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

Source/cmDocumentationSection.h

@@ -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

Source/cmDumpDocumentation.cxx

@@ -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.SetSection("Name",cmDocumentationName);
-  doc.SetUsageSection(cmDocumentationUsage);
+  doc.SetSection("Usage",cmDocumentationUsage);
-  doc.SetDescriptionSection(cmDocumentationDescription);
+  doc.SetSection("Description",cmDocumentationDescription);
-  doc.SetOptionsSection(cmDocumentationOptions);
+  doc.SetSection("options",cmDocumentationOptions);
-  doc.SetCommandsSection(&commands[0]);
+  doc.SetSection("Commands",commands);
-  doc.SetGeneratorsSection(&generators[0]);
+  doc.SetSection("Generators",generators);
   doc.PrintDocumentation(cmDocumentation::Usage, out);
   doc.PrintDocumentation(cmDocumentation::Full, out);
   return 0;

Source/cmExtraCodeBlocksGenerator.cxx

@@ -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.Name = this->GetName();
-  entry.brief = "Generates CodeBlocks project files.";
+  entry.Brief = "Generates CodeBlocks project files.";
-  entry.full =
+  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. "

Source/cmExtraEclipseCDT4Generator.cxx

@@ -45,9 +45,9 @@ cmExtraEclipseCDT4Generator
 void cmExtraEclipseCDT4Generator
 ::GetDocumentation(cmDocumentationEntry& entry, const char*) const
 {
-  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 =
+  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."

Source/cmGlobalBorlandMakefileGenerator.cxx

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

Source/cmGlobalGenerator.cxx

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

Source/cmGlobalMSYSMakefileGenerator.cxx

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

Source/cmGlobalMinGWMakefileGenerator.cxx

@@ -83,8 +83,8 @@ cmLocalGenerator *cmGlobalMinGWMakefileGenerator::CreateLocalGenerator()
 void cmGlobalMinGWMakefileGenerator
 ::GetDocumentation(cmDocumentationEntry& entry) const
 {
-  entry.name = this->GetName();
+  entry.Name = this->GetName();
-  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.  "
+  entry.Full = "The makefiles generated use cmd.exe as the shell.  "
     "They do not require msys or a unix shell.";
 }

Source/cmGlobalNMakeMakefileGenerator.cxx

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

Source/cmGlobalUnixMakefileGenerator3.cxx

@@ -104,9 +104,9 @@ cmLocalGenerator *cmGlobalUnixMakefileGenerator3::CreateLocalGenerator()
 void cmGlobalUnixMakefileGenerator3
 ::GetDocumentation(cmDocumentationEntry& entry) const
 {
-  entry.name = this->GetName();
+  entry.Name = this->GetName();
-  entry.brief = "Generates standard UNIX makefiles.";
+  entry.Brief = "Generates standard UNIX makefiles.";
-  entry.full =
+  entry.Full =
     "A hierarchy of UNIX makefiles is generated into the build tree.  Any "
     "standard UNIX-style make program can build the project through the "
     "default make target.  A \"make install\" target is also provided.";

Source/cmGlobalVisualStudio6Generator.cxx

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

Source/cmGlobalVisualStudio71Generator.cxx

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

Source/cmGlobalVisualStudio7Generator.cxx

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

Source/cmGlobalVisualStudio8Generator.cxx

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

Source/cmGlobalVisualStudio8Win64Generator.cxx

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

Source/cmGlobalVisualStudio9Generator.cxx

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

Source/cmGlobalWatcomWMakeGenerator.cxx

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

Source/cmMakefile.cxx

@@ -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())

Source/cmPropertyDefinition.cxx

@@ -20,10 +20,9 @@
 cmDocumentationEntry cmPropertyDefinition::GetDocumentation() const
 {
   cmDocumentationEntry e;
-  e.name = this->Name.c_str();
+  e.Name = this->Name;
-  e.brief = 
+  e.Brief = this->ShortDescription;
-    this->ShortDescription.size() ? this->ShortDescription.c_str() : 0;
+  e.Full = this->FullDescription;
-  e.full = this->FullDescription.size() ? this->FullDescription.c_str() : 0;
   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;
+    }
 }
 

Source/cmPropertyDefinition.h

@@ -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;
 };

Source/cmPropertyDefinitionMap.cxx

@@ -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();
+    // add a section if needed
-    if (e.brief)
+    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);
     }
 }
 

Source/cmPropertyDefinitionMap.h

@@ -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

Source/cmStandardIncludes.h

@@ -316,9 +316,16 @@ extern void operator << (std::ostream&, const cmOStringStream&);
 /** Standard documentation entry for cmDocumentation's formatting.  */
 struct cmDocumentationEntry
 {
-  const char* name;
+  std::string Name;
-  const char* brief;
+  std::string Brief;
-  const char* full;
+  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.  */

Source/cmake.cxx

@@ -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(),
+      continue;
-        (*j).second->GetTerseDocumentation(),
+      }
-        (*j).second->GetFullDocumentation()
+    
-      };
+    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, 
+void cmake::GetPropertiesDocumentation(std::map<std::string,
-                                       cmProperty::ScopeType type)
+                                       cmDocumentationSection *>& v)
 {
-  // get the properties for cmake
+  // loop over the properties and put them into the doc structure
-  this->PropertyDefinitions[type].GetPropertiesDocumentation(v);
+  std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>::iterator i;
-  cmDocumentationEntry empty = {0,0,0};
+  i = this->PropertyDefinitions.begin();
-  v.push_back(empty);
+  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)

Source/cmake.h

@@ -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>&,
+  void GetPropertiesDocumentation(std::map<std::string,
-                                  cmProperty::ScopeType type);
+                                  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);

Source/cmakemain.cxx

@@ -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::map<std::string,cmDocumentationSection *> propDocs;
-    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::vector<cmDocumentationEntry> generators;
     hcm.GetCommandDocumentation(commands, true, false);
     hcm.GetCommandDocumentation(compatCommands, false, true);
-    hcm.GetPropertiesDocumentation(globalProperties, cmProperty::GLOBAL);
+    hcm.GetPropertiesDocumentation(propDocs);
-    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.GetGeneratorDocumentation(generators);
+
     doc.SetName("cmake");
-    doc.SetNameSection(cmDocumentationName);
+    doc.SetSection("Name",cmDocumentationName);
-    doc.SetUsageSection(cmDocumentationUsage);
+    doc.SetSection("Usage",cmDocumentationUsage);
-    doc.SetDescriptionSection(cmDocumentationDescription);
+    doc.SetSection("Description",cmDocumentationDescription);
-    doc.SetGeneratorsSection(&generators[0]);
+    doc.SetSection("Generators",generators);
-    doc.SetOptionsSection(cmDocumentationOptions);
+    doc.SetSection("Options",cmDocumentationOptions);
-    doc.SetCommandsSection(&commands[0]);
+    doc.SetSection("Commands",commands);
-    doc.SetCompatCommandsSection(&compatCommands[0]);
+    doc.SetSection("Compatibility Commands",compatCommands);
-    doc.SetPropertiesSection(&globalProperties[0], cmProperty::GLOBAL);
+    doc.SetSections(propDocs);
-    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.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;
       }

Source/ctest.cxx

@@ -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.SetSection("Name",cmDocumentationName);
-      doc.SetUsageSection(cmDocumentationUsage);
+      doc.SetSection("Usage",cmDocumentationUsage);
-      doc.SetDescriptionSection(cmDocumentationDescription);
+      doc.SetSection("Description",cmDocumentationDescription);
-      doc.SetOptionsSection(cmDocumentationOptions);
+      doc.SetSection("Options",cmDocumentationOptions);
-      doc.SetCommandsSection(&commands[0]);
+      doc.SetSection("Commands",commands);
       doc.SetSeeAlsoList(cmDocumentationSeeAlso);
 #ifdef cout
 #  undef cout