Remove `//------...` horizontal separator comments

Modern editors provide plenty of ways to visually separate functions.
Drop the explicit comments that previously served this purpose.
Use the following command to automate the change:

    $ git ls-files -z -- \
        "*.c" "*.cc" "*.cpp" "*.cxx" "*.h" "*.hh" "*.hpp" "*.hxx" |
      egrep -z -v "^Source/cmCommandArgumentLexer\." |
      egrep -z -v "^Source/cmCommandArgumentParser(\.y|\.cxx|Tokens\.h)" |
      egrep -z -v "^Source/cmDependsJavaLexer\." |
      egrep -z -v "^Source/cmDependsJavaParser(\.y|\.cxx|Tokens\.h)" |
      egrep -z -v "^Source/cmExprLexer\." |
      egrep -z -v "^Source/cmExprParser(\.y|\.cxx|Tokens\.h)" |
      egrep -z -v "^Source/cmFortranLexer\." |
      egrep -z -v "^Source/cmFortranParser(\.y|\.cxx|Tokens\.h)" |
      egrep -z -v "^Source/cmListFileLexer\." |
      egrep -z -v "^Source/cm_sha2" |
      egrep -z -v "^Source/(kwsys|CursesDialog/form)/" |
      egrep -z -v "^Utilities/(KW|cm).*/" |
      xargs -0 sed -i '/^\(\/\/---*\|\/\*---*\*\/\)$/ {d;}'

This avoids modifying third-party sources and generated sources.

Modules/CMakeCCompilerABI.c

@@ -6,11 +6,9 @@
 # define const
 #endif
 
-/*--------------------------------------------------------------------------*/
 
 #include "CMakeCompilerABI.h"
 
-/*--------------------------------------------------------------------------*/
 
 #ifdef __CLASSIC_C__
 int main(argc, argv) int argc; char *argv[];

Modules/CMakeCXXCompilerABI.cpp

@@ -2,11 +2,9 @@
 # error "A C compiler has been selected for C++."
 #endif
 
-/*--------------------------------------------------------------------------*/
 
 #include "CMakeCompilerABI.h"
 
-/*--------------------------------------------------------------------------*/
 
 int main(int argc, char* argv[])
 {

Modules/CMakeCompilerABI.h

@@ -1,4 +1,3 @@
-/*--------------------------------------------------------------------------*/
 
 /* Size of a pointer-to-data in bytes.  */
 #define SIZEOF_DPTR (sizeof(void*))
@@ -10,7 +9,6 @@ const char info_sizeof_dptr[] =  {
   /* clang-format needs this comment to break after the opening brace */
 };
 
-/*--------------------------------------------------------------------------*/
 
 /* Application Binary Interface.  */
 #if defined(__sgi) && defined(_ABIO32)

Source/CPack/IFW/cmCPackIFWGenerator.cxx

@@ -31,38 +31,32 @@
 #include <cmVersionConfig.h>
 #include <cmXMLWriter.h>
 
-//----------------------------------------------------------------------------
 cmCPackIFWGenerator::cmCPackIFWGenerator()
 {
 }
 
-//----------------------------------------------------------------------------
 cmCPackIFWGenerator::~cmCPackIFWGenerator()
 {
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWGenerator::IsVersionLess(const char *version)
 {
   return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
     FrameworkVersion.data(), version);
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWGenerator::IsVersionGreater(const char *version)
 {
   return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
     FrameworkVersion.data(), version);
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWGenerator::IsVersionEqual(const char *version)
 {
   return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
     FrameworkVersion.data(), version);
 }
 
-//----------------------------------------------------------------------------
 int cmCPackIFWGenerator::PackageFiles()
 {
   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Configuration" << std::endl);
@@ -223,7 +217,6 @@ int cmCPackIFWGenerator::PackageFiles()
   return 1;
 }
 
-//----------------------------------------------------------------------------
 const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
 {
   const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
@@ -240,13 +233,11 @@ const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
   return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
 }
 
-//----------------------------------------------------------------------------
 const char *cmCPackIFWGenerator::GetOutputExtension()
 {
   return ExecutableSuffix.c_str();
 }
 
-//----------------------------------------------------------------------------
 int cmCPackIFWGenerator::InitializeInternal()
 {
   // Search Qt Installer Framework tools
@@ -367,7 +358,6 @@ int cmCPackIFWGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------------
 std::string
 cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
   const std::string& componentName)
@@ -384,7 +374,6 @@ cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
     + suffix;
 }
 
-//----------------------------------------------------------------------------
 cmCPackComponent*
 cmCPackIFWGenerator::GetComponent(const std::string &projectName,
                                   const std::string &componentName)
@@ -433,7 +422,6 @@ cmCPackIFWGenerator::GetComponent(const std::string &projectName,
   return component;
 }
 
-//----------------------------------------------------------------------------
 cmCPackComponentGroup*
 cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName,
                                        const std::string &groupName)
@@ -471,32 +459,27 @@ cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName,
   return group;
 }
 
-//----------------------------------------------------------------------------
 enum cmCPackGenerator::CPackSetDestdirSupport
 cmCPackIFWGenerator::SupportsSetDestdir() const
 {
   return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWGenerator::SupportsAbsoluteDestination() const
 {
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWGenerator::SupportsComponentInstallation() const
 {
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWGenerator::IsOnePackage() const
 {
   return componentPackageMethod == ONE_PACKAGE;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCPackIFWGenerator::GetRootPackageName()
 {
   // Default value
@@ -525,7 +508,6 @@ std::string cmCPackIFWGenerator::GetRootPackageName()
   return name;
 }
 
-//----------------------------------------------------------------------------
 std::string
 cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
 {
@@ -556,7 +538,6 @@ cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
   return name;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCPackIFWGenerator::GetComponentPackageName(
   cmCPackComponent *component) const
 {
@@ -592,7 +573,6 @@ std::string cmCPackIFWGenerator::GetComponentPackageName(
   return name;
 }
 
-//----------------------------------------------------------------------------
 cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
   cmCPackComponentGroup *group) const
 {
@@ -601,7 +581,6 @@ cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
   return pit != GroupPackages.end() ? pit->second : 0;
 }
 
-//----------------------------------------------------------------------------
 cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
   cmCPackComponent *component) const
 {
@@ -610,7 +589,6 @@ cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
   return pit != ComponentPackages.end() ? pit->second : 0;
 }
 
-//----------------------------------------------------------------------------
 void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmXMLWriter &xout)
 {
   std::stringstream comment;

Source/CPack/IFW/cmCPackIFWInstaller.cxx

@@ -32,44 +32,37 @@
   }                                                                     \
   } while ( 0 )
 
-//----------------------------------------------------------------------------
 cmCPackIFWInstaller::cmCPackIFWInstaller() :
   Generator(0)
 {
 }
 
-//----------------------------------------------------------------------------
 const char *cmCPackIFWInstaller::GetOption(const std::string &op) const
 {
   return Generator ? Generator->GetOption(op) : 0;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWInstaller::IsOn(const std::string &op) const
 {
   return Generator ? Generator->IsOn(op) : false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWInstaller::IsVersionLess(const char *version)
 {
   return Generator ? Generator->IsVersionLess(version) : false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWInstaller::IsVersionGreater(const char *version)
 {
   return Generator ? Generator->IsVersionGreater(version) : false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWInstaller::IsVersionEqual(const char *version)
 {
   return Generator ? Generator->IsVersionEqual(version) : false;
 }
 
 
-//----------------------------------------------------------------------------
 void cmCPackIFWInstaller::ConfigureFromOptions()
 {
   // Name;
@@ -324,7 +317,6 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCPackIFWInstaller::GenerateInstallerFile()
 {
   // Lazy directory initialization
@@ -486,7 +478,6 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
   xout.EndDocument();
 }
 
-//----------------------------------------------------------------------------
 void cmCPackIFWInstaller::GeneratePackageFiles()
 {
   if (Packages.empty() || Generator->IsOnePackage())

Source/CPack/IFW/cmCPackIFWPackage.cxx

@@ -45,7 +45,6 @@ cmCPackIFWPackage::DependenceStruct::DependenceStruct()
 {
 }
 
-//----------------------------------------------------------------------------
 cmCPackIFWPackage::DependenceStruct::DependenceStruct(
   const std::string &dependence)
 {
@@ -79,7 +78,6 @@ cmCPackIFWPackage::DependenceStruct::DependenceStruct(
   Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
 }
 
-//----------------------------------------------------------------------------
 std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
 {
   if (Compare.Type == CompareNone) return Name;
@@ -119,38 +117,32 @@ cmCPackIFWPackage::cmCPackIFWPackage() :
 {
 }
 
-//----------------------------------------------------------------------------
 const char *cmCPackIFWPackage::GetOption(const std::string &op) const
 {
   const char *option = Generator ? Generator->GetOption(op) : 0;
   return option && *option ? option : 0;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWPackage::IsOn(const std::string &op) const
 {
   return Generator ? Generator->IsOn(op) : false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWPackage::IsVersionLess(const char *version)
 {
   return Generator ? Generator->IsVersionLess(version) : false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWPackage::IsVersionGreater(const char *version)
 {
   return Generator ? Generator->IsVersionGreater(version) : false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCPackIFWPackage::IsVersionEqual(const char *version)
 {
   return Generator ? Generator->IsVersionEqual(version) : false;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
 {
   if (!component) return "";
@@ -161,7 +153,6 @@ std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
   return option ? option : component->Name;
 }
 
-//----------------------------------------------------------------------------
 void cmCPackIFWPackage::DefaultConfiguration()
 {
   DisplayName = "";
@@ -176,7 +167,6 @@ void cmCPackIFWPackage::DefaultConfiguration()
   ForcedInstallation = "";
 }
 
-//----------------------------------------------------------------------------
 // Defaul configuration (all in one package)
 int cmCPackIFWPackage::ConfigureFromOptions()
 {
@@ -222,7 +212,6 @@ int cmCPackIFWPackage::ConfigureFromOptions()
   return 1;
 }
 
-//----------------------------------------------------------------------------
 int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
 {
   if(!component) return 0;
@@ -329,7 +318,6 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
   return 1;
 }
 
-//----------------------------------------------------------------------------
 int
 cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
 {
@@ -389,7 +377,6 @@ cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
   return 1;
 }
 
-//----------------------------------------------------------------------------
 int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
 {
   // Group configuration
@@ -431,7 +418,6 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
   return ConfigureFromGroup(&group);
 }
 
-//----------------------------------------------------------------------------
 void cmCPackIFWPackage::GeneratePackageFile()
 {
   // Lazy directory initialization

Source/CPack/cmCPack7zGenerator.cxx

@@ -12,14 +12,12 @@
 
 #include "cmCPack7zGenerator.h"
 
-//----------------------------------------------------------------------
 cmCPack7zGenerator::cmCPack7zGenerator()
   :cmCPackArchiveGenerator(cmArchiveWrite::CompressNone,
                            "7zip")
 {
 }
 
-//----------------------------------------------------------------------
 cmCPack7zGenerator::~cmCPack7zGenerator()
 {
 }

Source/CPack/cmCPackArchiveGenerator.cxx

@@ -24,7 +24,6 @@
 #include <cmsys/Directory.hxx>
 #include <cmsys/SystemTools.hxx>
 
-//----------------------------------------------------------------------
 cmCPackArchiveGenerator::cmCPackArchiveGenerator(cmArchiveWrite::Compress t,
   std::string const& format)
 {
@@ -32,18 +31,15 @@ cmCPackArchiveGenerator::cmCPackArchiveGenerator(cmArchiveWrite::Compress t,
   this->ArchiveFormat = format;
 }
 
-//----------------------------------------------------------------------
 cmCPackArchiveGenerator::~cmCPackArchiveGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackArchiveGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
   return this->Superclass::InitializeInternal();
 }
-//----------------------------------------------------------------------
 int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
                              cmCPackComponent* component)
 {
@@ -118,7 +114,6 @@ if (!archive) \
   return 0; \
   }
 
-//----------------------------------------------------------------------
 int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
 {
   packageFileNames.clear();
@@ -220,7 +215,6 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackArchiveGenerator::PackageComponentsAllInOne()
 {
   // reset the package file names
@@ -248,7 +242,6 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackArchiveGenerator::PackageFiles()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
@@ -300,7 +293,6 @@ int cmCPackArchiveGenerator::PackageFiles()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
 {
   return 1;

Source/CPack/cmCPackBundleGenerator.cxx

@@ -17,17 +17,14 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-//----------------------------------------------------------------------
 cmCPackBundleGenerator::cmCPackBundleGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackBundleGenerator::~cmCPackBundleGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackBundleGenerator::InitializeInternal()
 {
   const char* name = this->GetOption("CPACK_BUNDLE_NAME");
@@ -58,7 +55,6 @@ int cmCPackBundleGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 const char* cmCPackBundleGenerator::GetPackagingInstallPrefix()
 {
   this->InstallPrefix = "/";
@@ -68,7 +64,6 @@ const char* cmCPackBundleGenerator::GetPackagingInstallPrefix()
   return this->InstallPrefix.c_str();
 }
 
-//----------------------------------------------------------------------
 int cmCPackBundleGenerator::ConstructBundle()
 {
 
@@ -184,7 +179,6 @@ int cmCPackBundleGenerator::ConstructBundle()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackBundleGenerator::PackageFiles()
 {
   if(!this->ConstructBundle())

Source/CPack/cmCPackComponentGroup.cxx

@@ -17,7 +17,6 @@
 #include <string>
 #include <vector>
 
-//----------------------------------------------------------------------
 unsigned long cmCPackComponent::GetInstalledSize(
     const std::string& installDir) const
 {
@@ -38,7 +37,6 @@ unsigned long cmCPackComponent::GetInstalledSize(
   return this->TotalSize;
 }
 
-//----------------------------------------------------------------------
 unsigned long
 cmCPackComponent::GetInstalledSizeInKbytes(const std::string& installDir) const
 {

Source/CPack/cmCPackCygwinBinaryGenerator.cxx

@@ -21,17 +21,14 @@
 
 #include <cmsys/SystemTools.hxx>
 
-//----------------------------------------------------------------------
 cmCPackCygwinBinaryGenerator::cmCPackCygwinBinaryGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackCygwinBinaryGenerator::~cmCPackCygwinBinaryGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackCygwinBinaryGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
@@ -39,7 +36,6 @@ int cmCPackCygwinBinaryGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 int cmCPackCygwinBinaryGenerator::PackageFiles()
 {
   std::string packageName = this->GetOption("CPACK_PACKAGE_NAME");

Source/CPack/cmCPackCygwinSourceGenerator.cxx

@@ -29,24 +29,20 @@
 # include <windows.h>
 #endif
 
-//----------------------------------------------------------------------
 cmCPackCygwinSourceGenerator::cmCPackCygwinSourceGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackCygwinSourceGenerator::~cmCPackCygwinSourceGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackCygwinSourceGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 int cmCPackCygwinSourceGenerator::PackageFiles()
 {
   // Create a tar file of the sources

Source/CPack/cmCPackDebGenerator.cxx

@@ -32,17 +32,14 @@
 // Therefore we provide our own implementation of a BSD-ar:
 static int ar_append(const char*archive,const std::vector<std::string>& files);
 
-//----------------------------------------------------------------------
 cmCPackDebGenerator::cmCPackDebGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackDebGenerator::~cmCPackDebGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackDebGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
@@ -53,7 +50,6 @@ int cmCPackDebGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 int cmCPackDebGenerator::PackageOnePack(std::string initialTopLevel,
                                         std::string packageName)
   {
@@ -115,7 +111,6 @@ int cmCPackDebGenerator::PackageOnePack(std::string initialTopLevel,
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
 {
   int retval = 1;
@@ -170,7 +165,6 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackDebGenerator::PackageComponentsAllInOne()
 {
   int retval = 1;
@@ -243,7 +237,6 @@ int cmCPackDebGenerator::PackageComponentsAllInOne()
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackDebGenerator::PackageFiles()
 {
   int retval = -1;

Source/CPack/cmCPackDragNDropGenerator.cxx

@@ -61,7 +61,6 @@ static const char* SLASTREnglish =
 "};\n"
 "\n";
 
-//----------------------------------------------------------------------
 cmCPackDragNDropGenerator::cmCPackDragNDropGenerator()
   : singleLicense(false)
 {
@@ -69,12 +68,10 @@ cmCPackDragNDropGenerator::cmCPackDragNDropGenerator()
   this->componentPackageMethod = ONE_PACKAGE;
 }
 
-//----------------------------------------------------------------------
 cmCPackDragNDropGenerator::~cmCPackDragNDropGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackDragNDropGenerator::InitializeInternal()
 {
   // Starting with Xcode 4.3, look in "/Applications/Xcode.app" first:
@@ -183,13 +180,11 @@ int cmCPackDragNDropGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 const char* cmCPackDragNDropGenerator::GetOutputExtension()
 {
   return ".dmg";
 }
 
-//----------------------------------------------------------------------
 int cmCPackDragNDropGenerator::PackageFiles()
 {
   // gather which directories to make dmg files for
@@ -245,7 +240,6 @@ int cmCPackDragNDropGenerator::PackageFiles()
   return 1;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
   std::ostringstream& target)
 {
@@ -266,7 +260,6 @@ bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackDragNDropGenerator::CreateEmptyFile(std::ostringstream& target,
                                                 size_t size)
 {
@@ -288,7 +281,6 @@ bool cmCPackDragNDropGenerator::CreateEmptyFile(std::ostringstream& target,
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
   std::string* output)
 {
@@ -315,7 +307,6 @@ bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
   return true;
 }
 
-//----------------------------------------------------------------------
 int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
                                          const std::string& output_file)
 {

Source/CPack/cmCPackGenerator.cxx

@@ -31,7 +31,6 @@
 #include <StorageDefs.h>
 #endif
 
-//----------------------------------------------------------------------
 cmCPackGenerator::cmCPackGenerator()
 {
   this->GeneratorVerbose = cmSystemTools::OUTPUT_NONE;
@@ -40,20 +39,17 @@ cmCPackGenerator::cmCPackGenerator()
   this->componentPackageMethod = ONE_PACKAGE_PER_GROUP;
 }
 
-//----------------------------------------------------------------------
 cmCPackGenerator::~cmCPackGenerator()
 {
   this->MakefileMap = 0;
 }
 
-//----------------------------------------------------------------------
 void cmCPackGeneratorProgress(const char *msg, float prog, void* ptr)
 {
   cmCPackGenerator* self = static_cast<cmCPackGenerator*>(ptr);
   self->DisplayVerboseOutput(msg, prog);
 }
 
-//----------------------------------------------------------------------
 void cmCPackGenerator::DisplayVerboseOutput(const char* msg,
   float progress)
 {
@@ -61,7 +57,6 @@ void cmCPackGenerator::DisplayVerboseOutput(const char* msg,
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "" << msg << std::endl);
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::PrepareNames()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
@@ -185,7 +180,6 @@ int cmCPackGenerator::PrepareNames()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::InstallProject()
 {
   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Install projects" << std::endl);
@@ -267,7 +261,6 @@ int cmCPackGenerator::InstallProject()
   return res;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::InstallProjectViaInstallCommands(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
@@ -311,7 +304,6 @@ int cmCPackGenerator::InstallProjectViaInstallCommands(
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::InstallProjectViaInstalledDirectories(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
@@ -473,7 +465,6 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::InstallProjectViaInstallScript(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
@@ -540,7 +531,6 @@ int cmCPackGenerator::InstallProjectViaInstallScript(
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
   bool setDestDir, const std::string& baseTempInstallDirectory)
 {
@@ -983,7 +973,6 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
   return 1;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::ReadListFile(const char* moduleName)
 {
   bool retval;
@@ -994,7 +983,6 @@ bool cmCPackGenerator::ReadListFile(const char* moduleName)
   return retval;
 }
 
-//----------------------------------------------------------------------
 void cmCPackGenerator::SetOptionIfNotSet(const std::string& op,
   const char* value)
 {
@@ -1006,7 +994,6 @@ void cmCPackGenerator::SetOptionIfNotSet(const std::string& op,
   this->SetOption(op, value);
 }
 
-//----------------------------------------------------------------------
 void cmCPackGenerator::SetOption(const std::string& op, const char* value)
 {
   if ( !value )
@@ -1019,7 +1006,6 @@ void cmCPackGenerator::SetOption(const std::string& op, const char* value)
   this->MakefileMap->AddDefinition(op, value);
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::DoPackage()
 {
   cmCPackLogger(cmCPackLog::LOG_OUTPUT,
@@ -1160,7 +1146,6 @@ int cmCPackGenerator::DoPackage()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::Initialize(const std::string& name, cmMakefile* mf)
 {
   this->MakefileMap = mf;
@@ -1188,25 +1173,21 @@ int cmCPackGenerator::Initialize(const std::string& name, cmMakefile* mf)
   return result;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::InitializeInternal()
 {
   return 1;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::IsSet(const std::string& name) const
 {
   return this->MakefileMap->IsSet(name);
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::IsOn(const std::string& name) const
 {
   return cmSystemTools::IsOn(GetOption(name));
 }
 
-//----------------------------------------------------------------------
 const char* cmCPackGenerator::GetOption(const std::string& op) const
 {
   const char* ret = this->MakefileMap->GetDefinition(op);
@@ -1220,19 +1201,16 @@ const char* cmCPackGenerator::GetOption(const std::string& op) const
   return ret;
 }
 
-//----------------------------------------------------------------------
 std::vector<std::string> cmCPackGenerator::GetOptions() const
 {
   return this->MakefileMap->GetDefinitions();
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::PackageFiles()
 {
   return 0;
 }
 
-//----------------------------------------------------------------------
 const char* cmCPackGenerator::GetInstallPath()
 {
   if ( !this->InstallPath.empty() )
@@ -1275,7 +1253,6 @@ const char* cmCPackGenerator::GetInstallPath()
   return this->InstallPath.c_str();
 }
 
-//----------------------------------------------------------------------
 const char* cmCPackGenerator::GetPackagingInstallPrefix()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "GetPackagingInstallPrefix: '"
@@ -1284,7 +1261,6 @@ const char* cmCPackGenerator::GetPackagingInstallPrefix()
   return this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
 }
 
-//----------------------------------------------------------------------
 std::string cmCPackGenerator::FindTemplate(const char* name)
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for template: "
@@ -1295,7 +1271,6 @@ std::string cmCPackGenerator::FindTemplate(const char* name)
   return ffile;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::ConfigureString(const std::string& inString,
   std::string& outString)
 {
@@ -1304,7 +1279,6 @@ bool cmCPackGenerator::ConfigureString(const std::string& inString,
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::ConfigureFile(const char* inName,
   const char* outName, bool copyOnly /* = false */)
 {
@@ -1312,7 +1286,6 @@ bool cmCPackGenerator::ConfigureFile(const char* inName,
     copyOnly, true, false) == 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::CleanTemporaryDirectory()
 {
   std::string tempInstallDirectoryWithPostfix
@@ -1335,7 +1308,6 @@ int cmCPackGenerator::CleanTemporaryDirectory()
   return 1;
 }
 
-//----------------------------------------------------------------------
 cmInstalledFile const* cmCPackGenerator::GetInstalledFile(
   std::string const& name) const
 {
@@ -1343,7 +1315,6 @@ cmInstalledFile const* cmCPackGenerator::GetInstalledFile(
   return cm->GetInstalledFile(name);
 }
 
-//----------------------------------------------------------------------
 int cmCPackGenerator::PrepareGroupingKind()
 {
   // find a component package method specified by the user
@@ -1440,12 +1411,10 @@ int cmCPackGenerator::PrepareGroupingKind()
   return 1;
 }
 
-//----------------------------------------------------------------------
 std::string cmCPackGenerator::GetComponentInstallDirNameSuffix(
     const std::string& componentName) {
   return componentName;
 }
-//----------------------------------------------------------------------
 std::string cmCPackGenerator::GetComponentPackageFileName(
     const std::string& initialPackageFileName,
     const std::string& groupOrComponentName,
@@ -1486,26 +1455,22 @@ std::string cmCPackGenerator::GetComponentPackageFileName(
   return initialPackageFileName + suffix;
 }
 
-//----------------------------------------------------------------------
 enum cmCPackGenerator::CPackSetDestdirSupport
 cmCPackGenerator::SupportsSetDestdir() const
 {
   return cmCPackGenerator::SETDESTDIR_SUPPORTED;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::SupportsAbsoluteDestination() const
 {
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::SupportsComponentInstallation() const
 {
   return false;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackGenerator::WantsComponentInstallation() const
 {
   return (!IsOn("CPACK_MONOLITHIC_INSTALL")
@@ -1514,7 +1479,6 @@ bool cmCPackGenerator::WantsComponentInstallation() const
         && (!this->ComponentGroups.empty() || !this->Components.empty()));
 }
 
-//----------------------------------------------------------------------
 cmCPackInstallationType*
 cmCPackGenerator::GetInstallationType(const std::string& projectName,
                                       const std::string& name)
@@ -1546,7 +1510,6 @@ cmCPackGenerator::GetInstallationType(const std::string& projectName,
   return installType;
 }
 
-//----------------------------------------------------------------------
 cmCPackComponent*
 cmCPackGenerator::GetComponent(const std::string& projectName,
                                const std::string& name)
@@ -1642,7 +1605,6 @@ cmCPackGenerator::GetComponent(const std::string& projectName,
   return component;
 }
 
-//----------------------------------------------------------------------
 cmCPackComponentGroup*
 cmCPackGenerator::GetComponentGroup(const std::string& projectName,
                                     const std::string& name)

Source/CPack/cmCPackGeneratorFactory.cxx

@@ -49,7 +49,6 @@
 #include "cmCPackLog.h"
 
 
-//----------------------------------------------------------------------
 cmCPackGeneratorFactory::cmCPackGeneratorFactory()
 {
   if (cmCPackTGZGenerator::CanGenerate())
@@ -156,13 +155,11 @@ cmCPackGeneratorFactory::cmCPackGeneratorFactory()
 #endif
 }
 
-//----------------------------------------------------------------------
 cmCPackGeneratorFactory::~cmCPackGeneratorFactory()
 {
   cmDeleteAll(this->Generators);
 }
 
-//----------------------------------------------------------------------
 cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
                                                 const std::string& name)
 {
@@ -176,7 +173,6 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
   return gen;
 }
 
-//----------------------------------------------------------------------
 cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal(
   const std::string& name)
 {
@@ -189,7 +185,6 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal(
   return (it->second)();
 }
 
-//----------------------------------------------------------------------
 void cmCPackGeneratorFactory::RegisterGenerator(const std::string& name,
   const char* generatorDescription,
   CreateGeneratorCall* createGenerator)

Source/CPack/cmCPackLog.cxx

@@ -15,7 +15,6 @@
 #include "cmGeneratedFileStream.h"
 #include "cmSystemTools.h"
 
-//----------------------------------------------------------------------
 cmCPackLog::cmCPackLog()
 {
   this->Verbose = false;
@@ -33,13 +32,11 @@ cmCPackLog::cmCPackLog()
   this->LogOutputCleanup = false;
 }
 
-//----------------------------------------------------------------------
 cmCPackLog::~cmCPackLog()
 {
   this->SetLogOutputStream(0);
 }
 
-//----------------------------------------------------------------------
 void cmCPackLog::SetLogOutputStream(std::ostream* os)
 {
   if ( this->LogOutputCleanup && this->LogOutput )
@@ -50,7 +47,6 @@ void cmCPackLog::SetLogOutputStream(std::ostream* os)
   this->LogOutput = os;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackLog::SetLogOutputFile(const char* fname)
 {
   cmGeneratedFileStream *cg = 0;
@@ -72,7 +68,6 @@ bool cmCPackLog::SetLogOutputFile(const char* fname)
   return true;
 }
 
-//----------------------------------------------------------------------
 void cmCPackLog::Log(int tag, const char* file, int line,
   const char* msg, size_t length)
 {

Source/CPack/cmCPackNSISGenerator.cxx

@@ -31,18 +31,15 @@
 # define NSIS_OPT "-"
 #endif
 
-//----------------------------------------------------------------------
 cmCPackNSISGenerator::cmCPackNSISGenerator(bool nsis64)
 {
   Nsis64 = nsis64;
 }
 
-//----------------------------------------------------------------------
 cmCPackNSISGenerator::~cmCPackNSISGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackNSISGenerator::PackageFiles()
 {
   // TODO: Fix nsis to force out file name
@@ -361,7 +358,6 @@ int cmCPackNSISGenerator::PackageFiles()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackNSISGenerator::InitializeInternal()
 {
   if ( cmSystemTools::IsOn(this->GetOption(
@@ -585,7 +581,6 @@ int cmCPackNSISGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 void cmCPackNSISGenerator::CreateMenuLinks( std::ostringstream& str,
                                             std::ostringstream& deleteStr)
 {
@@ -663,7 +658,6 @@ void cmCPackNSISGenerator::CreateMenuLinks( std::ostringstream& str,
     }
 }
 
-//----------------------------------------------------------------------
 bool cmCPackNSISGenerator::GetListOfSubdirectories(const char* topdir,
   std::vector<std::string>& dirs)
 {
@@ -692,26 +686,22 @@ bool cmCPackNSISGenerator::GetListOfSubdirectories(const char* topdir,
   return true;
 }
 
-//----------------------------------------------------------------------
 enum cmCPackGenerator::CPackSetDestdirSupport
 cmCPackNSISGenerator::SupportsSetDestdir() const
 {
   return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackNSISGenerator::SupportsAbsoluteDestination() const
 {
         return false;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackNSISGenerator::SupportsComponentInstallation() const
 {
         return true;
 }
 
-//----------------------------------------------------------------------
 std::string
 cmCPackNSISGenerator::
 CreateComponentDescription(cmCPackComponent *component,
@@ -946,7 +936,6 @@ CreateComponentDescription(cmCPackComponent *component,
   return componentCode;
 }
 
-//----------------------------------------------------------------------
 std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription
               (cmCPackComponent *component,
                std::set<cmCPackComponent *>& visited)
@@ -978,7 +967,6 @@ std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription
 }
 
 
-//----------------------------------------------------------------------
 std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription
               (cmCPackComponent *component,
                    std::set<cmCPackComponent *>& visited)
@@ -1011,7 +999,6 @@ std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription
   return out.str();
 }
 
-//----------------------------------------------------------------------
 std::string
 cmCPackNSISGenerator::
 CreateComponentGroupDescription(cmCPackComponentGroup *group,

Source/CPack/cmCPackOSXX11Generator.cxx

@@ -23,17 +23,14 @@
 #include <cmsys/SystemTools.hxx>
 #include <sys/stat.h>
 
-//----------------------------------------------------------------------
 cmCPackOSXX11Generator::cmCPackOSXX11Generator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackOSXX11Generator::~cmCPackOSXX11Generator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackOSXX11Generator::PackageFiles()
 {
   // TODO: Use toplevel ?
@@ -206,7 +203,6 @@ int cmCPackOSXX11Generator::PackageFiles()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackOSXX11Generator::InitializeInternal()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
@@ -225,7 +221,6 @@ int cmCPackOSXX11Generator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 /*
 bool cmCPackOSXX11Generator::CopyCreateResourceFile(const std::string& name)
 {
@@ -270,7 +265,6 @@ bool cmCPackOSXX11Generator::CopyCreateResourceFile(const std::string& name)
 }
 */
 
-//----------------------------------------------------------------------
 bool cmCPackOSXX11Generator::CopyResourcePlistFile(const std::string& name,
   const std::string& dir, const char* outputFileName /* = 0 */,
   bool copyOnly /* = false */)
@@ -301,7 +295,6 @@ bool cmCPackOSXX11Generator::CopyResourcePlistFile(const std::string& name,
   return true;
 }
 
-//----------------------------------------------------------------------
 const char* cmCPackOSXX11Generator::GetPackagingInstallPrefix()
 {
   this->InstallPrefix = "/";

Source/CPack/cmCPackPackageMakerGenerator.cxx

@@ -32,25 +32,21 @@ unsigned int getVersion(unsigned int major, unsigned int minor)
   return ((major & 0xFF) << 16 | minor);
 }
 
-//----------------------------------------------------------------------
 cmCPackPackageMakerGenerator::cmCPackPackageMakerGenerator()
 {
   this->PackageMakerVersion = 0.0;
   this->PackageCompatibilityVersion = getVersion(10, 4);
 }
 
-//----------------------------------------------------------------------
 cmCPackPackageMakerGenerator::~cmCPackPackageMakerGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 bool cmCPackPackageMakerGenerator::SupportsComponentInstallation() const
 {
   return this->PackageCompatibilityVersion >= getVersion(10, 4);
 }
 
-//----------------------------------------------------------------------
 int cmCPackPackageMakerGenerator::CopyInstallScript(const std::string& resdir,
                                                     const std::string& script,
                                                     const std::string& name)
@@ -67,7 +63,6 @@ int cmCPackPackageMakerGenerator::CopyInstallScript(const std::string& resdir,
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackPackageMakerGenerator::PackageFiles()
 {
   // TODO: Use toplevel
@@ -403,7 +398,6 @@ int cmCPackPackageMakerGenerator::PackageFiles()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCPackPackageMakerGenerator::InitializeInternal()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
@@ -567,7 +561,6 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 bool cmCPackPackageMakerGenerator::CopyCreateResourceFile(
                                             const std::string& name,
                                             const std::string& dirName)
@@ -646,7 +639,6 @@ bool cmCPackPackageMakerGenerator::CopyResourcePlistFile(
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCPackPackageMakerGenerator::RunPackageMaker(const char *command,
                                                    const char *packageFile)
 {
@@ -695,7 +687,6 @@ bool cmCPackPackageMakerGenerator::RunPackageMaker(const char *command,
   return true;
 }
 
-//----------------------------------------------------------------------
 std::string
 cmCPackPackageMakerGenerator::GetPackageName(const cmCPackComponent& component)
 {
@@ -714,7 +705,6 @@ cmCPackPackageMakerGenerator::GetPackageName(const cmCPackComponent& component)
     }
 }
 
-//----------------------------------------------------------------------
 bool
 cmCPackPackageMakerGenerator::
 GenerateComponentPackage(const char *packageFile,
@@ -797,7 +787,6 @@ GenerateComponentPackage(const char *packageFile,
   return RunPackageMaker(pkgCmd.str().c_str(), packageFile);
 }
 
-//----------------------------------------------------------------------
 void
 cmCPackPackageMakerGenerator::
 WriteDistributionFile(const char* metapackageFile)
@@ -875,7 +864,6 @@ WriteDistributionFile(const char* metapackageFile)
                       distributionFile.c_str());
 }
 
-//----------------------------------------------------------------------
 void
 cmCPackPackageMakerGenerator::
 CreateChoiceOutline(const cmCPackComponentGroup& group,
@@ -899,7 +887,6 @@ CreateChoiceOutline(const cmCPackComponentGroup& group,
   out << "</line>" << std::endl;
 }
 
-//----------------------------------------------------------------------
 void
 cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponentGroup& group,
                                            std::ostringstream& out)
@@ -917,7 +904,6 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponentGroup& group,
   out << "></choice>" << std::endl;
 }
 
-//----------------------------------------------------------------------
 void
 cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
                                            std::ostringstream& out)
@@ -1001,7 +987,6 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
   out << "</pkg-ref>" << std::endl;
 }
 
-//----------------------------------------------------------------------
 void
 cmCPackPackageMakerGenerator::
 AddDependencyAttributes(const cmCPackComponent& component,
@@ -1025,7 +1010,6 @@ AddDependencyAttributes(const cmCPackComponent& component,
     }
 }
 
-//----------------------------------------------------------------------
 void
 cmCPackPackageMakerGenerator::
 AddReverseDependencyAttributes(const cmCPackComponent& component,
@@ -1048,7 +1032,6 @@ AddReverseDependencyAttributes(const cmCPackComponent& component,
     }
 }
 
-//----------------------------------------------------------------------
 std::string cmCPackPackageMakerGenerator::EscapeForXML(std::string str)
 {
   cmSystemTools::ReplaceString(str, "&", "&amp;");

Source/CPack/cmCPackRPMGenerator.cxx

@@ -14,17 +14,14 @@
 #include "cmCPackLog.h"
 #include "cmSystemTools.h"
 
-//----------------------------------------------------------------------
 cmCPackRPMGenerator::cmCPackRPMGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackRPMGenerator::~cmCPackRPMGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackRPMGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
@@ -50,7 +47,6 @@ int cmCPackRPMGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
                                         std::string packageName)
 {
@@ -94,7 +90,6 @@ int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
 {
   int retval = 1;
@@ -147,7 +142,6 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackRPMGenerator::PackageComponentsAllInOne()
 {
   int retval = 1;
@@ -201,7 +195,6 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne()
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackRPMGenerator::PackageFiles()
 {
   int retval = 1;

Source/CPack/cmCPackSTGZGenerator.cxx

@@ -24,17 +24,14 @@
 // include sys/stat.h after sys/types.h
 #include <sys/stat.h>
 
-//----------------------------------------------------------------------
 cmCPackSTGZGenerator::cmCPackSTGZGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackSTGZGenerator::~cmCPackSTGZGenerator()
 {
 }
 
-//----------------------------------------------------------------------
 int cmCPackSTGZGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
@@ -52,7 +49,6 @@ int cmCPackSTGZGenerator::InitializeInternal()
   return this->Superclass::InitializeInternal();
 }
 
-//----------------------------------------------------------------------
 int cmCPackSTGZGenerator::PackageFiles()
 {
  bool retval = true;
@@ -81,7 +77,6 @@ int cmCPackSTGZGenerator::PackageFiles()
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Writing header" << std::endl);

Source/CPack/cmCPackTGZGenerator.cxx

@@ -12,14 +12,12 @@
 
 #include "cmCPackTGZGenerator.h"
 
-//----------------------------------------------------------------------
 cmCPackTGZGenerator::cmCPackTGZGenerator()
   :cmCPackArchiveGenerator(cmArchiveWrite::CompressGZip,
                            "paxr")
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackTGZGenerator::~cmCPackTGZGenerator()
 {
 }

Source/CPack/cmCPackTXZGenerator.cxx

@@ -12,14 +12,12 @@
 
 #include "cmCPackTXZGenerator.h"
 
-//----------------------------------------------------------------------
 cmCPackTXZGenerator::cmCPackTXZGenerator()
   :cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ,
                            "paxr")
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackTXZGenerator::~cmCPackTXZGenerator()
 {
 }

Source/CPack/cmCPackTarBZip2Generator.cxx

@@ -12,14 +12,12 @@
 
 #include "cmCPackTarBZip2Generator.h"
 
-//----------------------------------------------------------------------
 cmCPackTarBZip2Generator::cmCPackTarBZip2Generator()
  :cmCPackArchiveGenerator(cmArchiveWrite::CompressBZip2,
                           "paxr")
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackTarBZip2Generator::~cmCPackTarBZip2Generator()
 {
 }

Source/CPack/cmCPackTarCompressGenerator.cxx

@@ -12,14 +12,12 @@
 
 #include "cmCPackTarCompressGenerator.h"
 
-//----------------------------------------------------------------------
 cmCPackTarCompressGenerator::cmCPackTarCompressGenerator()
   :cmCPackArchiveGenerator(cmArchiveWrite::CompressCompress,
                            "paxr")
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackTarCompressGenerator::~cmCPackTarCompressGenerator()
 {
 }

Source/CPack/cmCPackZIPGenerator.cxx

@@ -12,14 +12,12 @@
 
 #include "cmCPackZIPGenerator.h"
 
-//----------------------------------------------------------------------
 cmCPackZIPGenerator::cmCPackZIPGenerator()
   :cmCPackArchiveGenerator(cmArchiveWrite::CompressNone,
                            "zip")
 {
 }
 
-//----------------------------------------------------------------------
 cmCPackZIPGenerator::~cmCPackZIPGenerator()
 {
 }

Source/CPack/cpack.cxx

@@ -26,7 +26,6 @@
 #include <cmsys/Encoding.hxx>
 #include <cmsys/SystemTools.hxx>
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationName[][2] =
 {
   {0,
@@ -34,7 +33,6 @@ static const char * cmDocumentationName[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationUsage[][2] =
 {
   {0,
@@ -42,7 +40,6 @@ static const char * cmDocumentationUsage[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationOptions[][2] =
 {
     {"-G <generator>", "Use the specified generator to generate package."},
@@ -58,13 +55,11 @@ static const char * cmDocumentationOptions[][2] =
     {0,0}
 };
 
-//----------------------------------------------------------------------------
 int cpackUnknownArgument(const char*, void*)
 {
   return 1;
 }
 
-//----------------------------------------------------------------------------
 struct cpackDefinitions
 {
   typedef std::map<std::string, std::string> MapType;
@@ -72,7 +67,6 @@ struct cpackDefinitions
   cmCPackLog *Log;
 };
 
-//----------------------------------------------------------------------------
 int cpackDefinitionArgument(const char* argument, const char* cValue,
   void* call_data)
 {
@@ -95,7 +89,6 @@ int cpackDefinitionArgument(const char* argument, const char* cValue,
 }
 
 
-//----------------------------------------------------------------------------
 // this is CPack.
 int main (int argc, char const* const* argv)
 {

Source/CTest/cmCTestBZR.cxx

@@ -19,7 +19,6 @@
 
 #include <cm_expat.h>
 
-//----------------------------------------------------------------------------
 extern "C"
 int cmBZRXMLParserUnknownEncodingHandler(void*,
                                          const XML_Char *name,
@@ -75,7 +74,6 @@ int cmBZRXMLParserUnknownEncodingHandler(void*,
   return 0;
 }
 
-//----------------------------------------------------------------------------
 cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
   cmCTestGlobalVC(ct, log)
 {
@@ -86,12 +84,10 @@ cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
   cmSystemTools::PutEnv("BZR_PROGRESS_BAR=none");
 }
 
-//----------------------------------------------------------------------------
 cmCTestBZR::~cmCTestBZR()
 {
 }
 
-//----------------------------------------------------------------------------
 class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
 {
 public:
@@ -122,7 +118,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
 {
 public:
@@ -145,7 +140,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 std::string cmCTestBZR::LoadInfo()
 {
   // Run "bzr info" to get the repository info from the work tree.
@@ -174,7 +168,6 @@ void cmCTestBZR::NoteOldRevision()
   this->PriorRev.Rev = this->OldRevision;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestBZR::NoteNewRevision()
 {
   this->NewRevision = this->LoadInfo();
@@ -184,7 +177,6 @@ void cmCTestBZR::NoteNewRevision()
   this->Log << "URL = " << this->URL << "\n";
 }
 
-//----------------------------------------------------------------------------
 class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
                              private cmXMLParser
 {
@@ -314,7 +306,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
 {
 public:
@@ -399,7 +390,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 bool cmCTestBZR::UpdateImpl()
 {
   // Get user-specified update options.
@@ -433,7 +423,6 @@ bool cmCTestBZR::UpdateImpl()
   return this->RunUpdateCommand(&bzr_update[0], &out, &err);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestBZR::LoadRevisions()
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
@@ -465,7 +454,6 @@ void cmCTestBZR::LoadRevisions()
   cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
 }
 
-//----------------------------------------------------------------------------
 class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
 {
 public:
@@ -510,7 +498,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 void cmCTestBZR::LoadModifications()
 {
   // Run "bzr status" which reports local modifications.

Source/CTest/cmCTestBatchTestHandler.cxx

@@ -22,14 +22,12 @@ cmCTestBatchTestHandler::~cmCTestBatchTestHandler()
 {
 }
 
-//---------------------------------------------------------
 void cmCTestBatchTestHandler::RunTests()
 {
   this->WriteBatchScript();
   this->SubmitBatchScript();
 }
 
-//---------------------------------------------------------
 void cmCTestBatchTestHandler::WriteBatchScript()
 {
   this->Script = this->CTest->GetBinaryDir()
@@ -48,7 +46,6 @@ void cmCTestBatchTestHandler::WriteBatchScript()
   fout.close();
 }
 
-//---------------------------------------------------------
 void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
 {
   cmCTestTestHandler::cmCTestTestProperties* properties =
@@ -79,7 +76,6 @@ void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
     }
 }
 
-//---------------------------------------------------------
 void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout)
 {
   std::vector<std::string> args = this->Properties[test]->Args;
@@ -121,7 +117,6 @@ void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout)
   //this->TestResult.FullCommandLine = this->TestCommand;
 }
 
-//---------------------------------------------------------
 void cmCTestBatchTestHandler::SubmitBatchScript()
 {
   cmProcess sbatch;

Source/CTest/cmCTestBuildAndTestHandler.cxx

@@ -19,7 +19,6 @@
 #include "cmake.h"
 #include <cmsys/Process.h>
 
-//----------------------------------------------------------------------
 cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
 {
   this->BuildTwoConfig         = false;
@@ -28,19 +27,16 @@ cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
   this->Timeout = 0;
 }
 
-//----------------------------------------------------------------------
 void cmCTestBuildAndTestHandler::Initialize()
 {
   this->BuildTargets.clear();
   this->Superclass::Initialize();
 }
 
-//----------------------------------------------------------------------
 const char* cmCTestBuildAndTestHandler::GetOutput()
 {
   return this->Output.c_str();
 }
-//----------------------------------------------------------------------
 int cmCTestBuildAndTestHandler::ProcessHandler()
 {
   this->Output = "";
@@ -51,7 +47,6 @@ int cmCTestBuildAndTestHandler::ProcessHandler()
   return retv;
 }
 
-//----------------------------------------------------------------------
 int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
   std::ostringstream &out, std::string &cmakeOutString, std::string &cwd,
   cmake *cm)
@@ -144,7 +139,6 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
   return 0;
 }
 
-//----------------------------------------------------------------------
 void CMakeMessageCallback(const char* m, const char*, bool&, void* s)
 {
   std::string* out = (std::string*)s;
@@ -159,14 +153,12 @@ void CMakeProgressCallback(const char*msg, float , void * s)
   *out += "\n";
 }
 
-//----------------------------------------------------------------------
 void CMakeOutputCallback(const char* m, size_t len, void* s)
 {
   std::string* out = (std::string*)s;
   out->append(m, len);
 }
 
-//----------------------------------------------------------------------
 class cmCTestBuildAndTestCaptureRAII
 {
   cmake& CM;
@@ -187,7 +179,6 @@ public:
     }
 };
 
-//----------------------------------------------------------------------
 int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 {
   // if the generator and make program are not specified then it is an error
@@ -436,7 +427,6 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   return retval;
 }
 
-//----------------------------------------------------------------------
 int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
   const std::string& currentArg, size_t& idx,
   const std::vector<std::string>& allArgs)

Source/CTest/cmCTestBuildCommand.cxx

@@ -18,7 +18,6 @@
 #include "cmake.h"
 
 
-//----------------------------------------------------------------------------
 cmCTestBuildCommand::cmCTestBuildCommand()
 {
   this->GlobalGenerator = 0;
@@ -32,7 +31,6 @@ cmCTestBuildCommand::cmCTestBuildCommand()
   this->Last = ctb_LAST;
 }
 
-//----------------------------------------------------------------------------
 cmCTestBuildCommand::~cmCTestBuildCommand()
 {
   if ( this->GlobalGenerator )
@@ -42,7 +40,6 @@ cmCTestBuildCommand::~cmCTestBuildCommand()
     }
 }
 
-//----------------------------------------------------------------------------
 cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
 {
   cmCTestGenericHandler* handler

Source/CTest/cmCTestBuildHandler.cxx

@@ -174,7 +174,6 @@ cmCTestWarningErrorFileLine[] = {
     { 0, 0, 0 }
 };
 
-//----------------------------------------------------------------------
 cmCTestBuildHandler::cmCTestBuildHandler()
 {
   this->MaxPreContext = 10;
@@ -188,7 +187,6 @@ cmCTestBuildHandler::cmCTestBuildHandler()
   this->UseCTestLaunch = false;
 }
 
-//----------------------------------------------------------------------
 void cmCTestBuildHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -234,7 +232,6 @@ void cmCTestBuildHandler::Initialize()
   this->UseCTestLaunch = false;
 }
 
-//----------------------------------------------------------------------
 void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",
@@ -281,7 +278,6 @@ void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
     }
 }
 
-//----------------------------------------------------------------------
 std::string cmCTestBuildHandler::GetMakeCommand()
 {
   std::string makeCommand
@@ -307,7 +303,6 @@ std::string cmCTestBuildHandler::GetMakeCommand()
   return makeCommand;
 }
 
-//----------------------------------------------------------------------
 //clearly it would be nice if this were broken up into a few smaller
 //functions and commented...
 int cmCTestBuildHandler::ProcessHandler()
@@ -551,7 +546,6 @@ int cmCTestBuildHandler::ProcessHandler()
   return retVal;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestBuildHandler::GenerateXMLHeader(cmXMLWriter& xml)
 {
   this->CTest->StartXML(xml, this->AppendXML);
@@ -562,7 +556,6 @@ void cmCTestBuildHandler::GenerateXMLHeader(cmXMLWriter& xml)
   xml.Element("BuildCommand", this->GetMakeCommand());
 }
 
-//----------------------------------------------------------------------------
 class cmCTestBuildHandler::FragmentCompare
 {
 public:
@@ -587,7 +580,6 @@ private:
   cmFileTimeComparison* FTC;
 };
 
-//----------------------------------------------------------------------------
 void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml)
 {
   if(this->CTestLaunchDir.empty())
@@ -633,7 +625,6 @@ void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml)
 {
   std::vector<cmCTestBuildErrorWarning>& ew = this->ErrorsAndWarnings;
@@ -730,7 +721,6 @@ void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestBuildHandler::GenerateXMLFooter(cmXMLWriter& xml,
                                             double elapsed_build_time)
 {
@@ -746,7 +736,6 @@ void cmCTestBuildHandler::GenerateXMLFooter(cmXMLWriter& xml,
   this->CTest->EndXML(xml);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname)
 {
   // error-{hash}.xml
@@ -754,7 +743,6 @@ bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname)
           strcmp(fname+strlen(fname)-4, ".xml") == 0);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname)
 {
   // warning-{hash}.xml
@@ -767,7 +755,6 @@ bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname)
 //######################################################################
 //######################################################################
 
-//----------------------------------------------------------------------------
 class cmCTestBuildHandler::LaunchHelper
 {
 public:
@@ -782,7 +769,6 @@ private:
                            std::vector<std::string> const& matchers);
 };
 
-//----------------------------------------------------------------------------
 cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler):
   Handler(handler), CTest(handler->CTest)
 {
@@ -823,7 +809,6 @@ cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler):
     }
 }
 
-//----------------------------------------------------------------------------
 cmCTestBuildHandler::LaunchHelper::~LaunchHelper()
 {
   if(this->Handler->UseCTestLaunch)
@@ -832,7 +817,6 @@ cmCTestBuildHandler::LaunchHelper::~LaunchHelper()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig()
 {
   this->WriteScrapeMatchers("Warning",
@@ -848,7 +832,6 @@ void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig()
   fout << "set(CTEST_SOURCE_DIRECTORY \"" << srcdir << "\")\n";
 }
 
-//----------------------------------------------------------------------------
 void
 cmCTestBuildHandler::LaunchHelper
 ::WriteScrapeMatchers(const char* purpose,
@@ -870,7 +853,6 @@ cmCTestBuildHandler::LaunchHelper
     }
 }
 
-//----------------------------------------------------------------------
 int cmCTestBuildHandler::RunMakeCommand(const char* command,
   int* retVal, const char* dir, int timeout, std::ostream& ofs)
 {
@@ -1039,7 +1021,6 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
 //######################################################################
 //######################################################################
 
-//----------------------------------------------------------------------
 void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
   size_t& tick, size_t tick_len, std::ostream& ofs,
   t_BuildProcessingQueueType* queue)
@@ -1197,7 +1178,6 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
   ofs << cmCTestLogWrite(data, length);
 }
 
-//----------------------------------------------------------------------
 int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 {
   if(this->UseCTestLaunch)

Source/CTest/cmCTestCVS.cxx

@@ -18,17 +18,14 @@
 #include <cmsys/FStream.hxx>
 #include <cmsys/RegularExpression.hxx>
 
-//----------------------------------------------------------------------------
 cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log): cmCTestVC(ct, log)
 {
 }
 
-//----------------------------------------------------------------------------
 cmCTestCVS::~cmCTestCVS()
 {
 }
 
-//----------------------------------------------------------------------------
 class cmCTestCVS::UpdateParser: public cmCTestVC::LineParser
 {
 public:
@@ -86,7 +83,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 bool cmCTestCVS::UpdateImpl()
 {
   // Get user-specified update options.
@@ -124,7 +120,6 @@ bool cmCTestCVS::UpdateImpl()
   return this->RunUpdateCommand(&cvs_update[0], &out, &err);
 }
 
-//----------------------------------------------------------------------------
 class cmCTestCVS::LogParser: public cmCTestVC::LineParser
 {
 public:
@@ -220,7 +215,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir)
 {
   // Compute the tag file location for this directory.
@@ -250,7 +244,6 @@ std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestCVS::LoadRevisions(std::string const& file,
                                const char* branchFlag,
                                std::vector<Revision>& revisions)
@@ -267,7 +260,6 @@ void cmCTestCVS::LoadRevisions(std::string const& file,
   this->RunChild(cvs_log, &out, &err);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml,
                                    std::string const& path,
                                    Directory const& dir)
@@ -303,7 +295,6 @@ void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml,
   xml.EndElement(); // Directory
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestCVS::WriteXMLUpdates(cmXMLWriter& xml)
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,

Source/CTest/cmCTestConfigureHandler.cxx

@@ -19,18 +19,15 @@
 #include <cmsys/Process.h>
 
 
-//----------------------------------------------------------------------
 cmCTestConfigureHandler::cmCTestConfigureHandler()
 {
 }
 
-//----------------------------------------------------------------------
 void cmCTestConfigureHandler::Initialize()
 {
   this->Superclass::Initialize();
 }
 
-//----------------------------------------------------------------------
 //clearly it would be nice if this were broken up into a few smaller
 //functions and commented...
 int cmCTestConfigureHandler::ProcessHandler()

Source/CTest/cmCTestCoverageCommand.cxx

@@ -14,13 +14,11 @@
 #include "cmCTest.h"
 #include "cmCTestCoverageHandler.h"
 
-//----------------------------------------------------------------------------
 cmCTestCoverageCommand::cmCTestCoverageCommand()
 {
   this->LabelsMentioned = false;
 }
 
-//----------------------------------------------------------------------------
 cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
 {
   this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
@@ -45,7 +43,6 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
   return handler;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
 {
   // Look for arguments specific to this command.
@@ -60,7 +57,6 @@ bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
   return this->Superclass::CheckArgumentKeyword(arg);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestCoverageCommand::CheckArgumentValue(std::string const& arg)
 {
   // Handle states specific to this command.

Source/CTest/cmCTestCoverageHandler.cxx

@@ -132,14 +132,11 @@ private:
 };
 
 
-//----------------------------------------------------------------------
 
-//----------------------------------------------------------------------
 cmCTestCoverageHandler::cmCTestCoverageHandler()
 {
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -151,7 +148,6 @@ void cmCTestCoverageHandler::Initialize()
   this->LabelFilter.clear();
 }
 
-//----------------------------------------------------------------------------
 void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log)
 {
   std::string logGlob = this->CTest->GetCTestConfiguration("BuildDirectory");
@@ -169,7 +165,6 @@ void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log)
     }
 }
 
-//----------------------------------------------------------------------
 bool cmCTestCoverageHandler::StartCoverageLogFile(
   cmGeneratedFileStream& covLogFile, int logFileCount)
 {
@@ -187,7 +182,6 @@ bool cmCTestCoverageHandler::StartCoverageLogFile(
   return true;
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
   int logFileCount)
 {
@@ -198,7 +192,6 @@ void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
   ostr.Close();
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml)
 {
   this->CTest->StartXML(xml, this->AppendXML);
@@ -208,7 +201,6 @@ void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml)
     static_cast<unsigned int>(cmSystemTools::GetTime()));
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
 {
   xml.Element("EndDateTime", this->CTest->CurrentTime());
@@ -217,7 +209,6 @@ void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
   this->CTest->EndXML(xml);
 }
 
-//----------------------------------------------------------------------
 bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
   const char* srcDir,
   const char* binDir)
@@ -322,7 +313,6 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
   return true;
 }
 
-//----------------------------------------------------------------------
 //clearly it would be nice if this were broken up into a few smaller
 //functions and commented...
 int cmCTestCoverageHandler::ProcessHandler()
@@ -747,7 +737,6 @@ int cmCTestCoverageHandler::ProcessHandler()
   return 0;
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
@@ -772,7 +761,6 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
     }
 }
 
-//----------------------------------------------------------------------
 // Fix for issue #4971 where the case of the drive letter component of
 // the filenames might be different when analyzing gcov output.
 //
@@ -784,7 +772,6 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
 #define fnc(s) s
 #endif
 
-//----------------------------------------------------------------------
 bool IsFileInDir(const std::string &infile, const std::string &indir)
 {
   std::string file = cmSystemTools::CollapseFullPath(infile);
@@ -802,7 +789,6 @@ bool IsFileInDir(const std::string &infile, const std::string &indir)
   return false;
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandlePHPCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -815,7 +801,6 @@ int cmCTestCoverageHandler::HandlePHPCoverage(
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleCoberturaCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -855,7 +840,6 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage(
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleMumpsCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -923,7 +907,6 @@ struct cmCTestCoverageHandlerLocale
   std::string lc_all;
 };
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleJacocoCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -971,7 +954,6 @@ int cmCTestCoverageHandler::HandleJacocoCoverage(
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleDelphiCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -1005,7 +987,6 @@ int cmCTestCoverageHandler::HandleDelphiCoverage(
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleBlanketJSCoverage(
   cmCTestCoverageHandlerContainer* cont)
   {
@@ -1051,7 +1032,6 @@ int cmCTestCoverageHandler::HandleBlanketJSCoverage(
     }
   return static_cast<int>(cont->TotalCoverage.size());
   }
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleGCovCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -1493,7 +1473,6 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   return file_count;
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleLCovCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -1765,7 +1744,6 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
   return file_count;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
 {
   cmsys::Glob gl;
@@ -1796,7 +1774,6 @@ void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
 {
   cmsys::Glob gl;
@@ -1840,7 +1817,6 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
   return true;
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleTracePyCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -1974,7 +1950,6 @@ int cmCTestCoverageHandler::HandleTracePyCoverage(
   return file_count;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTestCoverageHandler::FindFile(
   cmCTestCoverageHandlerContainer* cont,
   std::string fileName)
@@ -2014,7 +1989,6 @@ namespace
    0};
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
   cmCTestCoverageHandlerContainer* cont,
   std::set<std::string>& coveredFileNames,
@@ -2163,7 +2137,6 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::RunBullseyeCommand(
   cmCTestCoverageHandlerContainer* cont,
   const char* cmd,
@@ -2213,7 +2186,6 @@ int cmCTestCoverageHandler::RunBullseyeCommand(
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::RunBullseyeSourceSummary(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -2390,7 +2362,6 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
                                          coveredFilesFullPath);
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::HandleBullseyeCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
@@ -2487,7 +2458,6 @@ bool cmCTestCoverageHandler::ParseBullsEyeCovsrcLine(
   return true;
 }
 
-//----------------------------------------------------------------------
 int cmCTestCoverageHandler::GetLabelId(std::string const& label)
 {
   LabelIdMapType::iterator i = this->LabelIdMap.find(label);
@@ -2501,7 +2471,6 @@ int cmCTestCoverageHandler::GetLabelId(std::string const& label)
   return i->second;
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::LoadLabels()
 {
   std::string fileList = this->CTest->GetBinaryDir();
@@ -2517,7 +2486,6 @@ void cmCTestCoverageHandler::LoadLabels()
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::LoadLabels(const char* dir)
 {
   LabelSet& dirLabels = this->TargetDirs[dir];
@@ -2572,7 +2540,6 @@ void cmCTestCoverageHandler::LoadLabels(const char* dir)
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml,
                                             std::string const& source)
 {
@@ -2589,7 +2556,6 @@ void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml,
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels)
 {
@@ -2601,7 +2567,6 @@ cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels)
     }
 }
 
-//----------------------------------------------------------------------
 bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels)
 {
   // If there is no label filter then nothing is filtered out.
@@ -2618,7 +2583,6 @@ bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels)
   return !ids.empty();
 }
 
-//----------------------------------------------------------------------
 bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source)
 {
   // If there is no label filter then nothing is filtered out.
@@ -2638,7 +2602,6 @@ bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source)
   return true;
 }
 
-//----------------------------------------------------------------------
 std::set<std::string> cmCTestCoverageHandler::FindUncoveredFiles(
   cmCTestCoverageHandlerContainer* cont)
 {

Source/CTest/cmCTestGIT.cxx

@@ -23,7 +23,6 @@
 #include <sys/types.h>
 #include <time.h>
 
-//----------------------------------------------------------------------------
 static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major,
                                       unsigned int minor, unsigned int fix)
 {
@@ -31,7 +30,6 @@ static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major,
   return fix + minor*1000 + major*100000 + epic*10000000;
 }
 
-//----------------------------------------------------------------------------
 cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log):
   cmCTestGlobalVC(ct, log)
 {
@@ -39,12 +37,10 @@ cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log):
   this->CurrentGitVersion = 0;
 }
 
-//----------------------------------------------------------------------------
 cmCTestGIT::~cmCTestGIT()
 {
 }
 
-//----------------------------------------------------------------------------
 class cmCTestGIT::OneLineParser: public cmCTestVC::LineParser
 {
 public:
@@ -63,7 +59,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 std::string cmCTestGIT::GetWorkingRevision()
 {
   // Run plumbing "git rev-list" to get work tree revision.
@@ -76,7 +71,6 @@ std::string cmCTestGIT::GetWorkingRevision()
   return rev;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGIT::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
@@ -85,7 +79,6 @@ void cmCTestGIT::NoteOldRevision()
   this->PriorRev.Rev = this->OldRevision;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGIT::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
@@ -93,7 +86,6 @@ void cmCTestGIT::NoteNewRevision()
              << this->NewRevision << "\n");
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestGIT::FindGitDir()
 {
   std::string git_dir;
@@ -141,7 +133,6 @@ std::string cmCTestGIT::FindGitDir()
   return git_dir;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestGIT::FindTopDir()
 {
   std::string top_dir = this->SourceDirectory;
@@ -162,7 +153,6 @@ std::string cmCTestGIT::FindTopDir()
   return top_dir;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestGIT::UpdateByFetchAndReset()
 {
   const char* git = this->CommandLineTool.c_str();
@@ -233,7 +223,6 @@ bool cmCTestGIT::UpdateByFetchAndReset()
   return this->RunChild(&git_reset[0], &reset_out, &reset_err);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestGIT::UpdateByCustom(std::string const& custom)
 {
   std::vector<std::string> git_custom_command;
@@ -251,7 +240,6 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom)
   return this->RunUpdateCommand(&git_custom[0], &custom_out, &custom_err);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestGIT::UpdateInternal()
 {
   std::string custom = this->CTest->GetCTestConfiguration("GITUpdateCustom");
@@ -262,7 +250,6 @@ bool cmCTestGIT::UpdateInternal()
   return this->UpdateByFetchAndReset();
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestGIT::UpdateImpl()
 {
   if(!this->UpdateInternal())
@@ -331,7 +318,6 @@ bool cmCTestGIT::UpdateImpl()
                         top_dir.c_str());
 }
 
-//----------------------------------------------------------------------------
 unsigned int cmCTestGIT::GetGitVersion()
 {
   if(!this->CurrentGitVersion)
@@ -352,7 +338,6 @@ unsigned int cmCTestGIT::GetGitVersion()
   return this->CurrentGitVersion;
 }
 
-//----------------------------------------------------------------------------
 /* Diff format:
 
    :src-mode dst-mode src-sha1 dst-sha1 status\0
@@ -470,7 +455,6 @@ protected:
     }
 };
 
-//----------------------------------------------------------------------------
 /* Commit format:
 
    commit ...\n
@@ -637,7 +621,6 @@ private:
 char const cmCTestGIT::CommitParser::SectionSep[SectionCount] =
 {'\n', '\n', '\0'};
 
-//----------------------------------------------------------------------------
 void cmCTestGIT::LoadRevisions()
 {
   // Use 'git rev-list ... | git diff-tree ...' to get revisions.
@@ -666,7 +649,6 @@ void cmCTestGIT::LoadRevisions()
   cmsysProcess_Delete(cp);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGIT::LoadModifications()
 {
   const char* git = this->CommandLineTool.c_str();

Source/CTest/cmCTestGenericHandler.cxx

@@ -16,7 +16,6 @@
 
 #include "cmCTest.h"
 
-//----------------------------------------------------------------------
 cmCTestGenericHandler::cmCTestGenericHandler()
 {
   this->HandlerVerbose = cmSystemTools::OUTPUT_NONE;
@@ -27,12 +26,10 @@ cmCTestGenericHandler::cmCTestGenericHandler()
   this->TestLoad = 0;
 }
 
-//----------------------------------------------------------------------
 cmCTestGenericHandler::~cmCTestGenericHandler()
 {
 }
 
-//----------------------------------------------------------------------
 void cmCTestGenericHandler::SetOption(const std::string& op, const char* value)
 {
   if ( !value )
@@ -49,7 +46,6 @@ void cmCTestGenericHandler::SetOption(const std::string& op, const char* value)
   this->Options[op] = value;
 }
 
-//----------------------------------------------------------------------
 void cmCTestGenericHandler::SetPersistentOption(const std::string& op,
                                                 const char* value)
 {
@@ -68,7 +64,6 @@ void cmCTestGenericHandler::SetPersistentOption(const std::string& op,
   this->PersistentOptions[op] = value;
 }
 
-//----------------------------------------------------------------------
 void cmCTestGenericHandler::Initialize()
 {
   this->AppendXML = false;
@@ -83,7 +78,6 @@ void cmCTestGenericHandler::Initialize()
     }
 }
 
-//----------------------------------------------------------------------
 const char* cmCTestGenericHandler::GetOption(const std::string& op)
 {
   cmCTestGenericHandler::t_StringToString::iterator remit
@@ -95,7 +89,6 @@ const char* cmCTestGenericHandler::GetOption(const std::string& op)
   return remit->second.c_str();
 }
 
-//----------------------------------------------------------------------
 bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part,
                                               const char* name,
                                               cmGeneratedFileStream& xofs)
@@ -136,7 +129,6 @@ bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part,
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTestGenericHandler::StartLogFile(const char* name,
   cmGeneratedFileStream& xofs)
 {

Source/CTest/cmCTestGlobalVC.cxx

@@ -17,25 +17,21 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-//----------------------------------------------------------------------------
 cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log):
   cmCTestVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
 
-//----------------------------------------------------------------------------
 cmCTestGlobalVC::~cmCTestGlobalVC()
 {
 }
 
-//----------------------------------------------------------------------------
 const char* cmCTestGlobalVC::LocalPath(std::string const& path)
 {
   return path.c_str();
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGlobalVC::DoRevision(Revision const& revision,
                                  std::vector<Change> const& changes)
 {
@@ -76,7 +72,6 @@ void cmCTestGlobalVC::DoRevision(Revision const& revision,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGlobalVC::DoModification(PathStatus status,
                                      std::string const& path)
 {
@@ -92,7 +87,6 @@ void cmCTestGlobalVC::DoModification(PathStatus status,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGlobalVC::WriteXMLDirectory(cmXMLWriter& xml,
                                         std::string const& path,
                                         Directory const& dir)
@@ -108,7 +102,6 @@ void cmCTestGlobalVC::WriteXMLDirectory(cmXMLWriter& xml,
   xml.EndElement(); // Directory
 }
 
-//----------------------------------------------------------------------------
 void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml)
 {
   if(!this->NewRevision.empty())
@@ -121,7 +114,6 @@ void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestGlobalVC::WriteXMLUpdates(cmXMLWriter& xml)
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,

Source/CTest/cmCTestHG.cxx

@@ -17,19 +17,16 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-//----------------------------------------------------------------------------
 cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log):
   cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
 
-//----------------------------------------------------------------------------
 cmCTestHG::~cmCTestHG()
 {
 }
 
-//----------------------------------------------------------------------------
 class cmCTestHG::IdentifyParser: public cmCTestVC::LineParser
 {
 public:
@@ -54,7 +51,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 class cmCTestHG::StatusParser: public cmCTestVC::LineParser
 {
 public:
@@ -94,7 +90,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 std::string cmCTestHG::GetWorkingRevision()
 {
   // Run plumbing "hg identify" to get work tree revision.
@@ -107,7 +102,6 @@ std::string cmCTestHG::GetWorkingRevision()
   return rev;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestHG::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
@@ -116,7 +110,6 @@ void cmCTestHG::NoteOldRevision()
   this->PriorRev.Rev = this->OldRevision;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestHG::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
@@ -124,7 +117,6 @@ void cmCTestHG::NoteNewRevision()
              << this->NewRevision << "\n");
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestHG::UpdateImpl()
 {
   // Use "hg pull" followed by "hg update" to update the working tree.
@@ -164,7 +156,6 @@ bool cmCTestHG::UpdateImpl()
   return this->RunUpdateCommand(&hg_update[0], &out, &err);
 }
 
-//----------------------------------------------------------------------------
 class cmCTestHG::LogParser: public cmCTestVC::OutputLogger,
                             private cmXMLParser
 {
@@ -293,7 +284,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 void cmCTestHG::LoadRevisions()
 {
   // Use 'hg log' to get revisions in a xml format.
@@ -326,7 +316,6 @@ void cmCTestHG::LoadRevisions()
   out.Process("</log>\n");
 }
 
-//----------------------------------------------------------------------------
 void cmCTestHG::LoadModifications()
 {
   // Use 'hg status' to get modified files.

Source/CTest/cmCTestHandlerCommand.cxx

@@ -158,7 +158,6 @@ bool cmCTestHandlerCommand
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestHandlerCommand::CheckArgumentKeyword(std::string const& arg)
 {
   // Look for non-value arguments common to all commands.
@@ -188,7 +187,6 @@ bool cmCTestHandlerCommand::CheckArgumentKeyword(std::string const& arg)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestHandlerCommand::CheckArgumentValue(std::string const& arg)
 {
   if(this->ArgumentDoing == ArgumentDoingKeyword)

Source/CTest/cmCTestLaunch.cxx

@@ -27,7 +27,6 @@
 #include <stdio.h> // for std{out,err} and fileno
 #endif
 
-//----------------------------------------------------------------------------
 cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
 {
   this->Passthru = true;
@@ -48,7 +47,6 @@ cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
   this->Process = cmsysProcess_New();
 }
 
-//----------------------------------------------------------------------------
 cmCTestLaunch::~cmCTestLaunch()
 {
   cmsysProcess_Delete(this->Process);
@@ -59,7 +57,6 @@ cmCTestLaunch::~cmCTestLaunch()
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv)
 {
   // Launcher options occur first and are separated from the real
@@ -171,7 +168,6 @@ bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::HandleRealArg(const char* arg)
 {
 #ifdef _WIN32
@@ -190,7 +186,6 @@ void cmCTestLaunch::HandleRealArg(const char* arg)
   this->RealArgs.push_back(arg);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::ComputeFileNames()
 {
   // We just passthru the behavior of the real command unless the
@@ -234,7 +229,6 @@ void cmCTestLaunch::ComputeFileNames()
   this->LogErr += "-err.txt";
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::RunChild()
 {
   // Ignore noopt make rules
@@ -302,7 +296,6 @@ void cmCTestLaunch::RunChild()
   this->ExitCode = cmsysProcess_GetExitValue(cp);
 }
 
-//----------------------------------------------------------------------------
 int cmCTestLaunch::Run()
 {
   if(!this->Process)
@@ -324,7 +317,6 @@ int cmCTestLaunch::Run()
   return this->ExitCode;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::LoadLabels()
 {
   if(this->OptionBuildDir.empty() || this->OptionTargetName.empty())
@@ -379,7 +371,6 @@ void cmCTestLaunch::LoadLabels()
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::SourceMatches(std::string const& lhs,
                                   std::string const& rhs)
 {
@@ -390,13 +381,11 @@ bool cmCTestLaunch::SourceMatches(std::string const& lhs,
   return lhs == rhs;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::IsError() const
 {
   return this->ExitCode != 0;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::WriteXML()
 {
   // Name the xml file.
@@ -417,7 +406,6 @@ void cmCTestLaunch::WriteXML()
   xml.EndElement(); // Failure
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
 {
   xml.Comment("Meta-information about the build action");
@@ -493,7 +481,6 @@ void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
   xml.EndElement(); // Action
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml)
 {
   xml.Comment("Details of command");
@@ -510,7 +497,6 @@ void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml)
   xml.EndElement(); // Command
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml)
 {
   xml.Comment("Result of command");
@@ -556,7 +542,6 @@ void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml)
   xml.EndElement(); // Result
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml)
 {
   this->LoadLabels();
@@ -573,7 +558,6 @@ void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml,
                                   std::string const& fname)
 {
@@ -595,7 +579,6 @@ void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml,
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::CheckResults()
 {
   // Skip XML in passthru mode.
@@ -619,7 +602,6 @@ bool cmCTestLaunch::CheckResults()
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestLaunch::LoadScrapeRules()
 {
   if(this->ScrapeRulesLoaded)
@@ -640,7 +622,6 @@ void cmCTestLaunch::LoadScrapeRules()
   this->LoadScrapeRules("WarningSuppress", this->RegexWarningSuppress);
 }
 
-//----------------------------------------------------------------------------
 void
 cmCTestLaunch
 ::LoadScrapeRules(const char* purpose,
@@ -662,7 +643,6 @@ cmCTestLaunch
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::ScrapeLog(std::string const& fname)
 {
   this->LoadScrapeRules();
@@ -687,7 +667,6 @@ bool cmCTestLaunch::ScrapeLog(std::string const& fname)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::Match(std::string const& line,
                           std::vector<cmsys::RegularExpression>& regexps)
 {
@@ -702,7 +681,6 @@ bool cmCTestLaunch::Match(std::string const& line,
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const
 {
   if(!this->OptionFilterPrefix.empty() && cmSystemTools::StringStartsWith(
@@ -713,7 +691,6 @@ bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const
   return false;
 }
 
-//----------------------------------------------------------------------------
 int cmCTestLaunch::Main(int argc, const char* const argv[])
 {
   if(argc == 2)
@@ -726,7 +703,6 @@ int cmCTestLaunch::Main(int argc, const char* const argv[])
   return self.Run();
 }
 
-//----------------------------------------------------------------------------
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
 #include "cmake.h"

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -141,7 +141,6 @@ public:
 
 
 
-//----------------------------------------------------------------------
 cmCTestMemCheckHandler::cmCTestMemCheckHandler()
 {
   this->MemCheck = true;
@@ -150,7 +149,6 @@ cmCTestMemCheckHandler::cmCTestMemCheckHandler()
   this->LogWithPID = false;
 }
 
-//----------------------------------------------------------------------
 void cmCTestMemCheckHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -164,7 +162,6 @@ void cmCTestMemCheckHandler::Initialize()
   this->MemoryTesterOutputFile = "";
 }
 
-//----------------------------------------------------------------------
 int cmCTestMemCheckHandler::PreProcessHandler()
 {
   if ( !this->InitializeMemoryChecking() )
@@ -181,7 +178,6 @@ int cmCTestMemCheckHandler::PreProcessHandler()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCTestMemCheckHandler::PostProcessHandler()
 {
   if ( !this->ExecuteCommands(this->CustomPostMemCheck) )
@@ -193,7 +189,6 @@ int cmCTestMemCheckHandler::PostProcessHandler()
   return 1;
 }
 
-//----------------------------------------------------------------------
 void cmCTestMemCheckHandler::GenerateTestCommand(
   std::vector<std::string>& args, int test)
 {
@@ -256,7 +251,6 @@ void cmCTestMemCheckHandler::GenerateTestCommand(
     "Memory check command: " << memcheckcommand << std::endl, this->Quiet);
 }
 
-//----------------------------------------------------------------------
 void cmCTestMemCheckHandler::InitializeResultsVectors()
 {
   // fill these members
@@ -300,7 +294,6 @@ void cmCTestMemCheckHandler::InitializeResultsVectors()
     "UMR",
     0
   };
-//----------------------------------------------------------------------
   static const char* cmCTestMemCheckResultLongStrings[] = {
     "Threading Problem",
     "ABW",
@@ -335,7 +328,6 @@ void cmCTestMemCheckHandler::InitializeResultsVectors()
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   this->cmCTestTestHandler::PopulateCustomVectors(mf);
@@ -352,7 +344,6 @@ void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf)
     this->Quiet);
 }
 
-//----------------------------------------------------------------------
 void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml)
 {
   if ( !this->CTest->GetProduceXML() )
@@ -483,7 +474,6 @@ void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml)
   this->CTest->EndXML(xml);
 }
 
-//----------------------------------------------------------------------
 bool cmCTestMemCheckHandler::InitializeMemoryChecking()
 {
   this->MemoryTesterEnvironmentVariable = "";
@@ -747,7 +737,6 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTestMemCheckHandler::
 ProcessMemCheckOutput(const std::string& str,
                       std::string& log, std::vector<int>& results)
@@ -801,7 +790,6 @@ std::vector<int>::size_type cmCTestMemCheckHandler::FindOrAddWarning(
   this->ResultStringsLong.push_back(warning);
   return this->ResultStrings.size()-1;
 }
-//----------------------------------------------------------------------
 bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
   const std::string& str, std::string& log,
   std::vector<int>& result)
@@ -866,7 +854,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
     }
   return true;
 }
-//----------------------------------------------------------------------
 bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
   const std::string& str, std::string& log,
   std::vector<int>& results)
@@ -920,7 +907,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
   const std::string& str, std::string& log,
   std::vector<int>& results)
@@ -1095,7 +1081,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
 
 
 
-//----------------------------------------------------------------------
 bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput(
   const std::string& str, std::string& log,
   std::vector<int>& results)

Source/CTest/cmCTestMultiProcessHandler.cxx

@@ -94,7 +94,6 @@ void cmCTestMultiProcessHandler::SetTestLoad(unsigned long load)
   this->TestLoad = load;
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::RunTests()
 {
   this->CheckResume();
@@ -121,7 +120,6 @@ void cmCTestMultiProcessHandler::RunTests()
   this->UpdateCostData();
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::StartTestProcess(int test)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
@@ -177,7 +175,6 @@ void cmCTestMultiProcessHandler::StartTestProcess(int test)
   cmSystemTools::ChangeDirectory(current_dir);
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::LockResources(int index)
 {
   this->LockedResources.insert(
@@ -190,7 +187,6 @@ void cmCTestMultiProcessHandler::LockResources(int index)
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::UnlockResources(int index)
 {
   for(std::set<std::string>::iterator i =
@@ -205,7 +201,6 @@ void cmCTestMultiProcessHandler::UnlockResources(int index)
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::EraseTest(int test)
 {
   this->Tests.erase(test);
@@ -213,7 +208,6 @@ void cmCTestMultiProcessHandler::EraseTest(int test)
     std::find(this->SortedTests.begin(), this->SortedTests.end(), test));
 }
 
-//---------------------------------------------------------
 inline size_t cmCTestMultiProcessHandler::GetProcessorsUsed(int test)
 {
   size_t processors =
@@ -232,7 +226,6 @@ std::string cmCTestMultiProcessHandler::GetName(int test)
   return this->Properties[test]->Name;
 }
 
-//---------------------------------------------------------
 bool cmCTestMultiProcessHandler::StartTest(int test)
 {
   //Check for locked resources
@@ -257,7 +250,6 @@ bool cmCTestMultiProcessHandler::StartTest(int test)
   return false;
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::StartNextTests()
 {
   size_t numToStart = 0;
@@ -407,7 +399,6 @@ void cmCTestMultiProcessHandler::StartNextTests()
     }
 }
 
-//---------------------------------------------------------
 bool cmCTestMultiProcessHandler::CheckOutput()
 {
   // no more output we are done
@@ -463,7 +454,6 @@ bool cmCTestMultiProcessHandler::CheckOutput()
   return true;
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::UpdateCostData()
 {
   std::string fname = this->CTest->GetCostDataFile();
@@ -527,7 +517,6 @@ void cmCTestMultiProcessHandler::UpdateCostData()
   cmSystemTools::RenameFile(tmpout.c_str(), fname.c_str());
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::ReadCostData()
 {
   std::string fname = this->CTest->GetCostDataFile();
@@ -579,7 +568,6 @@ void cmCTestMultiProcessHandler::ReadCostData()
     }
 }
 
-//---------------------------------------------------------
 int cmCTestMultiProcessHandler::SearchByName(std::string name)
 {
   int index = -1;
@@ -595,7 +583,6 @@ int cmCTestMultiProcessHandler::SearchByName(std::string name)
   return index;
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::CreateTestCostList()
 {
   if(this->ParallelLevel > 1)
@@ -608,7 +595,6 @@ void cmCTestMultiProcessHandler::CreateTestCostList()
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::CreateParallelTestCostList()
 {
   TestSet alreadySortedTests;
@@ -688,7 +674,6 @@ void cmCTestMultiProcessHandler::CreateParallelTestCostList()
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::GetAllTestDependencies(
     int test, TestList& dependencies)
 {
@@ -701,7 +686,6 @@ void cmCTestMultiProcessHandler::GetAllTestDependencies(
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::CreateSerialTestCostList()
 {
   TestList presortedList;
@@ -747,7 +731,6 @@ void cmCTestMultiProcessHandler::CreateSerialTestCostList()
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
 {
   std::string fname = this->CTest->GetBinaryDir()
@@ -758,7 +741,6 @@ void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
   fout.close();
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::MarkFinished()
 {
   std::string fname = this->CTest->GetBinaryDir()
@@ -766,7 +748,6 @@ void cmCTestMultiProcessHandler::MarkFinished()
   cmSystemTools::RemoveFile(fname);
 }
 
-//---------------------------------------------------------
 //For ShowOnly mode
 void cmCTestMultiProcessHandler::PrintTestList()
 {
@@ -858,7 +839,6 @@ void cmCTestMultiProcessHandler::PrintLabels()
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::CheckResume()
 {
   std::string fname = this->CTest->GetBinaryDir()
@@ -889,7 +869,6 @@ void cmCTestMultiProcessHandler::CheckResume()
     }
 }
 
-//---------------------------------------------------------
 void cmCTestMultiProcessHandler::RemoveTest(int index)
 {
   this->EraseTest(index);
@@ -899,7 +878,6 @@ void cmCTestMultiProcessHandler::RemoveTest(int index)
   this->Completed++;
 }
 
-//---------------------------------------------------------
 int cmCTestMultiProcessHandler::FindMaxIndex()
 {
   int max = 0;

Source/CTest/cmCTestP4.cxx

@@ -21,19 +21,16 @@
 #include <sys/types.h>
 #include <time.h>
 
-//----------------------------------------------------------------------------
 cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log):
   cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
 
-//----------------------------------------------------------------------------
 cmCTestP4::~cmCTestP4()
 {
 }
 
-//----------------------------------------------------------------------------
 class cmCTestP4::IdentifyParser: public cmCTestVC::LineParser
 {
 public:
@@ -58,7 +55,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 class cmCTestP4::ChangesParser: public cmCTestVC::LineParser
 {
 public:
@@ -81,7 +77,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 class cmCTestP4::UserParser: public cmCTestVC::LineParser
 {
 public:
@@ -112,7 +107,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 /* Diff format:
 ==== //depot/file#rev - /absolute/path/to/file ====
 (diff data)
@@ -157,7 +151,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
 {
   std::map<std::string, cmCTestP4::User>::const_iterator it =
@@ -188,7 +181,6 @@ cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
   return it->second;
 }
 
-//----------------------------------------------------------------------------
 /* Commit format:
 
 Change 1111111 by user@client on 2013/09/26 11:50:36
@@ -319,7 +311,6 @@ private:
   }
 };
 
-//----------------------------------------------------------------------------
 void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions)
 {
   if(P4Options.empty())
@@ -358,7 +349,6 @@ void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions)
     }
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestP4::GetWorkingRevision()
 {
   std::vector<char const*> p4_identify;
@@ -395,7 +385,6 @@ std::string cmCTestP4::GetWorkingRevision()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestP4::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
@@ -405,7 +394,6 @@ void cmCTestP4::NoteOldRevision()
   this->PriorRev.Rev = this->OldRevision;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestP4::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
@@ -414,7 +402,6 @@ void cmCTestP4::NoteNewRevision()
              << this->NewRevision << "\n");
 }
 
-//----------------------------------------------------------------------------
 void cmCTestP4::LoadRevisions()
 {
   std::vector<char const*> p4_changes;
@@ -465,7 +452,6 @@ void cmCTestP4::LoadRevisions()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestP4::LoadModifications()
 {
   std::vector<char const*> p4_diff;
@@ -484,7 +470,6 @@ void cmCTestP4::LoadModifications()
   this->RunChild(&p4_diff[0], &out, &err);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestP4::UpdateCustom(const std::string& custom)
 {
   std::vector<std::string> p4_custom_command;
@@ -504,7 +489,6 @@ bool cmCTestP4::UpdateCustom(const std::string& custom)
   return this->RunUpdateCommand(&p4_custom[0], &custom_out, &custom_err);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestP4::UpdateImpl()
 {
   std::string custom = this->CTest->GetCTestConfiguration("P4UpdateCustom");

Source/CTest/cmCTestRunTest.cxx

@@ -43,7 +43,6 @@ cmCTestRunTest::~cmCTestRunTest()
 {
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestRunTest::CheckOutput()
 {
   // Read lines for up to 0.1 seconds of total time.
@@ -98,7 +97,6 @@ bool cmCTestRunTest::CheckOutput()
   return true;
 }
 
-//---------------------------------------------------------
 // Streamed compression of test output.  The compressed data
 // is appended to this->CompressedOutput
 void cmCTestRunTest::CompressOutput()
@@ -161,7 +159,6 @@ void cmCTestRunTest::CompressOutput()
   delete [] out;
 }
 
-//---------------------------------------------------------
 bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
 {
   if ((!this->TestHandler->MemCheck &&
@@ -428,7 +425,6 @@ bool cmCTestRunTest::NeedsToRerun()
     }
   return false;
 }
-//----------------------------------------------------------------------
 void cmCTestRunTest::ComputeWeightedCost()
 {
   double prev = static_cast<double>(this->TestProperties->PreviousRuns);
@@ -443,7 +439,6 @@ void cmCTestRunTest::ComputeWeightedCost()
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestRunTest::MemCheckPostProcess()
 {
   if(!this->TestHandler->MemCheck)
@@ -460,7 +455,6 @@ void cmCTestRunTest::MemCheckPostProcess()
   handler->PostProcessTest(this->TestResult, this->Index);
 }
 
-//----------------------------------------------------------------------
 // Starts the execution of a test.  Returns once it has started
 bool cmCTestRunTest::StartTest(size_t total)
 {
@@ -556,7 +550,6 @@ bool cmCTestRunTest::StartTest(size_t total)
                            &this->TestProperties->Environment);
 }
 
-//----------------------------------------------------------------------
 void cmCTestRunTest::ComputeArguments()
 {
   this->Arguments.clear(); // reset becaue this might be a rerun
@@ -623,7 +616,6 @@ void cmCTestRunTest::ComputeArguments()
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestRunTest::DartProcessing()
 {
   if (!this->ProcessOutput.empty() &&
@@ -643,7 +635,6 @@ void cmCTestRunTest::DartProcessing()
     }
 }
 
-//----------------------------------------------------------------------
 double cmCTestRunTest::ResolveTimeout()
 {
   double timeout = this->TestProperties->Timeout;
@@ -708,7 +699,6 @@ double cmCTestRunTest::ResolveTimeout()
     (timeout < stop_timeout ? timeout : stop_timeout);
 }
 
-//----------------------------------------------------------------------
 bool cmCTestRunTest::ForkProcess(double testTimeOut, bool explicitTimeout,
                      std::vector<std::string>* environment)
 {

Source/CTest/cmCTestSVN.cxx

@@ -23,19 +23,16 @@ struct cmCTestSVN::Revision: public cmCTestVC::Revision
   cmCTestSVN::SVNInfo* SVNInfo;
 };
 
-//----------------------------------------------------------------------------
 cmCTestSVN::cmCTestSVN(cmCTest* ct, std::ostream& log):
   cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
 
-//----------------------------------------------------------------------------
 cmCTestSVN::~cmCTestSVN()
 {
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::CleanupImpl()
 {
   std::vector<const char*> svn_cleanup;
@@ -45,7 +42,6 @@ void cmCTestSVN::CleanupImpl()
   this->RunSVNCommand(svn_cleanup, &out, &err);
 }
 
-//----------------------------------------------------------------------------
 class cmCTestSVN::InfoParser: public cmCTestVC::LineParser
 {
 public:
@@ -84,7 +80,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 static bool cmCTestSVNPathStarts(std::string const& p1, std::string const& p2)
 {
   // Does path p1 start with path p2?
@@ -102,7 +97,6 @@ static bool cmCTestSVNPathStarts(std::string const& p1, std::string const& p2)
     }
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo)
 {
   // Run "svn info" to get the repository info from the work tree.
@@ -116,7 +110,6 @@ std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo)
   return rev;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::NoteOldRevision()
 {
   // Info for root repository
@@ -145,7 +138,6 @@ void cmCTestSVN::NoteOldRevision()
   this->PriorRev.Rev = this->OldRevision;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::NoteNewRevision()
 {
   // Get info for the external repositories
@@ -186,7 +178,6 @@ void cmCTestSVN::NoteNewRevision()
   this->NewRevision = this->RootInfo->NewRevision;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::GuessBase(SVNInfo& svninfo,
                            std::vector<Change> const& changes)
 {
@@ -220,7 +211,6 @@ void cmCTestSVN::GuessBase(SVNInfo& svninfo,
   this->Log << "Guessed Base = " << svninfo.Base << "\n";
 }
 
-//----------------------------------------------------------------------------
 class cmCTestSVN::UpdateParser: public cmCTestVC::LineParser
 {
 public:
@@ -268,7 +258,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 bool cmCTestSVN::UpdateImpl()
 {
   // Get user-specified update options.
@@ -298,7 +287,6 @@ bool cmCTestSVN::UpdateImpl()
   return this->RunSVNCommand(svn_update, &out, &err);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
     OutputParser* out, OutputParser* err)
 {
@@ -334,7 +322,6 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
     }
 }
 
-//----------------------------------------------------------------------------
 class cmCTestSVN::LogParser: public cmCTestVC::OutputLogger,
                              private cmXMLParser
 {
@@ -423,7 +410,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::LoadRevisions()
 {
   // Get revisions for all the external repositories
@@ -436,7 +422,6 @@ void cmCTestSVN::LoadRevisions()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::LoadRevisions(SVNInfo &svninfo)
 {
   // We are interested in every revision included in the update.
@@ -462,7 +447,6 @@ void cmCTestSVN::LoadRevisions(SVNInfo &svninfo)
   this->RunSVNCommand(svn_log, &out, &err);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::DoRevisionSVN(Revision const& revision,
                                std::vector<Change> const& changes)
 {
@@ -482,7 +466,6 @@ void cmCTestSVN::DoRevisionSVN(Revision const& revision,
   this->cmCTestGlobalVC::DoRevision(revision, changes);
 }
 
-//----------------------------------------------------------------------------
 class cmCTestSVN::StatusParser: public cmCTestVC::LineParser
 {
 public:
@@ -523,7 +506,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::LoadModifications()
 {
   // Run "svn status" which reports local modifications.
@@ -534,7 +516,6 @@ void cmCTestSVN::LoadModifications()
   this->RunSVNCommand(svn_status, &out, &err);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::WriteXMLGlobal(cmXMLWriter& xml)
 {
   this->cmCTestGlobalVC::WriteXMLGlobal(xml);
@@ -542,7 +523,6 @@ void cmCTestSVN::WriteXMLGlobal(cmXMLWriter& xml)
   xml.Element("SVNPath", this->RootInfo->Base);
 }
 
-//----------------------------------------------------------------------------
 class cmCTestSVN::ExternalParser: public cmCTestVC::LineParser
 {
 public:
@@ -581,7 +561,6 @@ private:
     }
 };
 
-//----------------------------------------------------------------------------
 void cmCTestSVN::LoadExternals()
 {
   // Run "svn status" to get the list of external repositories
@@ -592,7 +571,6 @@ void cmCTestSVN::LoadExternals()
   this->RunSVNCommand(svn_status, &out, &err);
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestSVN::SVNInfo::BuildLocalPath(std::string const& path) const
 {
   std::string local_path;

Source/CTest/cmCTestScriptHandler.cxx

@@ -78,7 +78,6 @@ IsFunctionBlocked(const cmListFileFunction& , cmMakefile &,
   return false;
 }
 
-//----------------------------------------------------------------------
 cmCTestScriptHandler::cmCTestScriptHandler()
 {
   this->Backup = false;
@@ -95,7 +94,6 @@ cmCTestScriptHandler::cmCTestScriptHandler()
   this->ContinuousDuration = -1;
 }
 
-//----------------------------------------------------------------------
 void cmCTestScriptHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -132,7 +130,6 @@ void cmCTestScriptHandler::Initialize()
   delete this->CMake;
 }
 
-//----------------------------------------------------------------------
 cmCTestScriptHandler::~cmCTestScriptHandler()
 {
   delete this->Makefile;
@@ -141,7 +138,6 @@ cmCTestScriptHandler::~cmCTestScriptHandler()
 }
 
 
-//----------------------------------------------------------------------
 // just adds an argument to the vector
 void cmCTestScriptHandler::AddConfigurationScript(const char *script,
                                                   bool pscope)
@@ -151,7 +147,6 @@ void cmCTestScriptHandler::AddConfigurationScript(const char *script,
 }
 
 
-//----------------------------------------------------------------------
 // the generic entry point for handling scripts, this routine will run all
 // the scripts provides a -S arguments
 int cmCTestScriptHandler::ProcessHandler()
@@ -184,7 +179,6 @@ void cmCTestScriptHandler::UpdateElapsedTime()
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestScriptHandler::AddCTestCommand(cmCTestCommand* command)
 {
   cmCTestCommand* newCom = command;
@@ -348,7 +342,6 @@ void cmCTestScriptHandler::CreateCMake()
   this->AddCTestCommand(new cmCTestUploadCommand);
 }
 
-//----------------------------------------------------------------------
 // this sets up some variables for the script to use, creates the required
 // cmake instance and generators, and then reads in the script
 int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
@@ -443,7 +436,6 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
 }
 
 
-//----------------------------------------------------------------------
 // extract variabels from the script to set ivars
 int cmCTestScriptHandler::ExtractVariables()
 {
@@ -560,7 +552,6 @@ int cmCTestScriptHandler::ExtractVariables()
   return 0;
 }
 
-//----------------------------------------------------------------------
 void cmCTestScriptHandler::SleepInSeconds(unsigned int secondsToWait)
 {
 #if defined(_WIN32)
@@ -570,7 +561,6 @@ void cmCTestScriptHandler::SleepInSeconds(unsigned int secondsToWait)
 #endif
 }
 
-//----------------------------------------------------------------------
 // run a specific script
 int cmCTestScriptHandler::RunConfigurationScript
 (const std::string& total_script_arg, bool pscope)
@@ -610,7 +600,6 @@ int cmCTestScriptHandler::RunConfigurationScript
   return result;
 }
 
-//----------------------------------------------------------------------
 int cmCTestScriptHandler::RunCurrentScript()
 {
   int result;
@@ -673,7 +662,6 @@ int cmCTestScriptHandler::RunCurrentScript()
   return result;
 }
 
-//----------------------------------------------------------------------
 int cmCTestScriptHandler::CheckOutSourceDir()
 {
   std::string command;
@@ -702,7 +690,6 @@ int cmCTestScriptHandler::CheckOutSourceDir()
   return 0;
 }
 
-//----------------------------------------------------------------------
 int cmCTestScriptHandler::BackupDirectories()
 {
   int retVal;
@@ -743,7 +730,6 @@ int cmCTestScriptHandler::BackupDirectories()
 }
 
 
-//----------------------------------------------------------------------
 int cmCTestScriptHandler::PerformExtraUpdates()
 {
   std::string command;
@@ -786,7 +772,6 @@ int cmCTestScriptHandler::PerformExtraUpdates()
 }
 
 
-//----------------------------------------------------------------------
 // run a single dashboard entry
 int cmCTestScriptHandler::RunConfigurationDashboard()
 {
@@ -977,7 +962,6 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
   return 0;
 }
 
-//-------------------------------------------------------------------------
 bool cmCTestScriptHandler::WriteInitialCache(const char* directory,
                                              const char* text)
 {
@@ -1002,7 +986,6 @@ bool cmCTestScriptHandler::WriteInitialCache(const char* directory,
   return true;
 }
 
-//-------------------------------------------------------------------------
 void cmCTestScriptHandler::RestoreBackupDirectories()
 {
   // if we backed up the dirs and the build failed, then restore
@@ -1074,7 +1057,6 @@ bool cmCTestScriptHandler::EmptyBinaryDirectory(const char *sname)
   return false;
 }
 
-//-------------------------------------------------------------------------
 bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce(
   const std::string& directoryPath)
 {
@@ -1114,7 +1096,6 @@ bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce(
   return cmSystemTools::RemoveADirectory(directoryPath);
 }
 
-//-------------------------------------------------------------------------
 double cmCTestScriptHandler::GetRemainingTimeAllowed()
 {
   if (!this->Makefile)

Source/CTest/cmCTestStartCommand.cxx

@@ -154,7 +154,6 @@ bool cmCTestStartCommand
   return this->CTest->InitializeFromCommand(this);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestStartCommand::InitialCheckout(
   std::ostream& ofs, std::string const& sourceDir)
 {

Source/CTest/cmCTestSubmitCommand.cxx

@@ -161,7 +161,6 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
   return handler;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
                                        cmExecutionStatus& status)
 {
@@ -169,7 +168,6 @@ bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
   return this->cmCTestHandlerCommand::InitialPass(args, status);
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitCommand::CheckArgumentKeyword(std::string const& arg)
 {
   if (this->CDashUpload)
@@ -227,7 +225,6 @@ bool cmCTestSubmitCommand::CheckArgumentKeyword(std::string const& arg)
 }
 
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitCommand::CheckArgumentValue(std::string const& arg)
 {
   // Handle states specific to this command.

Source/CTest/cmCTestSubmitHandler.cxx

@@ -37,7 +37,6 @@
 
 typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
 
-//----------------------------------------------------------------------------
 class cmCTestSubmitHandler::ResponseParser: public cmXMLParser
 {
 public:
@@ -146,13 +145,11 @@ cmCTestSubmitHandlerCurlDebugCallback(CURL *, curl_infotype, char *chPtr,
   return size;
 }
 
-//----------------------------------------------------------------------------
 cmCTestSubmitHandler::cmCTestSubmitHandler() : HTTPProxy(), FTPProxy()
 {
   this->Initialize();
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSubmitHandler::Initialize()
 {
   // We submit all available parts by default.
@@ -174,7 +171,6 @@ void cmCTestSubmitHandler::Initialize()
   this->Files.clear();
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
   const std::set<std::string>& files,
   const std::string& remoteprefix,
@@ -328,7 +324,6 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
   return true;
 }
 
-//----------------------------------------------------------------------------
 // Uploading files is simpler
 bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
   const std::set<std::string>& files,
@@ -643,7 +638,6 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSubmitHandler
 ::ParseResponse(cmCTestSubmitHandlerVectorOfChar chunk)
 {
@@ -680,7 +674,6 @@ void cmCTestSubmitHandler
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::TriggerUsingHTTP(
   const std::set<std::string>& files,
   const std::string& remoteprefix,
@@ -821,7 +814,6 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::SubmitUsingSCP(
   const std::string& scp_command,
   const std::string& localprefix,
@@ -923,7 +915,6 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::SubmitUsingCP(
   const std::string& localprefix,
   const std::set<std::string>& files,
@@ -967,7 +958,6 @@ bool cmCTestSubmitHandler::SubmitUsingCP(
 }
 
 
-//----------------------------------------------------------------------------
 #if defined(CTEST_USE_XMLRPC)
 bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const std::string& localprefix,
   const std::set<std::string>& files,
@@ -1238,7 +1228,6 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
   return 0;
 }
 
-//----------------------------------------------------------------------------
 int cmCTestSubmitHandler::ProcessHandler()
 {
   const char* cdashUploadFile = this->GetOption("CDashUploadFile");
@@ -1664,7 +1653,6 @@ int cmCTestSubmitHandler::ProcessHandler()
   return -1;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
 {
   std::string buildname = cmCTest::SafeBuildIdField(
@@ -1676,7 +1664,6 @@ std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
   return name;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts)
 {
   // Check whether each part is selected.
@@ -1688,7 +1675,6 @@ void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCTestSubmitHandler::SelectFiles(cmCTest::SetOfStrings const& files)
 {
   this->Files.insert(files.begin(), files.end());

Source/CTest/cmCTestTestHandler.cxx

@@ -36,7 +36,6 @@
 
 #include <set>
 
-//----------------------------------------------------------------------
 class cmCTestSubdirCommand : public cmCommand
 {
 public:
@@ -67,7 +66,6 @@ public:
   cmCTestTestHandler* TestHandler;
 };
 
-//----------------------------------------------------------------------
 bool cmCTestSubdirCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
@@ -131,7 +129,6 @@ bool cmCTestSubdirCommand
   return true;
 }
 
-//----------------------------------------------------------------------
 class cmCTestAddSubdirectoryCommand : public cmCommand
 {
 public:
@@ -162,7 +159,6 @@ public:
   cmCTestTestHandler* TestHandler;
 };
 
-//----------------------------------------------------------------------
 bool cmCTestAddSubdirectoryCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
@@ -215,7 +211,6 @@ bool cmCTestAddSubdirectoryCommand
   return true;
 }
 
-//----------------------------------------------------------------------
 class cmCTestAddTestCommand : public cmCommand
 {
 public:
@@ -246,7 +241,6 @@ public:
   cmCTestTestHandler* TestHandler;
 };
 
-//----------------------------------------------------------------------
 bool cmCTestAddTestCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
@@ -258,7 +252,6 @@ bool cmCTestAddTestCommand
   return this->TestHandler->AddTest(args);
 }
 
-//----------------------------------------------------------------------
 class cmCTestSetTestsPropertiesCommand : public cmCommand
 {
 public:
@@ -290,14 +283,12 @@ public:
   cmCTestTestHandler* TestHandler;
 };
 
-//----------------------------------------------------------------------
 bool cmCTestSetTestsPropertiesCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
   return this->TestHandler->SetTestsProperties(args);
 }
 
-//----------------------------------------------------------------------
 // get the next number in a string with numbers separated by ,
 // pos is the start of the search and pos2 is the end of the search
 // pos becomes pos2 after a call to GetNextNumber.
@@ -335,7 +326,6 @@ inline int GetNextNumber(std::string const& in,
     }
 }
 
-//----------------------------------------------------------------------
 // get the next number in a string with numbers separated by ,
 // pos is the start of the search and pos2 is the end of the search
 // pos becomes pos2 after a call to GetNextNumber.
@@ -374,7 +364,6 @@ inline int GetNextRealNumber(std::string const& in,
 }
 
 
-//----------------------------------------------------------------------
 cmCTestTestHandler::cmCTestTestHandler()
 {
   this->UseUnion = false;
@@ -400,7 +389,6 @@ cmCTestTestHandler::cmCTestTestHandler()
     "(<DartMeasurement[^<]*</DartMeasurement[a-zA-Z]*>)");
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -435,7 +423,6 @@ void cmCTestTestHandler::Initialize()
   this->TestList.clear();
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf)
 {
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST",
@@ -453,7 +440,6 @@ void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf)
                              this->CustomMaximumFailedTestOutputSize);
 }
 
-//----------------------------------------------------------------------
 int cmCTestTestHandler::PreProcessHandler()
 {
   if ( !this->ExecuteCommands(this->CustomPreTest) )
@@ -465,7 +451,6 @@ int cmCTestTestHandler::PreProcessHandler()
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCTestTestHandler::PostProcessHandler()
 {
   if ( !this->ExecuteCommands(this->CustomPostTest) )
@@ -477,7 +462,6 @@ int cmCTestTestHandler::PostProcessHandler()
   return 1;
 }
 
-//----------------------------------------------------------------------
 //clearly it would be nice if this were broken up into a few smaller
 //functions and commented...
 int cmCTestTestHandler::ProcessHandler()
@@ -652,7 +636,6 @@ int cmCTestTestHandler::ProcessHandler()
   return 0;
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::PrintLabelSummary()
 {
   cmCTestTestHandler::ListOfTests::iterator it = this->TestList.begin();
@@ -739,7 +722,6 @@ void cmCTestTestHandler::PrintLabelSummary()
 
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it)
 {
   // if not using Labels to filter then return
@@ -773,7 +755,6 @@ void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it)
 }
 
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it)
 {
   // if not using Labels to filter then return
@@ -805,14 +786,12 @@ void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it)
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::CheckLabelFilter(cmCTestTestProperties& it)
 {
   this->CheckLabelFilterInclude(it);
   this->CheckLabelFilterExclude(it);
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::ComputeTestList()
 {
   this->TestList.clear(); // clear list of test
@@ -1060,7 +1039,6 @@ bool cmCTestTestHandler::GetValue(const char* tag,
   return ret;
 }
 
-//---------------------------------------------------------------------
 void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
                                          std::vector<std::string> &failed)
 {
@@ -1158,12 +1136,10 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
      << this->CTest->CurrentTime() << std::endl;
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::GenerateTestCommand(std::vector<std::string>&, int)
 {
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
 {
   if ( !this->CTest->GetProduceXML() )
@@ -1271,7 +1247,6 @@ void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
   this->CTest->EndXML(xml);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml,
                                                cmCTestTestResult* result)
 {
@@ -1295,7 +1270,6 @@ void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml,
   xml.Element("FullCommandLine", result->FullCommandLine);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml,
                                                cmCTestTestResult* result)
 {
@@ -1314,7 +1288,6 @@ void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml,
   xml.EndElement(); // Test
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml,
                                      cmCTestTestResult* result)
 {
@@ -1343,7 +1316,6 @@ void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml,
     }
 }
 
-//----------------------------------------------------------------------
 int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec)
 {
   std::vector<std::string>::iterator it;
@@ -1365,7 +1337,6 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec)
 }
 
 
-//----------------------------------------------------------------------
 // Find the appropriate executable to run for a test
 std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
 {
@@ -1455,7 +1426,6 @@ void cmCTestTestHandler
 }
 
 
-//----------------------------------------------------------------------
 // Find the appropriate executable to run for a test
 std::string cmCTestTestHandler
 ::FindExecutable(cmCTest *ctest,
@@ -1565,7 +1535,6 @@ std::string cmCTestTestHandler
 }
 
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::GetListOfTests()
 {
   if ( !this->IncludeLabelRegExp.empty() )
@@ -1648,20 +1617,17 @@ void cmCTestTestHandler::GetListOfTests()
     "Done constructing a list of tests" << std::endl, this->Quiet);
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::UseIncludeRegExp()
 {
   this->UseIncludeRegExpFlag = true;
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::UseExcludeRegExp()
 {
   this->UseExcludeRegExpFlag = true;
   this->UseExcludeRegExpFirst = this->UseIncludeRegExpFlag ? false : true;
 }
 
-//----------------------------------------------------------------------
 const char* cmCTestTestHandler::GetTestStatus(int status)
 {
   static const char statuses[][100] = {
@@ -1685,7 +1651,6 @@ const char* cmCTestTestHandler::GetTestStatus(int status)
   return statuses[status];
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::ExpandTestsToRunInformation(size_t numTests)
 {
   if (this->TestsToRunString.empty())
@@ -1841,10 +1806,8 @@ void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed()
     }
 }
 
-//----------------------------------------------------------------------
 // Just for convenience
 #define SPACE_REGEX "[ \t\r\n]"
-//----------------------------------------------------------------------
 void cmCTestTestHandler::GenerateRegressionImages(
   cmXMLWriter& xml, const std::string& dart)
 {
@@ -2031,19 +1994,16 @@ void cmCTestTestHandler::GenerateRegressionImages(
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::SetIncludeRegExp(const char *arg)
 {
   this->IncludeRegExp = arg;
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::SetExcludeRegExp(const char *arg)
 {
   this->ExcludeRegExp = arg;
 }
 
-//----------------------------------------------------------------------
 void cmCTestTestHandler::SetTestsToRunInformation(const char* in)
 {
   if ( !in )
@@ -2065,7 +2025,6 @@ void cmCTestTestHandler::SetTestsToRunInformation(const char* in)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length)
 {
   if(!length || length >= output.size() ||
@@ -2107,7 +2066,6 @@ bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length)
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTestTestHandler::SetTestsProperties(
   const std::vector<std::string>& args)
 {
@@ -2287,7 +2245,6 @@ bool cmCTestTestHandler::SetTestsProperties(
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
 {
   const std::string& testname = args[0];

Source/CTest/cmCTestUpdateHandler.cxx

@@ -44,7 +44,6 @@
 #include <math.h>
 #include <stdlib.h>
 
-//----------------------------------------------------------------------
 static const char* cmCTestUpdateHandlerUpdateStrings[] =
 {
   "Unknown",
@@ -66,12 +65,10 @@ static const char* cmCTestUpdateHandlerUpdateToString(int type)
   return cmCTestUpdateHandlerUpdateStrings[type];
 }
 
-//----------------------------------------------------------------------
 cmCTestUpdateHandler::cmCTestUpdateHandler()
 {
 }
 
-//----------------------------------------------------------------------
 void cmCTestUpdateHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -79,7 +76,6 @@ void cmCTestUpdateHandler::Initialize()
   this->UpdateType = e_CVS;
 }
 
-//----------------------------------------------------------------------
 int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
 {
   cmCTestOptionalLog(this->CTest, DEBUG,
@@ -148,7 +144,6 @@ int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
   return cmCTestUpdateHandler::e_UNKNOWN;
 }
 
-//----------------------------------------------------------------------
 //clearly it would be nice if this were broken up into a few smaller
 //functions and commented...
 int cmCTestUpdateHandler::ProcessHandler()
@@ -291,7 +286,6 @@ int cmCTestUpdateHandler::ProcessHandler()
   return updated? numUpdated : -1;
 }
 
-//----------------------------------------------------------------------
 int cmCTestUpdateHandler::DetectVCS(const char* dir)
 {
   std::string sourceDirectory = dir;
@@ -341,7 +335,6 @@ int cmCTestUpdateHandler::DetectVCS(const char* dir)
   return cmCTestUpdateHandler::e_UNKNOWN;
 }
 
-//----------------------------------------------------------------------
 bool cmCTestUpdateHandler::SelectVCS()
 {
   // Get update command

Source/CTest/cmCTestUploadCommand.cxx

@@ -31,7 +31,6 @@ cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler()
 }
 
 
-//----------------------------------------------------------------------------
 bool cmCTestUploadCommand::CheckArgumentKeyword(std::string const& arg)
 {
   if(arg == "FILES")
@@ -49,7 +48,6 @@ bool cmCTestUploadCommand::CheckArgumentKeyword(std::string const& arg)
 }
 
 
-//----------------------------------------------------------------------------
 bool cmCTestUploadCommand::CheckArgumentValue(std::string const& arg)
 {
   if(this->ArgumentDoing == ArgumentDoingFiles)

Source/CTest/cmCTestUploadHandler.cxx

@@ -15,13 +15,11 @@
 #include "cmVersion.h"
 #include "cmXMLWriter.h"
 
-//----------------------------------------------------------------------------
 cmCTestUploadHandler::cmCTestUploadHandler()
 {
   this->Initialize();
 }
 
-//----------------------------------------------------------------------------
 void cmCTestUploadHandler::Initialize()
 {
   this->Superclass::Initialize();
@@ -33,7 +31,6 @@ void cmCTestUploadHandler::SetFiles(const cmCTest::SetOfStrings& files)
   this->Files = files;
 }
 
-//----------------------------------------------------------------------------
 int cmCTestUploadHandler::ProcessHandler()
 {
   cmGeneratedFileStream ofs;

Source/CTest/cmCTestVC.cxx

@@ -17,7 +17,6 @@
 
 #include <cmsys/Process.h>
 
-//----------------------------------------------------------------------------
 cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log): CTest(ct), Log(log)
 {
   this->PathCount[PathUpdated] = 0;
@@ -28,24 +27,20 @@ cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log): CTest(ct), Log(log)
   this->Unknown.Rev = "Unknown";
 }
 
-//----------------------------------------------------------------------------
 cmCTestVC::~cmCTestVC()
 {
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::SetCommandLineTool(std::string const& tool)
 {
   this->CommandLineTool = tool;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::SetSourceDirectory(std::string const& dir)
 {
   this->SourceDirectory = dir;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::InitialCheckout(const char* command)
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
@@ -86,7 +81,6 @@ bool cmCTestVC::InitialCheckout(const char* command)
   return result;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::RunChild(char const* const* cmd, OutputParser* out,
                          OutputParser* err, const char* workDir)
 {
@@ -102,7 +96,6 @@ bool cmCTestVC::RunChild(char const* const* cmd, OutputParser* out,
   return result == 0;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestVC::ComputeCommandLine(char const* const* cmd)
 {
   std::ostringstream line;
@@ -115,7 +108,6 @@ std::string cmCTestVC::ComputeCommandLine(char const* const* cmd)
   return line.str();
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::RunUpdateCommand(char const* const* cmd,
                                  OutputParser* out, OutputParser* err)
 {
@@ -131,7 +123,6 @@ bool cmCTestVC::RunUpdateCommand(char const* const* cmd,
   return this->RunChild(cmd, out, err);
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTestVC::GetNightlyTime()
 {
   // Get the nightly start time corresponding to the current dau.
@@ -149,7 +140,6 @@ std::string cmCTestVC::GetNightlyTime()
   return std::string(current_time);
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::Cleanup()
 {
   this->Log << "--- Begin Cleanup ---\n";
@@ -157,13 +147,11 @@ void cmCTestVC::Cleanup()
   this->Log << "--- End Cleanup ---\n";
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::CleanupImpl()
 {
   // We do no cleanup by default.
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::Update()
 {
   bool result = true;
@@ -181,19 +169,16 @@ bool cmCTestVC::Update()
   return result;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::NoteOldRevision()
 {
   // We do nothing by default.
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::NoteNewRevision()
 {
   // We do nothing by default.
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::UpdateImpl()
 {
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
@@ -201,7 +186,6 @@ bool cmCTestVC::UpdateImpl()
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::WriteXML(cmXMLWriter& xml)
 {
   this->Log << "--- Begin Revisions ---\n";
@@ -210,7 +194,6 @@ bool cmCTestVC::WriteXML(cmXMLWriter& xml)
   return result;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTestVC::WriteXMLUpdates(cmXMLWriter&)
 {
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
@@ -218,7 +201,6 @@ bool cmCTestVC::WriteXMLUpdates(cmXMLWriter&)
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmCTestVC::WriteXMLEntry(cmXMLWriter& xml,
                               std::string const& path,
                               std::string const& name,

Source/CTest/cmParseCoberturaCoverage.cxx

@@ -5,7 +5,6 @@
 #include <cmsys/Directory.hxx>
 #include <cmsys/FStream.hxx>
 
-//----------------------------------------------------------------------------
 class cmParseCoberturaCoverage::XMLParser: public cmXMLParser
 {
 public:

Source/CTest/cmProcess.cxx

@@ -69,7 +69,6 @@ bool cmProcess::StartProcess()
           == cmsysProcess_State_Executing);
 }
 
-//----------------------------------------------------------------------------
 bool cmProcess::Buffer::GetLine(std::string& line)
 {
   // Scan for the next newline.
@@ -106,7 +105,6 @@ bool cmProcess::Buffer::GetLine(std::string& line)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmProcess::Buffer::GetLast(std::string& line)
 {
   // Return the partial last line, if any.
@@ -120,7 +118,6 @@ bool cmProcess::Buffer::GetLast(std::string& line)
   return false;
 }
 
-//----------------------------------------------------------------------------
 int cmProcess::GetNextOutputLine(std::string& line, double timeout)
 {
   for(;;)

Source/CursesDialog/ccmake.cxx

@@ -23,7 +23,6 @@
 
 #include <form.h>
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationName[][2] =
 {
   {0,
@@ -31,7 +30,6 @@ static const char * cmDocumentationName[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationUsage[][2] =
 {
   {0,
@@ -44,7 +42,6 @@ static const char * cmDocumentationUsage[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationUsageNote[][2] =
 {
   {0,
@@ -52,7 +49,6 @@ static const char * cmDocumentationUsageNote[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationOptions[][2] =
 {
   CMAKE_STANDARD_OPTIONS_TABLE,

Source/QtDialog/CMakeSetup.cxx

@@ -25,7 +25,6 @@
 #include <cmsys/Encoding.hxx>
 #include <cmsys/SystemTools.hxx>
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationName[][2] =
 {
   {0,
@@ -33,7 +32,6 @@ static const char * cmDocumentationName[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationUsage[][2] =
 {
   {0,
@@ -43,7 +41,6 @@ static const char * cmDocumentationUsage[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char * cmDocumentationOptions[][2] =
 {
   {0,0}

Source/cmAddCustomCommandCommand.cxx

@@ -412,7 +412,6 @@ bool cmAddCustomCommandCommand
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmAddCustomCommandCommand
 ::CheckOutputs(const std::vector<std::string>& outputs)

Source/cmAddTestCommand.cxx

@@ -65,7 +65,6 @@ bool cmAddTestCommand
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
 {
   std::string name;

Source/cmArchiveWrite.cxx

@@ -22,14 +22,12 @@
 # define __LA_SSIZE_T la_ssize_t
 #endif
 
-//----------------------------------------------------------------------------
 static std::string cm_archive_error_string(struct archive* a)
 {
   const char* e = archive_error_string(a);
   return e? e : "unknown error";
 }
 
-//----------------------------------------------------------------------------
 static void cm_archive_entry_copy_pathname(struct archive_entry* e,
   const std::string& dest)
 {
@@ -40,7 +38,6 @@ static void cm_archive_entry_copy_pathname(struct archive_entry* e,
 #endif
 }
 
-//----------------------------------------------------------------------------
 static void cm_archive_entry_copy_sourcepath(struct archive_entry* e,
   const std::string& file)
 {
@@ -51,7 +48,6 @@ static void cm_archive_entry_copy_sourcepath(struct archive_entry* e,
 #endif
 }
 
-//----------------------------------------------------------------------------
 class cmArchiveWrite::Entry
 {
   struct archive_entry* Object;
@@ -61,7 +57,6 @@ public:
   operator struct archive_entry*() { return this->Object; }
 };
 
-//----------------------------------------------------------------------------
 struct cmArchiveWrite::Callback
 {
   // archive_write_callback
@@ -81,7 +76,6 @@ struct cmArchiveWrite::Callback
     }
 };
 
-//----------------------------------------------------------------------------
 cmArchiveWrite::cmArchiveWrite(
   std::ostream& os, Compress c, std::string const& format):
     Stream(os),
@@ -177,14 +171,12 @@ cmArchiveWrite::cmArchiveWrite(
     }
 }
 
-//----------------------------------------------------------------------------
 cmArchiveWrite::~cmArchiveWrite()
 {
   archive_read_free(this->Disk);
   archive_write_free(this->Archive);
 }
 
-//----------------------------------------------------------------------------
 bool cmArchiveWrite::Add(std::string path,
                          size_t skip,
                          const char* prefix,
@@ -201,7 +193,6 @@ bool cmArchiveWrite::Add(std::string path,
   return this->Okay();
 }
 
-//----------------------------------------------------------------------------
 bool cmArchiveWrite::AddPath(const char* path,
                              size_t skip, const char* prefix,
                              bool recursive)
@@ -239,7 +230,6 @@ bool cmArchiveWrite::AddPath(const char* path,
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmArchiveWrite::AddFile(const char* file,
                              size_t skip, const char* prefix)
 {
@@ -344,7 +334,6 @@ bool cmArchiveWrite::AddFile(const char* file,
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmArchiveWrite::AddData(const char* file, size_t size)
 {
   cmsys::ifstream fin(file, std::ios::in | std::ios::binary);

Source/cmBuildCommand.cxx

@@ -13,7 +13,6 @@
 
 #include "cmGlobalGenerator.h"
 
-//----------------------------------------------------------------------
 bool cmBuildCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
@@ -27,7 +26,6 @@ bool cmBuildCommand
   return this->MainSignature(args);
 }
 
-//----------------------------------------------------------------------
 bool cmBuildCommand
 ::MainSignature(std::vector<std::string> const& args)
 {
@@ -113,7 +111,6 @@ bool cmBuildCommand
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmBuildCommand
 ::TwoArgsSignature(std::vector<std::string> const& args)
 {

Source/cmCMakeMinimumRequired.cxx

@@ -127,7 +127,6 @@ bool cmCMakeMinimumRequired
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCMakeMinimumRequired::EnforceUnknownArguments()
 {
   if(!this->UnknownArguments.empty())

Source/cmCMakePolicyCommand.cxx

@@ -62,7 +62,6 @@ bool cmCMakePolicyCommand
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args)
 {
   if(args.size() != 3)
@@ -112,7 +111,6 @@ bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
 {
   if(args.size() != 3)
@@ -169,7 +167,6 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmCMakePolicyCommand::HandleVersionMode(std::vector<std::string> const& args)
 {

Source/cmCTest.cxx

@@ -64,7 +64,6 @@
 #define DEBUGOUT std::cout << __LINE__ << " "; std::cout
 #define DEBUGERR std::cerr << __LINE__ << " "; std::cerr
 
-//----------------------------------------------------------------------
 struct tm* cmCTest::GetNightlyTime(std::string str,
                                    bool tomorrowtag)
 {
@@ -123,7 +122,6 @@ struct tm* cmCTest::GetNightlyTime(std::string str,
   return lctime;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::CleanString(const std::string& str)
 {
   std::string::size_type spos = str.find_first_not_of(" \n\t\r\f\v");
@@ -139,7 +137,6 @@ std::string cmCTest::CleanString(const std::string& str)
   return str.substr(spos, epos);
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::CurrentTime()
 {
   time_t currenttime = time(0);
@@ -158,7 +155,6 @@ std::string cmCTest::CurrentTime()
   return cmCTest::CleanString(current_time);
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::GetCostDataFile()
 {
   std::string fname = this->GetCTestConfiguration("CostDataFile");
@@ -170,7 +166,6 @@ std::string cmCTest::GetCostDataFile()
 }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-//----------------------------------------------------------------------------
 static size_t
 HTTPResponseCallback(void *ptr, size_t size, size_t nmemb, void *data)
 {
@@ -184,7 +179,6 @@ HTTPResponseCallback(void *ptr, size_t size, size_t nmemb, void *data)
   return realsize;
 }
 
-//----------------------------------------------------------------------------
 int cmCTest::HTTPRequest(std::string url, HTTPMethod method,
                                        std::string& response,
                                        std::string fields,
@@ -240,7 +234,6 @@ int cmCTest::HTTPRequest(std::string url, HTTPMethod method,
 }
 #endif
 
-//----------------------------------------------------------------------
 std::string cmCTest::MakeURLSafe(const std::string& str)
 {
   std::ostringstream ost;
@@ -267,7 +260,6 @@ std::string cmCTest::MakeURLSafe(const std::string& str)
   return ost.str();
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTest::DecodeURL(const std::string& in)
 {
   std::string out;
@@ -287,7 +279,6 @@ std::string cmCTest::DecodeURL(const std::string& in)
   return out;
 }
 
-//----------------------------------------------------------------------
 cmCTest::cmCTest()
 {
   this->LabelSummary           = true;
@@ -381,7 +372,6 @@ cmCTest::cmCTest()
   cmSystemTools::EnableVSConsoleOutput();
 }
 
-//----------------------------------------------------------------------
 cmCTest::~cmCTest()
 {
   cmDeleteAll(this->TestingHandlers);
@@ -398,7 +388,6 @@ void cmCTest::SetTestLoad(unsigned long load)
   this->TestLoad = load;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTest::ShouldCompressTestOutput()
 {
   if(!this->ComputedCompressTestOutput)
@@ -415,7 +404,6 @@ bool cmCTest::ShouldCompressTestOutput()
   return this->CompressTestOutput;
 }
 
-//----------------------------------------------------------------------------
 bool cmCTest::ShouldCompressMemCheckOutput()
 {
   if(!this->ComputedCompressMemCheckOutput)
@@ -430,7 +418,6 @@ bool cmCTest::ShouldCompressMemCheckOutput()
   return this->CompressMemCheckOutput;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCTest::GetCDashVersion()
 {
 #ifdef CMAKE_BUILD_WITH_CMAKE
@@ -455,7 +442,6 @@ std::string cmCTest::GetCDashVersion()
 #endif
 }
 
-//----------------------------------------------------------------------------
 cmCTest::Part cmCTest::GetPartFromName(const char* name)
 {
   // Look up by lower-case to make names case-insensitive.
@@ -470,7 +456,6 @@ cmCTest::Part cmCTest::GetPartFromName(const char* name)
   return PartCount;
 }
 
-//----------------------------------------------------------------------
 int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
 {
   bool quiet = false;
@@ -658,7 +643,6 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
   return 1;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
 {
   std::string src_dir
@@ -745,7 +729,6 @@ bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
 }
 
 
-//----------------------------------------------------------------------
 bool cmCTest::UpdateCTestConfiguration()
 {
   if ( this->SuppressUpdatingCTestConfiguration )
@@ -848,7 +831,6 @@ bool cmCTest::UpdateCTestConfiguration()
   return true;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::BlockTestErrorDiagnostics()
 {
   cmSystemTools::PutEnv("DART_TEST_FROM_DART=1");
@@ -860,14 +842,12 @@ void cmCTest::BlockTestErrorDiagnostics()
 #endif
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetTestModel(int mode)
 {
   this->InteractiveDebugMode = false;
   this->TestModel = mode;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::SetTest(const char* ttype, bool report)
 {
   if ( cmSystemTools::LowerCase(ttype) == "all" )
@@ -895,12 +875,10 @@ bool cmCTest::SetTest(const char* ttype, bool report)
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTest::Finalize()
 {
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::OpenOutputFile(const std::string& path,
                      const std::string& name, cmGeneratedFileStream& stream,
                      bool compress)
@@ -947,7 +925,6 @@ bool cmCTest::OpenOutputFile(const std::string& path,
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::AddIfExists(Part part, const char* file)
 {
   if ( this->CTestFileExists(file) )
@@ -970,7 +947,6 @@ bool cmCTest::AddIfExists(Part part, const char* file)
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::CTestFileExists(const std::string& filename)
 {
   std::string testingDir = this->BinaryDir + "/Testing/" +
@@ -978,7 +954,6 @@ bool cmCTest::CTestFileExists(const std::string& filename)
   return cmSystemTools::FileExists(testingDir.c_str());
 }
 
-//----------------------------------------------------------------------
 cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
 {
   cmCTest::t_TestingHandlers::iterator it =
@@ -991,7 +966,6 @@ cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
   return it->second;
 }
 
-//----------------------------------------------------------------------
 cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
 {
   cmCTest::t_TestingHandlers::iterator it =
@@ -1003,7 +977,6 @@ cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
   return it->second;
 }
 
-//----------------------------------------------------------------------
 int cmCTest::ExecuteHandler(const char* shandler)
 {
   cmCTestGenericHandler* handler = this->GetHandler(shandler);
@@ -1015,7 +988,6 @@ int cmCTest::ExecuteHandler(const char* shandler)
   return handler->ProcessHandler();
 }
 
-//----------------------------------------------------------------------
 int cmCTest::ProcessTests()
 {
   int res = 0;
@@ -1135,7 +1107,6 @@ int cmCTest::ProcessTests()
   return res;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::GetTestModelString()
 {
   if ( !this->SpecificTrack.empty() )
@@ -1152,7 +1123,6 @@ std::string cmCTest::GetTestModelString()
   return "Experimental";
 }
 
-//----------------------------------------------------------------------
 int cmCTest::GetTestModelFromString(const char* str)
 {
   if ( !str )
@@ -1176,7 +1146,6 @@ int cmCTest::GetTestModelFromString(const char* str)
 //######################################################################
 //######################################################################
 
-//----------------------------------------------------------------------
 int cmCTest::RunMakeCommand(const char* command, std::string& output,
   int* retVal, const char* dir, int timeout, std::ostream& ofs)
 {
@@ -1294,7 +1263,6 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
 //######################################################################
 //######################################################################
 
-//----------------------------------------------------------------------
 int cmCTest::RunTest(std::vector<const char*> argv,
                      std::string* output, int *retVal,
                      std::ostream* log, double testTimeOut,
@@ -1472,7 +1440,6 @@ int cmCTest::RunTest(std::vector<const char*> argv,
   return result;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::SafeBuildIdField(const std::string& value)
 {
   std::string safevalue(value);
@@ -1507,7 +1474,6 @@ std::string cmCTest::SafeBuildIdField(const std::string& value)
   return safevalue;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::StartXML(cmXMLWriter& xml, bool append)
 {
   if(this->CurrentTag.empty())
@@ -1574,7 +1540,6 @@ void cmCTest::StartXML(cmXMLWriter& xml, bool append)
   this->AddSiteProperties(xml);
 }
 
-//----------------------------------------------------------------------
 void cmCTest::AddSiteProperties(cmXMLWriter& xml)
 {
   cmCTestScriptHandler* ch =
@@ -1622,14 +1587,12 @@ void cmCTest::AddSiteProperties(cmXMLWriter& xml)
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTest::EndXML(cmXMLWriter& xml)
 {
   xml.EndElement(); // Site
   xml.EndDocument();
 }
 
-//----------------------------------------------------------------------
 int cmCTest::GenerateCTestNotesOutput(cmXMLWriter& xml,
   const cmCTest::VectorOfStrings& files)
 {
@@ -1683,7 +1646,6 @@ int cmCTest::GenerateCTestNotesOutput(cmXMLWriter& xml,
   return 1;
 }
 
-//----------------------------------------------------------------------
 int cmCTest::GenerateNotesFile(const VectorOfStrings &files)
 {
   cmGeneratedFileStream ofs;
@@ -1697,7 +1659,6 @@ int cmCTest::GenerateNotesFile(const VectorOfStrings &files)
   return 0;
 }
 
-//----------------------------------------------------------------------
 int cmCTest::GenerateNotesFile(const char* cfiles)
 {
   if ( !cfiles )
@@ -1718,7 +1679,6 @@ int cmCTest::GenerateNotesFile(const char* cfiles)
   return this->GenerateNotesFile(files);
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::Base64GzipEncodeFile(std::string file)
 {
   std::string tarFile = file + "_temp.tar.gz";
@@ -1737,7 +1697,6 @@ std::string cmCTest::Base64GzipEncodeFile(std::string file)
   return base64;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::Base64EncodeFile(std::string file)
 {
   size_t const len = cmSystemTools::FileLength(file);
@@ -1768,7 +1727,6 @@ std::string cmCTest::Base64EncodeFile(std::string file)
 }
 
 
-//----------------------------------------------------------------------
 bool cmCTest::SubmitExtraFiles(const VectorOfStrings &files)
 {
   VectorOfStrings::const_iterator it;
@@ -1788,7 +1746,6 @@ bool cmCTest::SubmitExtraFiles(const VectorOfStrings &files)
   return true;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::SubmitExtraFiles(const char* cfiles)
 {
   if ( !cfiles )
@@ -1810,7 +1767,6 @@ bool cmCTest::SubmitExtraFiles(const char* cfiles)
 }
 
 
-//-------------------------------------------------------
 // for a -D argument convert the next argument into
 // the proper list of dashboard steps via SetTest
 bool cmCTest::AddTestsForDashboardType(std::string &targ)
@@ -1999,7 +1955,6 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
 }
 
 
-//----------------------------------------------------------------------
 void cmCTest::ErrorMessageUnknownDashDValue(std::string &val)
 {
   cmCTestLog(this, ERROR_MESSAGE,
@@ -2020,7 +1975,6 @@ void cmCTest::ErrorMessageUnknownDashDValue(std::string &val)
 }
 
 
-//----------------------------------------------------------------------
 bool cmCTest::CheckArgument(const std::string& arg, const char* varg1,
   const char* varg2)
 {
@@ -2028,7 +1982,6 @@ bool cmCTest::CheckArgument(const std::string& arg, const char* varg1,
 }
 
 
-//----------------------------------------------------------------------
 // Processes one command line argument (and its arguments if any)
 // for many simple options and then returns
 bool cmCTest::HandleCommandLineArguments(size_t &i,
@@ -2316,7 +2269,6 @@ bool cmCTest::HandleCommandLineArguments(size_t &i,
   return true;
 }
 
-//----------------------------------------------------------------------
 // handle the -S -SR and -SP arguments
 void cmCTest::HandleScriptArguments(size_t &i,
                                     std::vector<std::string> &args,
@@ -2362,7 +2314,6 @@ void cmCTest::HandleScriptArguments(size_t &i,
     }
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::AddVariableDefinition(const std::string &arg)
 {
   std::string name;
@@ -2378,7 +2329,6 @@ bool cmCTest::AddVariableDefinition(const std::string &arg)
   return false;
 }
 
-//----------------------------------------------------------------------
 // the main entry point of ctest, called from main
 int cmCTest::Run(std::vector<std::string> &args, std::string* output)
 {
@@ -2625,7 +2575,6 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
   return 1;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetNotesFiles(const char* notes)
 {
   if ( !notes )
@@ -2635,14 +2584,12 @@ void cmCTest::SetNotesFiles(const char* notes)
   this->NotesFiles = notes;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetStopTime(std::string time)
 {
   this->StopTime = time;
   this->DetermineNextDayStop();
 }
 
-//----------------------------------------------------------------------
 int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
 {
   bool found = false;
@@ -2719,7 +2666,6 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
   return 1;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
   std::vector<std::string>& vec)
 {
@@ -2740,7 +2686,6 @@ void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTest::PopulateCustomInteger(cmMakefile* mf, const std::string& def,
   int& val)
 {
@@ -2752,7 +2697,6 @@ void cmCTest::PopulateCustomInteger(cmMakefile* mf, const std::string& def,
   val = atoi(dval);
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::GetShortPathToFile(const char* cfname)
 {
   const std::string& sourceDir
@@ -2819,7 +2763,6 @@ std::string cmCTest::GetShortPathToFile(const char* cfname)
   return path;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::GetCTestConfiguration(const std::string& name)
 {
   if ( this->CTestConfigurationOverwrites.find(name) !=
@@ -2830,13 +2773,11 @@ std::string cmCTest::GetCTestConfiguration(const std::string& name)
   return this->CTestConfiguration[name];
 }
 
-//----------------------------------------------------------------------
 void cmCTest::EmptyCTestConfiguration()
 {
   this->CTestConfiguration.clear();
 }
 
-//----------------------------------------------------------------------
 void cmCTest::DetermineNextDayStop()
 {
   struct tm* lctime;
@@ -2876,7 +2817,6 @@ void cmCTest::DetermineNextDayStop()
     }
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetCTestConfiguration(const char *name, const char* value,
                                     bool suppress)
 {
@@ -2896,49 +2836,41 @@ void cmCTest::SetCTestConfiguration(const char *name, const char* value,
 }
 
 
-//----------------------------------------------------------------------
 std::string cmCTest::GetCurrentTag()
 {
   return this->CurrentTag;
 }
 
-//----------------------------------------------------------------------
 std::string cmCTest::GetBinaryDir()
 {
   return this->BinaryDir;
 }
 
-//----------------------------------------------------------------------
 std::string const& cmCTest::GetConfigType()
 {
   return this->ConfigType;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::GetShowOnly()
 {
   return this->ShowOnly;
 }
 
-//----------------------------------------------------------------------
 int cmCTest::GetMaxTestNameWidth() const
 {
   return this->MaxTestNameWidth;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetProduceXML(bool v)
 {
   this->ProduceXML = v;
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::GetProduceXML()
 {
   return this->ProduceXML;
 }
 
-//----------------------------------------------------------------------
 const char* cmCTest::GetSpecificTrack()
 {
   if ( this->SpecificTrack.empty() )
@@ -2948,7 +2880,6 @@ const char* cmCTest::GetSpecificTrack()
   return this->SpecificTrack.c_str();
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetSpecificTrack(const char* track)
 {
   if ( !track )
@@ -2959,13 +2890,11 @@ void cmCTest::SetSpecificTrack(const char* track)
   this->SpecificTrack = track;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::AddSubmitFile(Part part, const char* name)
 {
   this->Parts[part].SubmitFiles.push_back(name);
 }
 
-//----------------------------------------------------------------------
 void cmCTest::AddCTestConfigurationOverwrite(const std::string& overStr)
 {
   size_t epos = overStr.find("=");
@@ -2983,7 +2912,6 @@ void cmCTest::AddCTestConfigurationOverwrite(const std::string& overStr)
   this->CTestConfigurationOverwrites[key] = value;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetConfigType(const char* ct)
 {
   this->ConfigType = ct?ct:"";
@@ -2993,7 +2921,6 @@ void cmCTest::SetConfigType(const char* ct)
   cmSystemTools::PutEnv(confTypeEnv);
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::SetCTestConfigurationFromCMakeVariable(cmMakefile* mf,
   const char* dconfig, const std::string& cmake_var, bool suppress)
 {
@@ -3124,7 +3051,6 @@ bool cmCTest::RunCommand(
   return result;
 }
 
-//----------------------------------------------------------------------
 void cmCTest::SetOutputLogFileName(const char* name)
 {
   if ( this->OutputLogFile)
@@ -3138,7 +3064,6 @@ void cmCTest::SetOutputLogFileName(const char* name)
     }
 }
 
-//----------------------------------------------------------------------
 static const char* cmCTestStringLogType[] =
 {
   "DEBUG",
@@ -3151,7 +3076,6 @@ static const char* cmCTestStringLogType[] =
   0
 };
 
-//----------------------------------------------------------------------
 #ifdef cerr
 #  undef cerr
 #endif
@@ -3267,7 +3191,6 @@ void cmCTest::Log(int logType, const char* file, int line, const char* msg,
     }
 }
 
-//-------------------------------------------------------------------------
 double cmCTest::GetRemainingTimeAllowed()
 {
   if (!this->GetHandler("script"))
@@ -3281,7 +3204,6 @@ double cmCTest::GetRemainingTimeAllowed()
   return ch->GetRemainingTimeAllowed();
 }
 
-//----------------------------------------------------------------------
 void cmCTest::OutputTestErrors(std::vector<char> const &process_output)
 {
   std::string test_outputs("\n*** Test Failed:\n");
@@ -3292,7 +3214,6 @@ void cmCTest::OutputTestErrors(std::vector<char> const &process_output)
   cmCTestLog(this, HANDLER_OUTPUT, test_outputs << std::endl << std::flush);
 }
 
-//----------------------------------------------------------------------
 bool cmCTest::CompressString(std::string& str)
 {
   int ret;

Source/cmCacheManager.cxx

@@ -204,7 +204,6 @@ bool cmCacheManager::LoadCache(const std::string& path,
   return true;
 }
 
-//----------------------------------------------------------------------------
 const char* cmCacheManager::PersistentProperties[] =
 {
   "ADVANCED",
@@ -213,7 +212,6 @@ const char* cmCacheManager::PersistentProperties[] =
   0
 };
 
-//----------------------------------------------------------------------------
 bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
                                        CacheEntry& e)
 {
@@ -250,7 +248,6 @@ bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
   return false;
 }
 
-//----------------------------------------------------------------------------
 void cmCacheManager::WritePropertyEntries(std::ostream& os,
                                           CacheIterator const& i)
 {
@@ -640,13 +637,11 @@ void cmCacheManager::CacheIterator::SetValue(const char* value)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCacheManager::CacheIterator::GetValueAsBool() const
 {
   return cmSystemTools::IsOn(this->GetEntry().Value.c_str());
 }
 
-//----------------------------------------------------------------------------
 const char*
 cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
 {
@@ -661,7 +656,6 @@ cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
   return this->Properties.GetPropertyValue(prop);
 }
 
-//----------------------------------------------------------------------------
 void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
                                              const char* value)
 {
@@ -679,7 +673,6 @@ void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
                                                 const char* value,
                                                 bool asString)
@@ -705,7 +698,6 @@ void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
     }
 }
 
-//----------------------------------------------------------------------------
 const char* cmCacheManager::CacheIterator::GetProperty(
     const std::string& prop) const
 {
@@ -716,7 +708,6 @@ const char* cmCacheManager::CacheIterator::GetProperty(
   return 0;
 }
 
-//----------------------------------------------------------------------------
 void cmCacheManager::CacheIterator::SetProperty(const std::string& p,
                                                 const char* v)
 {
@@ -726,7 +717,6 @@ void cmCacheManager::CacheIterator::SetProperty(const std::string& p,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCacheManager::CacheIterator::AppendProperty(const std::string& p,
                                                    const char* v,
                                                    bool asString)
@@ -737,7 +727,6 @@ void cmCacheManager::CacheIterator::AppendProperty(const std::string& p,
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmCacheManager::CacheIterator::GetPropertyAsBool(
     const std::string& prop) const
 {
@@ -748,13 +737,11 @@ bool cmCacheManager::CacheIterator::GetPropertyAsBool(
   return false;
 }
 
-//----------------------------------------------------------------------------
 void cmCacheManager::CacheIterator::SetProperty(const std::string& p, bool v)
 {
   this->SetProperty(p, v ? "ON" : "OFF");
 }
 
-//----------------------------------------------------------------------------
 bool cmCacheManager::CacheIterator::PropertyExists(
     const std::string& prop) const
 {

Source/cmCallVisualStudioMacro.cxx

@@ -30,7 +30,6 @@ static bool LogErrorsAsMessages;
 #include <comdef.h>
 
 
-//----------------------------------------------------------------------------
 // Copied from a correct comdef.h to avoid problems with deficient versions
 // of comdef.h that exist in the wild... Fixes issue #7533.
 //
@@ -49,7 +48,6 @@ static bool LogErrorsAsMessages;
 #endif
 
 
-//----------------------------------------------------------------------------
 ///! Use ReportHRESULT to make a cmSystemTools::Message after calling
 ///! a COM method that may have failed.
 #define ReportHRESULT(hr, context) \
@@ -68,7 +66,6 @@ static bool LogErrorsAsMessages;
     }
 
 
-//----------------------------------------------------------------------------
 ///! Using the given instance of Visual Studio, call the named macro
 HRESULT InstanceCallMacro(
   IDispatch* vsIDE,
@@ -161,7 +158,6 @@ HRESULT InstanceCallMacro(
 }
 
 
-//----------------------------------------------------------------------------
 ///! Get the Solution object from the IDE object
 HRESULT GetSolutionObject(
   IDispatch* vsIDE,
@@ -211,7 +207,6 @@ HRESULT GetSolutionObject(
 }
 
 
-//----------------------------------------------------------------------------
 ///! Get the FullName property from the Solution object
 HRESULT GetSolutionFullName(
   IDispatch* vsSolution,
@@ -261,7 +256,6 @@ HRESULT GetSolutionFullName(
 }
 
 
-//----------------------------------------------------------------------------
 ///! Get the FullName property from the Solution object, given the IDE object
 HRESULT GetIDESolutionFullName(
   IDispatch* vsIDE,
@@ -281,7 +275,6 @@ HRESULT GetIDESolutionFullName(
 }
 
 
-//----------------------------------------------------------------------------
 ///! Get all running objects from the Windows running object table.
 ///! Save them in a map by their display names.
 HRESULT GetRunningInstances(std::map<std::string, IUnknownPtr>& mrot)
@@ -347,7 +340,6 @@ HRESULT GetRunningInstances(std::map<std::string, IUnknownPtr>& mrot)
 }
 
 
-//----------------------------------------------------------------------------
 ///! Do the two file names refer to the same Visual Studio solution? Or are
 ///! we perhaps looking for any and all solutions?
 bool FilesSameSolution(
@@ -370,7 +362,6 @@ bool FilesSameSolution(
 }
 
 
-//----------------------------------------------------------------------------
 ///! Find instances of Visual Studio with the given solution file
 ///! open. Pass "ALL" for slnFile to gather all running instances
 ///! of Visual Studio.
@@ -421,7 +412,6 @@ HRESULT FindVisualStudioInstances(
 #endif  //defined(HAVE_COMDEF_H)
 
 
-//----------------------------------------------------------------------------
 int cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
   const std::string& slnFile)
 {
@@ -457,7 +447,6 @@ int cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
 }
 
 
-//----------------------------------------------------------------------------
 ///! Get all running objects from the Windows running object table.
 ///! Save them in a map by their display names.
 int cmCallVisualStudioMacro::CallMacro(

Source/cmCommonTargetGenerator.cxx

@@ -52,19 +52,16 @@ std::string cmCommonTargetGenerator::Convert(
   return this->LocalGenerator->Convert(source, relative, output);
 }
 
-//----------------------------------------------------------------------------
 const char* cmCommonTargetGenerator::GetFeature(const std::string& feature)
 {
   return this->GeneratorTarget->GetFeature(feature, this->ConfigName);
 }
 
-//----------------------------------------------------------------------------
 bool cmCommonTargetGenerator::GetFeatureAsBool(const std::string& feature)
 {
   return this->GeneratorTarget->GetFeatureAsBool(feature, this->ConfigName);
 }
 
-//----------------------------------------------------------------------------
 void cmCommonTargetGenerator::AddFeatureFlags(
   std::string& flags, const std::string& lang
   )
@@ -78,7 +75,6 @@ void cmCommonTargetGenerator::AddFeatureFlags(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
 {
   if(!this->ModuleDefinitionFile)
@@ -102,7 +98,6 @@ void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
   this->LocalGenerator->AppendFlags(flags, flag);
 }
 
-//----------------------------------------------------------------------------
 std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const
 {
   std::string mod_dir;
@@ -132,7 +127,6 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const
   return mod_dir;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCommonTargetGenerator::GetFortranModuleDirectory()
 {
   // Compute the module directory.
@@ -146,7 +140,6 @@ std::string cmCommonTargetGenerator::GetFortranModuleDirectory()
   return this->FortranModuleDirectory;
 }
 
-//----------------------------------------------------------------------------
 void cmCommonTargetGenerator::AddFortranFlags(std::string& flags)
 {
   // Enable module output if necessary.
@@ -202,7 +195,6 @@ void cmCommonTargetGenerator::AddFortranFlags(std::string& flags)
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmCommonTargetGenerator
 ::AppendFortranFormatFlags(std::string& flags, cmSourceFile const& source)
@@ -231,7 +223,6 @@ cmCommonTargetGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l)
 {
  if(!this->Makefile->IsOn("APPLE"))
@@ -293,7 +284,6 @@ std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l)
   return flags;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCommonTargetGenerator::GetFlags(const std::string &l)
 {
   ByLanguageMap::iterator i = this->FlagsByLanguage.find(l);

Source/cmComputeComponentGraph.cxx

@@ -15,7 +15,6 @@
 
 #include <assert.h>
 
-//----------------------------------------------------------------------------
 cmComputeComponentGraph::cmComputeComponentGraph(Graph const& input):
   InputGraph(input)
 {
@@ -28,12 +27,10 @@ cmComputeComponentGraph::cmComputeComponentGraph(Graph const& input):
   this->TransferEdges();
 }
 
-//----------------------------------------------------------------------------
 cmComputeComponentGraph::~cmComputeComponentGraph()
 {
 }
 
-//----------------------------------------------------------------------------
 void cmComputeComponentGraph::Tarjan()
 {
   int n = static_cast<int>(this->InputGraph.size());
@@ -58,7 +55,6 @@ void cmComputeComponentGraph::Tarjan()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeComponentGraph::TarjanVisit(int i)
 {
   // We are now visiting this node.
@@ -133,7 +129,6 @@ void cmComputeComponentGraph::TarjanVisit(int i)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeComponentGraph::TransferEdges()
 {
   // Map inter-component edges in the original graph to edges in the

Source/cmComputeLinkDepends.cxx

@@ -170,7 +170,6 @@ items that we know the linker will re-use automatically (shared libs).
 
 */
 
-//----------------------------------------------------------------------------
 cmComputeLinkDepends
 ::cmComputeLinkDepends(const cmGeneratorTarget* target,
                        const std::string& config)
@@ -199,20 +198,17 @@ cmComputeLinkDepends
   this->CCG = 0;
 }
 
-//----------------------------------------------------------------------------
 cmComputeLinkDepends::~cmComputeLinkDepends()
 {
   cmDeleteAll(this->InferredDependSets);
   delete this->CCG;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::SetOldLinkDirMode(bool b)
 {
   this->OldLinkDirMode = b;
 }
 
-//----------------------------------------------------------------------------
 std::vector<cmComputeLinkDepends::LinkEntry> const&
 cmComputeLinkDepends::Compute()
 {
@@ -290,7 +286,6 @@ cmComputeLinkDepends::Compute()
   return this->FinalLinkEntries;
 }
 
-//----------------------------------------------------------------------------
 std::map<std::string, int>::iterator
 cmComputeLinkDepends::AllocateLinkEntry(std::string const& item)
 {
@@ -304,7 +299,6 @@ cmComputeLinkDepends::AllocateLinkEntry(std::string const& item)
   return lei;
 }
 
-//----------------------------------------------------------------------------
 int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
 {
   // Check if the item entry has already been added.
@@ -354,7 +348,6 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
   return index;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
 {
   // Get this entry representation.
@@ -397,7 +390,6 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeLinkDepends
 ::FollowSharedDeps(int depender_index, cmLinkInterface const* iface,
@@ -414,7 +406,6 @@ cmComputeLinkDepends
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeLinkDepends
 ::QueueSharedDependencies(int depender_index,
@@ -430,7 +421,6 @@ cmComputeLinkDepends
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
 {
   // Check if the target already has an entry.
@@ -472,7 +462,6 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
                                              const char* value)
 {
@@ -550,7 +539,6 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
   this->AddLinkEntries(depender_index, actual_libs);
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::AddDirectLinkEntries()
 {
   // Add direct link dependencies in this configuration.
@@ -565,7 +553,6 @@ void cmComputeLinkDepends::AddDirectLinkEntries()
     }
 }
 
-//----------------------------------------------------------------------------
 template <typename T>
 void
 cmComputeLinkDepends::AddLinkEntries(
@@ -632,7 +619,6 @@ cmComputeLinkDepends::AddLinkEntries(
     }
 }
 
-//----------------------------------------------------------------------------
 cmGeneratorTarget const*
 cmComputeLinkDepends::FindTargetToLink(int depender_index,
                                        const std::string& name)
@@ -650,7 +636,6 @@ cmComputeLinkDepends::FindTargetToLink(int depender_index,
   return from->FindTargetToLink(name);
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::InferDependencies()
 {
   // The inferred dependency sets for each item list the possible
@@ -685,7 +670,6 @@ void cmComputeLinkDepends::InferDependencies()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::CleanConstraintGraph()
 {
   for(Graph::iterator i = this->EntryConstraintGraph.begin();
@@ -700,7 +684,6 @@ void cmComputeLinkDepends::CleanConstraintGraph()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::DisplayConstraintGraph()
 {
   // Display the graph nodes and their edges.
@@ -714,7 +697,6 @@ void cmComputeLinkDepends::DisplayConstraintGraph()
   fprintf(stderr, "%s\n", e.str().c_str());
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::OrderLinkEntires()
 {
   // Compute the DAG of strongly connected components.  The algorithm
@@ -765,7 +747,6 @@ void cmComputeLinkDepends::OrderLinkEntires()
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeLinkDepends::DisplayComponents()
 {
@@ -793,7 +774,6 @@ cmComputeLinkDepends::DisplayComponents()
   fprintf(stderr, "\n");
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::VisitComponent(unsigned int c)
 {
   // Check if the node has already been visited.
@@ -819,7 +799,6 @@ void cmComputeLinkDepends::VisitComponent(unsigned int c)
   this->ComponentOrder[c] = --this->ComponentOrderId;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::VisitEntry(int index)
 {
   // Include this entry on the link line.
@@ -890,7 +869,6 @@ void cmComputeLinkDepends::VisitEntry(int index)
     }
 }
 
-//----------------------------------------------------------------------------
 cmComputeLinkDepends::PendingComponent&
 cmComputeLinkDepends::MakePendingComponent(unsigned int component)
 {
@@ -928,7 +906,6 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
   return pc;
 }
 
-//----------------------------------------------------------------------------
 int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
 {
   unsigned int count = 2;
@@ -949,7 +926,6 @@ int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
   return count;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::DisplayFinalEntries()
 {
   fprintf(stderr, "target [%s] links to:\n", this->Target->GetName().c_str());
@@ -969,7 +945,6 @@ void cmComputeLinkDepends::DisplayFinalEntries()
   fprintf(stderr, "\n");
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkDepends::CheckWrongConfigItem(cmLinkItem const& item)
 {
   if(!this->OldLinkDirMode)

Source/cmComputeLinkInformation.cxx

@@ -240,7 +240,6 @@ because this need be done only for shared libraries without soname-s.
 
 */
 
-//----------------------------------------------------------------------------
 cmComputeLinkInformation
 ::cmComputeLinkInformation(const cmGeneratorTarget* target,
                            const std::string& config)
@@ -422,7 +421,6 @@ cmComputeLinkInformation
       "CMAKE_POLICY_WARNING_CMP0060");
 }
 
-//----------------------------------------------------------------------------
 cmComputeLinkInformation::~cmComputeLinkInformation()
 {
   delete this->OrderLinkerSearchPath;
@@ -430,20 +428,17 @@ cmComputeLinkInformation::~cmComputeLinkInformation()
   delete this->OrderDependentRPath;
 }
 
-//----------------------------------------------------------------------------
 cmComputeLinkInformation::ItemVector const&
 cmComputeLinkInformation::GetItems()
 {
   return this->Items;
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const& cmComputeLinkInformation::GetDirectories()
 {
   return this->OrderLinkerSearchPath->GetOrderedDirectories();
 }
 
-//----------------------------------------------------------------------------
 std::string cmComputeLinkInformation::GetRPathLinkString()
 {
   // If there is no separate linker runtime search flag (-rpath-link)
@@ -457,26 +452,22 @@ std::string cmComputeLinkInformation::GetRPathLinkString()
   return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":");
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const& cmComputeLinkInformation::GetDepends()
 {
   return this->Depends;
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const& cmComputeLinkInformation::GetFrameworkPaths()
 {
   return this->FrameworkPaths;
 }
 
-//----------------------------------------------------------------------------
 const std::set<const cmGeneratorTarget*>&
 cmComputeLinkInformation::GetSharedLibrariesLinked()
 {
   return this->SharedLibrariesLinked;
 }
 
-//----------------------------------------------------------------------------
 bool cmComputeLinkInformation::Compute()
 {
   // Skip targets that do not link.
@@ -579,7 +570,6 @@ bool cmComputeLinkInformation::Compute()
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddImplicitLinkInfo()
 {
   // The link closure lists all languages whose implicit info is needed.
@@ -596,7 +586,6 @@ void cmComputeLinkInformation::AddImplicitLinkInfo()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
 {
   // Add libraries for this language that are not implied by the
@@ -631,7 +620,6 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddItem(std::string const& item,
                                        cmGeneratorTarget const* tgt)
 {
@@ -714,7 +702,6 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddSharedDepItem(std::string const& item,
                                                 const cmGeneratorTarget* tgt)
 {
@@ -804,7 +791,6 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::ComputeLinkTypeInfo()
 {
   // Check whether archives may actually be shared libraries.
@@ -861,7 +847,6 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
   this->CurrentLinkType = this->StartLinkType;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::ComputeItemParserInfo()
 {
   // Get possible library name prefixes.
@@ -960,7 +945,6 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddLinkPrefix(const char* p)
 {
   if(p && *p)
@@ -969,7 +953,6 @@ void cmComputeLinkInformation::AddLinkPrefix(const char* p)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddLinkExtension(const char* e, LinkType type)
 {
   if(e && *e)
@@ -986,7 +969,6 @@ void cmComputeLinkInformation::AddLinkExtension(const char* e, LinkType type)
     }
 }
 
-//----------------------------------------------------------------------------
 std::string
 cmComputeLinkInformation
 ::CreateExtensionRegex(std::vector<std::string> const& exts, LinkType type)
@@ -1027,7 +1009,6 @@ cmComputeLinkInformation
   return libext;
 }
 
-//----------------------------------------------------------------------------
 std::string cmComputeLinkInformation::NoCaseExpression(const char* str)
 {
   std::string ret;
@@ -1050,7 +1031,6 @@ std::string cmComputeLinkInformation::NoCaseExpression(const char* str)
   return ret;
 }
 
-//-------------------------------------------------------------------
 void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
 {
   // If we are changing the current link type add the flag to tell the
@@ -1076,7 +1056,6 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddTargetItem(std::string const& item,
                                              cmGeneratorTarget const* target)
 {
@@ -1124,7 +1103,6 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item,
   this->Items.push_back(Item(item, true, target));
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddFullItem(std::string const& item)
 {
   // Check for the implicit link directory special case.
@@ -1194,7 +1172,6 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item)
   this->Items.push_back(Item(item, true));
 }
 
-//----------------------------------------------------------------------------
 bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
 {
   // We only switch to a pathless item if the link type may be
@@ -1258,7 +1235,6 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddUserItem(std::string const& item,
                                            bool pathNotKnown)
 {
@@ -1376,7 +1352,6 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
   // specification.
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
 {
   // Try to separate the framework name and path.
@@ -1411,7 +1386,6 @@ void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
   this->Items.push_back(Item(fw, false));
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddDirectoryItem(std::string const& item)
 {
   if(this->Makefile->IsOn("APPLE")
@@ -1425,7 +1399,6 @@ void cmComputeLinkInformation::AddDirectoryItem(std::string const& item)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::DropDirectoryItem(std::string const& item)
 {
   // A full path to a directory was found as a link item.  Warn the
@@ -1438,7 +1411,6 @@ void cmComputeLinkInformation::DropDirectoryItem(std::string const& item)
   cmSystemTools::Message(e.str().c_str());
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::ComputeFrameworkInfo()
 {
   // Avoid adding implicit framework paths.
@@ -1468,7 +1440,6 @@ void cmComputeLinkInformation::ComputeFrameworkInfo()
   this->SplitFramework.compile("(.*)/(.*)\\.framework$");
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddFrameworkPath(std::string const& p)
 {
   if(this->FrameworkPathsEmmitted.insert(p).second)
@@ -1477,7 +1448,6 @@ void cmComputeLinkInformation::AddFrameworkPath(std::string const& p)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
 {
   // This platform will use the path to a library as its soname if the
@@ -1499,7 +1469,6 @@ bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
   return false;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddSharedLibNoSOName(std::string const& item)
 {
   // We have a full path to a shared library with no soname.  We need
@@ -1514,7 +1483,6 @@ void cmComputeLinkInformation::AddSharedLibNoSOName(std::string const& item)
   this->OrderLinkerSearchPath->AddLinkLibrary(item);
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
                                                  std::string const& file)
 {
@@ -1578,7 +1546,6 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
 {
   // Support broken projects if necessary.
@@ -1631,7 +1598,6 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
 {
   // Tell the user what to do.
@@ -1702,7 +1668,6 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
      << "Run \"cmake --help-policy CMP0003\" for more information.";
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::LoadImplicitLinkInfo()
 {
   std::vector<std::string> implicitDirVec;
@@ -1773,14 +1738,12 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
     }
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const&
 cmComputeLinkInformation::GetRuntimeSearchPath()
 {
   return this->OrderRuntimeSearchPath->GetOrderedDirectories();
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath,
                                               cmGeneratorTarget const* target)
@@ -1823,7 +1786,6 @@ cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath,
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath)
 {
@@ -1891,7 +1853,6 @@ cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath)
     }
 }
 
-//----------------------------------------------------------------------------
 static void cmCLI_ExpandListUnique(const char* str,
                                    std::vector<std::string>& out,
                                    std::set<std::string>& emitted)
@@ -1907,7 +1868,6 @@ static void cmCLI_ExpandListUnique(const char* str,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
                                         bool for_install)
 {
@@ -2033,7 +1993,6 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
   cmCLI_ExpandListUnique(this->RuntimeAlways.c_str(), runtimeDirs, emitted);
 }
 
-//----------------------------------------------------------------------------
 std::string cmComputeLinkInformation::GetRPathString(bool for_install)
 {
   // Get the directories to use.
@@ -2065,7 +2024,6 @@ std::string cmComputeLinkInformation::GetRPathString(bool for_install)
   return rpath;
 }
 
-//----------------------------------------------------------------------------
 std::string cmComputeLinkInformation::GetChrpathString()
 {
   if(!this->RuntimeUseChrpath)

Source/cmComputeTargetDepends.cxx

@@ -94,7 +94,6 @@ transitively on all the static libraries it links.
 
 */
 
-//----------------------------------------------------------------------------
 cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator* gg)
 {
   this->GlobalGenerator = gg;
@@ -105,12 +104,10 @@ cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator* gg)
                       ->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_NO_CYCLES");
 }
 
-//----------------------------------------------------------------------------
 cmComputeTargetDepends::~cmComputeTargetDepends()
 {
 }
 
-//----------------------------------------------------------------------------
 bool cmComputeTargetDepends::Compute()
 {
   // Build the original graph.
@@ -145,7 +142,6 @@ bool cmComputeTargetDepends::Compute()
   return true;
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeTargetDepends::GetTargetDirectDepends(cmGeneratorTarget const* t,
                                                cmTargetDependSet& deps)
@@ -167,7 +163,6 @@ cmComputeTargetDepends::GetTargetDirectDepends(cmGeneratorTarget const* t,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::CollectTargets()
 {
   // Collect all targets from all generators.
@@ -188,7 +183,6 @@ void cmComputeTargetDepends::CollectTargets()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::CollectDepends()
 {
   // Allocate the dependency graph adjacency lists.
@@ -201,7 +195,6 @@ void cmComputeTargetDepends::CollectDepends()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
 {
   // Get the depender.
@@ -287,7 +280,6 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
   }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
                                              const cmGeneratorTarget* dependee,
                                              const std::string& config,
@@ -312,7 +304,6 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
                                              cmLinkItem const& dependee_name,
                                              std::set<std::string> &emitted)
@@ -344,7 +335,6 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::AddTargetDepend(
   int depender_index, cmLinkItem const& dependee_name,
   bool linking)
@@ -411,7 +401,6 @@ void cmComputeTargetDepends::AddTargetDepend(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmComputeTargetDepends::AddTargetDepend(int depender_index,
                                              const cmGeneratorTarget* dependee,
                                              bool linking)
@@ -446,7 +435,6 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeTargetDepends::DisplayGraph(Graph const& graph,
                                      const std::string& name)
@@ -470,7 +458,6 @@ cmComputeTargetDepends::DisplayGraph(Graph const& graph,
   fprintf(stderr, "\n");
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeTargetDepends
 ::DisplayComponents(cmComputeComponentGraph const& ccg)
@@ -492,7 +479,6 @@ cmComputeTargetDepends
   fprintf(stderr, "\n");
 }
 
-//----------------------------------------------------------------------------
 bool
 cmComputeTargetDepends
 ::CheckComponents(cmComputeComponentGraph const& ccg)
@@ -532,7 +518,6 @@ cmComputeTargetDepends
   return true;
 }
 
-//----------------------------------------------------------------------------
 void
 cmComputeTargetDepends
 ::ComplainAboutBadComponent(cmComputeComponentGraph const& ccg, int c,
@@ -589,7 +574,6 @@ cmComputeTargetDepends
   cmSystemTools::Error(e.str().c_str());
 }
 
-//----------------------------------------------------------------------------
 bool
 cmComputeTargetDepends
 ::IntraComponent(std::vector<int> const& cmap, int c, int i, int* head,
@@ -631,7 +615,6 @@ cmComputeTargetDepends
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmComputeTargetDepends
 ::ComputeFinalDepends(cmComputeComponentGraph const& ccg)

Source/cmCryptoHash.cxx

@@ -15,7 +15,6 @@
 #include <cmsys/FStream.hxx>
 #include <cmsys/MD5.h>
 
-//----------------------------------------------------------------------------
 cmsys::auto_ptr<cmCryptoHash> cmCryptoHash::New(const char* algo)
 {
   if(strcmp(algo,"MD5") == 0)
@@ -34,7 +33,6 @@ cmsys::auto_ptr<cmCryptoHash> cmCryptoHash::New(const char* algo)
     { return cmsys::auto_ptr<cmCryptoHash>(0); }
 }
 
-//----------------------------------------------------------------------------
 std::string cmCryptoHash::HashString(const std::string& input)
 {
   this->Initialize();
@@ -43,7 +41,6 @@ std::string cmCryptoHash::HashString(const std::string& input)
   return this->Finalize();
 }
 
-//----------------------------------------------------------------------------
 std::string cmCryptoHash::HashFile(const std::string& file)
 {
   cmsys::ifstream fin(file.c_str(), std::ios::in | std::ios::binary);
@@ -79,30 +76,25 @@ std::string cmCryptoHash::HashFile(const std::string& file)
   return "";
 }
 
-//----------------------------------------------------------------------------
 cmCryptoHashMD5::cmCryptoHashMD5(): MD5(cmsysMD5_New())
 {
 }
 
-//----------------------------------------------------------------------------
 cmCryptoHashMD5::~cmCryptoHashMD5()
 {
   cmsysMD5_Delete(this->MD5);
 }
 
-//----------------------------------------------------------------------------
 void cmCryptoHashMD5::Initialize()
 {
   cmsysMD5_Initialize(this->MD5);
 }
 
-//----------------------------------------------------------------------------
 void cmCryptoHashMD5::Append(unsigned char const* buf, int sz)
 {
   cmsysMD5_Append(this->MD5, buf, sz);
 }
 
-//----------------------------------------------------------------------------
 std::string cmCryptoHashMD5::Finalize()
 {
   char md5out[32];

Source/cmCurl.cxx

@@ -26,7 +26,6 @@
     e += ::curl_easy_strerror(result);                                  \
     }
 
-//----------------------------------------------------------------------------
 std::string cmCurlSetCAInfo(::CURL *curl, const char* cafile)
 {
   std::string e;

Source/cmCustomCommand.cxx

@@ -15,7 +15,6 @@
 
 #include <cmsys/auto_ptr.hxx>
 
-//----------------------------------------------------------------------------
 cmCustomCommand::cmCustomCommand()
   : Backtrace()
 {
@@ -25,7 +24,6 @@ cmCustomCommand::cmCustomCommand()
   this->UsesTerminal = false;
 }
 
-//----------------------------------------------------------------------------
 cmCustomCommand::cmCustomCommand(cmMakefile const* mf,
                                  const std::vector<std::string>& outputs,
                                  const std::vector<std::string>& byproducts,
@@ -50,107 +48,90 @@ cmCustomCommand::cmCustomCommand(cmMakefile const* mf,
     }
 }
 
-//----------------------------------------------------------------------------
 const std::vector<std::string>& cmCustomCommand::GetOutputs() const
 {
   return this->Outputs;
 }
 
-//----------------------------------------------------------------------------
 const std::vector<std::string>& cmCustomCommand::GetByproducts() const
 {
   return this->Byproducts;
 }
 
-//----------------------------------------------------------------------------
 const std::vector<std::string>& cmCustomCommand::GetDepends() const
 {
   return this->Depends;
 }
 
-//----------------------------------------------------------------------------
 const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const
 {
   return this->CommandLines;
 }
 
-//----------------------------------------------------------------------------
 const char* cmCustomCommand::GetComment() const
 {
   const char* no_comment = 0;
   return this->HaveComment? this->Comment.c_str() : no_comment;
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::AppendCommands(const cmCustomCommandLines& commandLines)
 {
   this->CommandLines.insert(this->CommandLines.end(),
                             commandLines.begin(), commandLines.end());
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::AppendDepends(const std::vector<std::string>& depends)
 {
   this->Depends.insert(this->Depends.end(), depends.begin(), depends.end());
 }
 
-//----------------------------------------------------------------------------
 bool cmCustomCommand::GetEscapeOldStyle() const
 {
   return this->EscapeOldStyle;
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::SetEscapeOldStyle(bool b)
 {
   this->EscapeOldStyle = b;
 }
 
-//----------------------------------------------------------------------------
 bool cmCustomCommand::GetEscapeAllowMakeVars() const
 {
   return this->EscapeAllowMakeVars;
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::SetEscapeAllowMakeVars(bool b)
 {
   this->EscapeAllowMakeVars = b;
 }
 
-//----------------------------------------------------------------------------
 cmListFileBacktrace const& cmCustomCommand::GetBacktrace() const
 {
   return this->Backtrace;
 }
 
-//----------------------------------------------------------------------------
 cmCustomCommand::ImplicitDependsList const&
 cmCustomCommand::GetImplicitDepends() const
 {
   return this->ImplicitDepends;
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::SetImplicitDepends(ImplicitDependsList const& l)
 {
   this->ImplicitDepends = l;
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::AppendImplicitDepends(ImplicitDependsList const& l)
 {
   this->ImplicitDepends.insert(this->ImplicitDepends.end(),
                                l.begin(), l.end());
 }
 
-//----------------------------------------------------------------------------
 bool cmCustomCommand::GetUsesTerminal() const
 {
   return this->UsesTerminal;
 }
 
-//----------------------------------------------------------------------------
 void cmCustomCommand::SetUsesTerminal(bool b)
 {
   this->UsesTerminal = b;

Source/cmCustomCommandGenerator.cxx

@@ -17,7 +17,6 @@
 #include "cmMakefile.h"
 #include "cmOutputConverter.h"
 
-//----------------------------------------------------------------------------
 cmCustomCommandGenerator::cmCustomCommandGenerator(
   cmCustomCommand const& cc, const std::string& config, cmLocalGenerator* lg):
   CC(cc), Config(config), LG(lg),
@@ -26,19 +25,16 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(
 {
 }
 
-//----------------------------------------------------------------------------
 cmCustomCommandGenerator::~cmCustomCommandGenerator()
 {
   delete this->GE;
 }
 
-//----------------------------------------------------------------------------
 unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
 {
   return static_cast<unsigned int>(this->CC.GetCommandLines().size());
 }
 
-//----------------------------------------------------------------------------
 bool cmCustomCommandGenerator::UseCrossCompilingEmulator(unsigned int c) const
 {
   std::string const& argv0 = this->CC.GetCommandLines()[c][0];
@@ -51,7 +47,6 @@ bool cmCustomCommandGenerator::UseCrossCompilingEmulator(unsigned int c) const
   return false;
 }
 
-//----------------------------------------------------------------------------
 std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
 {
   std::string const& argv0 = this->CC.GetCommandLines()[c][0];
@@ -78,7 +73,6 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
   return exe;
 }
 
-//----------------------------------------------------------------------------
 std::string escapeForShellOldStyle(const std::string& str)
 {
   std::string result;
@@ -107,7 +101,6 @@ std::string escapeForShellOldStyle(const std::string& str)
 #endif
 }
 
-//----------------------------------------------------------------------------
 void
 cmCustomCommandGenerator
 ::AppendArguments(unsigned int c, std::string& cmd) const
@@ -136,31 +129,26 @@ cmCustomCommandGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 const char* cmCustomCommandGenerator::GetComment() const
 {
   return this->CC.GetComment();
 }
 
-//----------------------------------------------------------------------------
 std::string cmCustomCommandGenerator::GetWorkingDirectory() const
 {
   return this->CC.GetWorkingDirectory();
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const& cmCustomCommandGenerator::GetOutputs() const
 {
   return this->CC.GetOutputs();
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const& cmCustomCommandGenerator::GetByproducts() const
 {
   return this->CC.GetByproducts();
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const
 {
   if (!this->DependsDone)

Source/cmDefinitions.cxx

@@ -13,10 +13,8 @@
 
 #include <assert.h>
 
-//----------------------------------------------------------------------------
 cmDefinitions::Def cmDefinitions::NoDef;
 
-//----------------------------------------------------------------------------
 cmDefinitions::Def const& cmDefinitions::GetInternal(
   const std::string& key, StackIter begin, StackIter end, bool raise)
 {
@@ -41,7 +39,6 @@ cmDefinitions::Def const& cmDefinitions::GetInternal(
   return begin->Map.insert(MapType::value_type(key, def)).first->second;
 }
 
-//----------------------------------------------------------------------------
 const char* cmDefinitions::Get(const std::string& key,
     StackIter begin, StackIter end)
 {
@@ -69,14 +66,12 @@ bool cmDefinitions::HasKey(const std::string& key,
   return false;
 }
 
-//----------------------------------------------------------------------------
 void cmDefinitions::Set(const std::string& key, const char* value)
 {
   Def def(value);
   this->Map[key] = def;
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string> cmDefinitions::UnusedKeys() const
 {
   std::vector<std::string> keys;
@@ -93,7 +88,6 @@ std::vector<std::string> cmDefinitions::UnusedKeys() const
   return keys;
 }
 
-//----------------------------------------------------------------------------
 cmDefinitions cmDefinitions::MakeClosure(StackIter begin,
                                          StackIter end)
 {
@@ -123,7 +117,6 @@ cmDefinitions cmDefinitions::MakeClosure(StackIter begin,
   return closure;
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string>
 cmDefinitions::ClosureKeys(StackIter begin, StackIter end)
 {

Source/cmDepends.cxx

@@ -19,7 +19,6 @@
 #include <cmsys/FStream.hxx>
 #include <string.h>
 
-//----------------------------------------------------------------------------
 cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir):
   CompileDirectory(),
   LocalGenerator(lg),
@@ -32,14 +31,12 @@ cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir):
 {
 }
 
-//----------------------------------------------------------------------------
 cmDepends::~cmDepends()
 {
   delete [] this->Dependee;
   delete [] this->Depender;
 }
 
-//----------------------------------------------------------------------------
 bool cmDepends::Write(std::ostream &makeDepends,
                       std::ostream &internalDepends)
 {
@@ -76,14 +73,12 @@ bool cmDepends::Write(std::ostream &makeDepends,
   return this->Finalize(makeDepends, internalDepends);
 }
 
-//----------------------------------------------------------------------------
 bool cmDepends::Finalize(std::ostream&,
                          std::ostream&)
 {
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDepends::Check(const char *makeFile, const char *internalFile,
                       std::map<std::string, DependencyVector>& validDeps)
 {
@@ -117,7 +112,6 @@ bool cmDepends::Check(const char *makeFile, const char *internalFile,
   return okay;
 }
 
-//----------------------------------------------------------------------------
 void cmDepends::Clear(const char *file)
 {
   // Print verbose output.
@@ -135,7 +129,6 @@ void cmDepends::Clear(const char *file)
     << "# This may be replaced when dependencies are built." << std::endl;
 }
 
-//----------------------------------------------------------------------------
 bool cmDepends::WriteDependencies(
     const std::set<std::string>&, const std::string&,
     std::ostream&, std::ostream&)
@@ -144,7 +137,6 @@ bool cmDepends::WriteDependencies(
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDepends::CheckDependencies(std::istream& internalDepends,
                                   const char* internalDependsFileName,
                             std::map<std::string, DependencyVector>& validDeps)
@@ -291,7 +283,6 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends,
   return okay;
 }
 
-//----------------------------------------------------------------------------
 void cmDepends::SetIncludePathFromLanguage(const std::string& lang)
 {
   // Look for the new per "TARGET_" variant first:

Source/cmDependsC.cxx

@@ -29,13 +29,11 @@
 #define INCLUDE_REGEX_COMPLAIN_MARKER "#IncludeRegexComplain: "
 #define INCLUDE_REGEX_TRANSFORM_MARKER "#IncludeRegexTransform: "
 
-//----------------------------------------------------------------------------
 cmDependsC::cmDependsC()
 : ValidDeps(0)
 {
 }
 
-//----------------------------------------------------------------------------
 cmDependsC::cmDependsC(cmLocalGenerator* lg,
                    const char* targetDir,
                    const std::string& lang,
@@ -87,14 +85,12 @@ cmDependsC::cmDependsC(cmLocalGenerator* lg,
   this->ReadCacheFile();
 }
 
-//----------------------------------------------------------------------------
 cmDependsC::~cmDependsC()
 {
   this->WriteCacheFile();
   cmDeleteAll(this->FileCache);
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
                                    const std::string& obj,
                                    std::ostream& makeDepends,
@@ -292,7 +288,6 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmDependsC::ReadCacheFile()
 {
   if(this->CacheFileName.empty())
@@ -381,7 +376,6 @@ void cmDependsC::ReadCacheFile()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsC::WriteCacheFile() const
 {
   if(this->CacheFileName.empty())
@@ -426,7 +420,6 @@ void cmDependsC::WriteCacheFile() const
    }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsC::Scan(std::istream& is, const char* directory,
   const std::string& fullName)
 {
@@ -484,7 +477,6 @@ void cmDependsC::Scan(std::istream& is, const char* directory,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsC::SetupTransforms()
 {
   // Get the transformation rules.
@@ -532,7 +524,6 @@ void cmDependsC::SetupTransforms()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsC::ParseTransform(std::string const& xform)
 {
   // A transform rule is of the form SOME_MACRO(%)=value-with-%
@@ -547,7 +538,6 @@ void cmDependsC::ParseTransform(std::string const& xform)
   this->TransformRules[name] = value;
 }
 
-//----------------------------------------------------------------------------
 void cmDependsC::TransformLine(std::string& line)
 {
   // Check for a transform rule match.  Return if none.

Source/cmDependsFortran.cxx

@@ -24,7 +24,6 @@
 // use lower case and some always use upper case.  I do not know if any
 // use the case from the source code.
 
-//----------------------------------------------------------------------------
 class cmDependsFortranInternals
 {
 public:
@@ -55,13 +54,11 @@ public:
     }
 };
 
-//----------------------------------------------------------------------------
 cmDependsFortran::cmDependsFortran():
   Internal(0)
 {
 }
 
-//----------------------------------------------------------------------------
 cmDependsFortran
 ::cmDependsFortran(cmLocalGenerator* lg):
   cmDepends(lg),
@@ -94,13 +91,11 @@ cmDependsFortran
     }
 }
 
-//----------------------------------------------------------------------------
 cmDependsFortran::~cmDependsFortran()
 {
   delete this->Internal;
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsFortran::WriteDependencies(
     const std::set<std::string>& sources, const std::string& obj,
     std::ostream&, std::ostream&)
@@ -143,7 +138,6 @@ bool cmDependsFortran::WriteDependencies(
   return okay;
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsFortran::Finalize(std::ostream& makeDepends,
                                 std::ostream& internalDepends)
 {
@@ -232,7 +226,6 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmDependsFortran::LocateModules()
 {
   // Collect the set of modules provided and required by all sources.
@@ -283,7 +276,6 @@ void cmDependsFortran::LocateModules()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsFortran::MatchLocalModules()
 {
   const char* stampDir = this->TargetDirectory.c_str();
@@ -295,7 +287,6 @@ void cmDependsFortran::MatchLocalModules()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsFortran::MatchRemoteModules(std::istream& fin,
                                           const char* stampDir)
 {
@@ -327,7 +318,6 @@ void cmDependsFortran::MatchRemoteModules(std::istream& fin,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDependsFortran::ConsiderModule(const char* name,
                                       const char* stampDir)
 {
@@ -347,7 +337,6 @@ void cmDependsFortran::ConsiderModule(const char* name,
     }
 }
 
-//----------------------------------------------------------------------------
 bool
 cmDependsFortran
 ::WriteDependenciesReal(const char *obj,
@@ -516,7 +505,6 @@ cmDependsFortran
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsFortran::FindModule(std::string const& name,
                                   std::string& module)
 {
@@ -554,7 +542,6 @@ bool cmDependsFortran::FindModule(std::string const& name,
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
 {
   // Implements
@@ -620,7 +607,6 @@ bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
   return false;
 }
 
-//----------------------------------------------------------------------------
 // Helper function to look for a short sequence in a stream.  If this
 // is later used for longer sequences it should be re-written using an
 // efficient string search algorithm such as Boyer-Moore.
@@ -656,7 +642,6 @@ bool cmFortranStreamContainsSequence(std::istream& ifs,
   return true;
 }
 
-//----------------------------------------------------------------------------
 // Helper function to compare the remaining content in two streams.
 static bool cmFortranStreamsDiffer(std::istream& ifs1,
                                           std::istream& ifs2)
@@ -684,7 +669,6 @@ static bool cmFortranStreamsDiffer(std::istream& ifs1,
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsFortran::ModulesDiffer(const char* modFile,
                                      const char* stampFile,
                                      const char* compilerId)

Source/cmDependsJava.cxx

@@ -14,17 +14,14 @@
 #include "cmDependsJavaParserHelper.h"
 #include "cmSystemTools.h"
 
-//----------------------------------------------------------------------------
 cmDependsJava::cmDependsJava()
 {
 }
 
-//----------------------------------------------------------------------------
 cmDependsJava::~cmDependsJava()
 {
 }
 
-//----------------------------------------------------------------------------
 bool cmDependsJava::WriteDependencies(const std::set<std::string>& sources,
     const std::string&, std::ostream&, std::ostream&)
 {

Source/cmDocumentation.cxx

@@ -24,7 +24,6 @@
 
 #include <algorithm>
 
-//----------------------------------------------------------------------------
 static const char *cmDocumentationStandardOptions[][2] =
 {
   {"--help,-help,-usage,-h,-H,/?",
@@ -70,7 +69,6 @@ static const char *cmDocumentationStandardOptions[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 static const char *cmDocumentationGeneratorsHeader[][2] =
 {
   {0,
@@ -78,20 +76,17 @@ static const char *cmDocumentationGeneratorsHeader[][2] =
   {0,0}
 };
 
-//----------------------------------------------------------------------------
 cmDocumentation::cmDocumentation()
 {
   this->addCommonStandardDocSections();
   this->ShowGenerators = true;
 }
 
-//----------------------------------------------------------------------------
 cmDocumentation::~cmDocumentation()
 {
   cmDeleteAll(this->AllSections);
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintVersion(std::ostream& os)
 {
   /* clang-format off */
@@ -105,7 +100,6 @@ bool cmDocumentation::PrintVersion(std::ostream& os)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintDocumentation(Type ht, std::ostream& os)
 {
   switch (ht)
@@ -150,7 +144,6 @@ bool cmDocumentation::PrintDocumentation(Type ht, std::ostream& os)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintRequestedDocumentation(std::ostream& os)
 {
   int count = 0;
@@ -233,7 +226,6 @@ void cmDocumentation::WarnFormFromFilename(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::addCommonStandardDocSections()
 {
     cmDocumentationSection *sec;
@@ -243,7 +235,6 @@ void cmDocumentation::addCommonStandardDocSections()
     this->AllSections["Options"] = sec;
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::addCMakeStandardDocSections()
 {
     cmDocumentationSection *sec;
@@ -253,7 +244,6 @@ void cmDocumentation::addCMakeStandardDocSections()
     this->AllSections["Generators"] = sec;
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::addCTestStandardDocSections()
 {
     // This is currently done for backward compatibility reason
@@ -261,7 +251,6 @@ void cmDocumentation::addCTestStandardDocSections()
     addCMakeStandardDocSections();
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::addCPackStandardDocSections()
 {
     cmDocumentationSection *sec;
@@ -271,7 +260,6 @@ void cmDocumentation::addCPackStandardDocSections()
     this->AllSections["Generators"] = sec;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::CheckOptions(int argc, const char* const* argv,
                                    const char* exitOpt)
 {
@@ -482,13 +470,11 @@ bool cmDocumentation::CheckOptions(int argc, const char* const* argv,
   return result;
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::SetName(const std::string& name)
 {
   this->NameString = name;
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::SetSection(const char *name,
                                  cmDocumentationSection *section)
 {
@@ -499,7 +485,6 @@ void cmDocumentation::SetSection(const char *name,
   this->AllSections[name] = section;
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::SetSection(const char *name,
                                  std::vector<cmDocumentationEntry> &docs)
 {
@@ -510,7 +495,6 @@ void cmDocumentation::SetSection(const char *name,
   this->SetSection(name,sec);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::SetSection(const char *name,
                                  const char *docs[][2])
 {
@@ -521,7 +505,6 @@ void cmDocumentation::SetSection(const char *name,
   this->SetSection(name,sec);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation
 ::SetSections(std::map<std::string,cmDocumentationSection *> &sections)
 {
@@ -532,7 +515,6 @@ void cmDocumentation
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::PrependSection(const char *name,
                                      const char *docs[][2])
 {
@@ -550,7 +532,6 @@ void cmDocumentation::PrependSection(const char *name,
   sec->Prepend(docs);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::PrependSection(const char *name,
                                      std::vector<cmDocumentationEntry> &docs)
 {
@@ -568,7 +549,6 @@ void cmDocumentation::PrependSection(const char *name,
   sec->Prepend(docs);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::AppendSection(const char *name,
                                     const char *docs[][2])
 {
@@ -586,7 +566,6 @@ void cmDocumentation::AppendSection(const char *name,
   sec->Append(docs);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::AppendSection(const char *name,
                                     std::vector<cmDocumentationEntry> &docs)
 {
@@ -604,7 +583,6 @@ void cmDocumentation::AppendSection(const char *name,
   sec->Append(docs);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::AppendSection(const char *name,
                                     cmDocumentationEntry &docs)
 {
@@ -614,7 +592,6 @@ void cmDocumentation::AppendSection(const char *name,
   this->AppendSection(name,docsVec);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::PrependSection(const char *name,
                                      cmDocumentationEntry &docs)
 {
@@ -624,7 +601,6 @@ void cmDocumentation::PrependSection(const char *name,
   this->PrependSection(name,docsVec);
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::GlobHelp(std::vector<std::string>& files,
                                std::string const& pattern)
 {
@@ -637,7 +613,6 @@ void cmDocumentation::GlobHelp(std::vector<std::string>& files,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentation::PrintNames(std::ostream& os,
                                  std::string const& pattern)
 {
@@ -666,7 +641,6 @@ void cmDocumentation::PrintNames(std::ostream& os,
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintFiles(std::ostream& os,
                                  std::string const& pattern)
 {
@@ -683,13 +657,11 @@ bool cmDocumentation::PrintFiles(std::ostream& os,
   return found;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpFull(std::ostream& os)
 {
   return this->PrintFiles(os, "index");
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpOneManual(std::ostream& os)
 {
   std::string mname = this->CurrentArgument;
@@ -711,14 +683,12 @@ bool cmDocumentation::PrintHelpOneManual(std::ostream& os)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListManuals(std::ostream& os)
 {
   this->PrintNames(os, "manual/*");
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpOneCommand(std::ostream& os)
 {
   std::string cname = cmSystemTools::LowerCase(this->CurrentArgument);
@@ -733,14 +703,12 @@ bool cmDocumentation::PrintHelpOneCommand(std::ostream& os)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListCommands(std::ostream& os)
 {
   this->PrintNames(os, "command/*");
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpOneModule(std::ostream& os)
 {
   std::string mname = this->CurrentArgument;
@@ -754,7 +722,6 @@ bool cmDocumentation::PrintHelpOneModule(std::ostream& os)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListModules(std::ostream& os)
 {
   std::vector<std::string> files;
@@ -775,7 +742,6 @@ bool cmDocumentation::PrintHelpListModules(std::ostream& os)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpOneProperty(std::ostream& os)
 {
   std::string pname = cmSystemTools::HelpFileName(this->CurrentArgument);
@@ -790,14 +756,12 @@ bool cmDocumentation::PrintHelpOneProperty(std::ostream& os)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListProperties(std::ostream& os)
 {
   this->PrintNames(os, "prop_*/*");
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpOnePolicy(std::ostream& os)
 {
   std::string pname = this->CurrentArgument;
@@ -813,14 +777,12 @@ bool cmDocumentation::PrintHelpOnePolicy(std::ostream& os)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListPolicies(std::ostream& os)
 {
   this->PrintNames(os, "policy/*");
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListGenerators(std::ostream& os)
 {
   std::map<std::string,cmDocumentationSection*>::iterator si;
@@ -833,7 +795,6 @@ bool cmDocumentation::PrintHelpListGenerators(std::ostream& os)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpOneVariable(std::ostream& os)
 {
   std::string vname = cmSystemTools::HelpFileName(this->CurrentArgument);
@@ -848,14 +809,12 @@ bool cmDocumentation::PrintHelpOneVariable(std::ostream& os)
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelpListVariables(std::ostream& os)
 {
   this->PrintNames(os, "variable/*");
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintUsage(std::ostream& os)
 {
   std::map<std::string,cmDocumentationSection*>::iterator si;
@@ -867,7 +826,6 @@ bool cmDocumentation::PrintUsage(std::ostream& os)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintHelp(std::ostream& os)
 {
   std::map<std::string,cmDocumentationSection*>::iterator si;
@@ -892,7 +850,6 @@ bool cmDocumentation::PrintHelp(std::ostream& os)
   return true;
 }
 
-//----------------------------------------------------------------------------
 const char* cmDocumentation::GetNameString() const
 {
   if(!this->NameString.empty())
@@ -905,14 +862,12 @@ const char* cmDocumentation::GetNameString() const
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::IsOption(const char* arg) const
 {
   return ((arg[0] == '-') || (strcmp(arg, "/V") == 0) ||
           (strcmp(arg, "/?") == 0));
 }
 
-//----------------------------------------------------------------------------
 bool cmDocumentation::PrintOldCustomModules(std::ostream& os)
 {
   // CheckOptions abuses the Argument field to give us the file name.

Source/cmDocumentationSection.cxx

@@ -12,7 +12,6 @@
 #include "cmDocumentationSection.h"
 
 
-//----------------------------------------------------------------------------
 void cmDocumentationSection::Append(const char *data[][2])
 {
   int i = 0;
@@ -24,7 +23,6 @@ void cmDocumentationSection::Append(const char *data[][2])
     }
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentationSection::Prepend(const char *data[][2])
 {
   std::vector<cmDocumentationEntry> tmp;
@@ -38,7 +36,6 @@ void cmDocumentationSection::Prepend(const char *data[][2])
   this->Entries.insert(this->Entries.begin(),tmp.begin(),tmp.end());
 }
 
-//----------------------------------------------------------------------------
 void cmDocumentationSection::Append(const char *n, const char *b)
 {
   this->Entries.push_back(cmDocumentationEntry(n,b));

Source/cmELF.cxx

@@ -47,7 +47,6 @@
 # include <sys/link.h> // For dynamic section information
 #endif
 
-//----------------------------------------------------------------------------
 // Low-level byte swapping implementation.
 template <size_t s> struct cmELFByteSwapSize {};
 void cmELFByteSwap(char*, cmELFByteSwapSize<1> const&)
@@ -80,7 +79,6 @@ void cmELFByteSwap(T& x)
   cmELFByteSwap(reinterpret_cast<char*>(&x), cmELFByteSwapSize<sizeof(T)>());
 }
 
-//----------------------------------------------------------------------------
 class cmELFInternal
 {
 public:
@@ -187,7 +185,6 @@ protected:
   std::map<unsigned int, StringEntry> DynamicSectionStrings;
 };
 
-//----------------------------------------------------------------------------
 // Configure the implementation template for 32-bit ELF files.
 struct cmELFTypes32
 {
@@ -210,7 +207,6 @@ struct cmELFTypes64
   static const char* GetName() { return "64-bit"; }
 };
 
-//----------------------------------------------------------------------------
 // Parser implementation template.
 template <class Types>
 class cmELFInternalImpl: public cmELFInternal
@@ -479,7 +475,6 @@ private:
   std::vector<ELF_Dyn> DynamicSectionEntries;
 };
 
-//----------------------------------------------------------------------------
 template <class Types>
 cmELFInternalImpl<Types>
 ::cmELFInternalImpl(cmELF* external,
@@ -548,7 +543,6 @@ cmELFInternalImpl<Types>
     }
 }
 
-//----------------------------------------------------------------------------
 template <class Types>
 bool cmELFInternalImpl<Types>::LoadDynamicSection()
 {
@@ -593,7 +587,6 @@ bool cmELFInternalImpl<Types>::LoadDynamicSection()
   return true;
 }
 
-//----------------------------------------------------------------------------
 template <class Types>
 unsigned int cmELFInternalImpl<Types>::GetDynamicEntryCount()
 {
@@ -611,7 +604,6 @@ unsigned int cmELFInternalImpl<Types>::GetDynamicEntryCount()
   return static_cast<unsigned int>(this->DynamicSectionEntries.size());
 }
 
-//----------------------------------------------------------------------------
 template <class Types>
 unsigned long cmELFInternalImpl<Types>::GetDynamicEntryPosition(int j)
 {
@@ -627,7 +619,6 @@ unsigned long cmELFInternalImpl<Types>::GetDynamicEntryPosition(int j)
   return static_cast<unsigned long>(sec.sh_offset + sec.sh_entsize*j);
 }
 
-//----------------------------------------------------------------------------
 template <class Types>
 cmELF::StringEntry const*
 cmELFInternalImpl<Types>::GetDynamicSectionString(unsigned int tag)
@@ -730,7 +721,6 @@ cmELFInternalImpl<Types>::GetDynamicSectionString(unsigned int tag)
 //============================================================================
 // External class implementation.
 
-//----------------------------------------------------------------------------
 cmELF::cmELF(const char* fname): Internal(0)
 {
   // Try to open the file.
@@ -803,19 +793,16 @@ cmELF::cmELF(const char* fname): Internal(0)
     }
 }
 
-//----------------------------------------------------------------------------
 cmELF::~cmELF()
 {
   delete this->Internal;
 }
 
-//----------------------------------------------------------------------------
 bool cmELF::Valid() const
 {
   return this->Internal && this->Internal->GetFileType() != FileTypeInvalid;
 }
 
-//----------------------------------------------------------------------------
 cmELF::FileType cmELF::GetFileType() const
 {
   if(this->Valid())
@@ -828,7 +815,6 @@ cmELF::FileType cmELF::GetFileType() const
     }
 }
 
-//----------------------------------------------------------------------------
 unsigned int cmELF::GetNumberOfSections() const
 {
   if(this->Valid())
@@ -841,7 +827,6 @@ unsigned int cmELF::GetNumberOfSections() const
     }
 }
 
-//----------------------------------------------------------------------------
 unsigned int cmELF::GetDynamicEntryCount() const
 {
   if(this->Valid())
@@ -854,7 +839,6 @@ unsigned int cmELF::GetDynamicEntryCount() const
     }
 }
 
-//----------------------------------------------------------------------------
 unsigned long cmELF::GetDynamicEntryPosition(int index) const
 {
   if(this->Valid())
@@ -867,7 +851,6 @@ unsigned long cmELF::GetDynamicEntryPosition(int index) const
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmELF::ReadBytes(unsigned long pos, unsigned long size, char* buf) const
 {
   if(this->Valid())
@@ -880,7 +863,6 @@ bool cmELF::ReadBytes(unsigned long pos, unsigned long size, char* buf) const
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmELF::GetSOName(std::string& soname)
 {
   if(StringEntry const* se = this->GetSOName())
@@ -894,7 +876,6 @@ bool cmELF::GetSOName(std::string& soname)
     }
 }
 
-//----------------------------------------------------------------------------
 cmELF::StringEntry const* cmELF::GetSOName()
 {
   if(this->Valid() &&
@@ -908,7 +889,6 @@ cmELF::StringEntry const* cmELF::GetSOName()
     }
 }
 
-//----------------------------------------------------------------------------
 cmELF::StringEntry const* cmELF::GetRPath()
 {
   if(this->Valid() &&
@@ -923,7 +903,6 @@ cmELF::StringEntry const* cmELF::GetRPath()
     }
 }
 
-//----------------------------------------------------------------------------
 cmELF::StringEntry const* cmELF::GetRunPath()
 {
   if(this->Valid() &&
@@ -938,7 +917,6 @@ cmELF::StringEntry const* cmELF::GetRunPath()
     }
 }
 
-//----------------------------------------------------------------------------
 void cmELF::PrintInfo(std::ostream& os) const
 {
   if(this->Valid())

Source/cmExecuteProcessCommand.cxx

@@ -384,7 +384,6 @@ bool cmExecuteProcessCommand
   return true;
 }
 
-//----------------------------------------------------------------------------
 void cmExecuteProcessCommandFixText(std::vector<char>& output,
                                     bool strip_trailing_whitespace)
 {
@@ -418,7 +417,6 @@ void cmExecuteProcessCommandFixText(std::vector<char>& output,
   output.push_back('\0');
 }
 
-//----------------------------------------------------------------------------
 void cmExecuteProcessCommandAppend(std::vector<char>& output,
                                    const char* data, int length)
 {

Source/cmExportBuildFileGenerator.cxx

@@ -16,14 +16,12 @@
 #include "cmLocalGenerator.h"
 #include "cmTargetExport.h"
 
-//----------------------------------------------------------------------------
 cmExportBuildFileGenerator::cmExportBuildFileGenerator()
 {
   this->LG = 0;
   this->ExportSet = 0;
 }
 
-//----------------------------------------------------------------------------
 void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
 {
   this->LG = lg;
@@ -33,7 +31,6 @@ void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
 {
   {
@@ -132,7 +129,6 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
   return true;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportBuildFileGenerator
 ::GenerateImportTargetsConfig(std::ostream& os,
@@ -179,13 +175,11 @@ cmExportBuildFileGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportBuildFileGenerator::SetExportSet(cmExportSet *exportSet)
 {
   this->ExportSet = exportSet;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportBuildFileGenerator
 ::SetImportLocationProperty(const std::string& config,
@@ -227,7 +221,6 @@ cmExportBuildFileGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportBuildFileGenerator::HandleMissingTarget(
     std::string& link_libs,
@@ -266,7 +259,6 @@ cmExportBuildFileGenerator::HandleMissingTarget(
   link_libs += dependee->GetExportName();
 }
 
-//----------------------------------------------------------------------------
 void cmExportBuildFileGenerator
 ::GetTargets(std::vector<std::string> &targets) const
 {
@@ -283,7 +275,6 @@ void cmExportBuildFileGenerator
   targets = this->Targets;
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string>
 cmExportBuildFileGenerator
 ::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
@@ -308,7 +299,6 @@ cmExportBuildFileGenerator
   return namespaces;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportBuildFileGenerator
 ::ComplainAboutMissingTarget(cmGeneratorTarget* depender,

Source/cmExportCommand.cxx

@@ -250,7 +250,6 @@ bool cmExportCommand
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
 {
   // Parse PACKAGE mode arguments.
@@ -314,7 +313,6 @@ bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
 #if defined(_WIN32) && !defined(__CYGWIN__)
 # include <windows.h>
 # undef GetCurrentDirectory
-//----------------------------------------------------------------------------
 void cmExportCommand::ReportRegistryError(std::string const& msg,
                                           std::string const& key,
                                           long err)
@@ -334,7 +332,6 @@ void cmExportCommand::ReportRegistryError(std::string const& msg,
   this->Makefile->IssueMessage(cmake::WARNING, e.str());
 }
 
-//----------------------------------------------------------------------------
 void cmExportCommand::StorePackageRegistryWin(std::string const& package,
                                               const char* content,
                                               const char* hash)
@@ -367,7 +364,6 @@ void cmExportCommand::StorePackageRegistryWin(std::string const& package,
     }
 }
 #else
-//----------------------------------------------------------------------------
 void cmExportCommand::StorePackageRegistryDir(std::string const& package,
                                               const char* content,
                                               const char* hash)

Source/cmExportFileGenerator.cxx

@@ -28,7 +28,6 @@
 #include <cmsys/FStream.hxx>
 #include <cmsys/auto_ptr.hxx>
 
-//----------------------------------------------------------------------------
 static std::string cmExportFileGeneratorEscape(std::string const& str)
 {
   // Escape a property value for writing into a .cmake file.
@@ -43,20 +42,17 @@ static std::string cmExportFileGeneratorEscape(std::string const& str)
   return result;
 }
 
-//----------------------------------------------------------------------------
 cmExportFileGenerator::cmExportFileGenerator()
 {
   this->AppendMode = false;
   this->ExportOld = false;
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::AddConfiguration(const std::string& config)
 {
   this->Configurations.push_back(config);
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::SetExportFile(const char* mainFile)
 {
   this->MainImportFile = mainFile;
@@ -68,13 +64,11 @@ void cmExportFileGenerator::SetExportFile(const char* mainFile)
     cmSystemTools::GetFilenameLastExtension(this->MainImportFile);
 }
 
-//----------------------------------------------------------------------------
 const char* cmExportFileGenerator::GetMainExportFileName() const
 {
   return this->MainImportFile.c_str();
 }
 
-//----------------------------------------------------------------------------
 bool cmExportFileGenerator::GenerateImportFile()
 {
   // Open the output file to generate it.
@@ -135,7 +129,6 @@ bool cmExportFileGenerator::GenerateImportFile()
   return result;
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateImportConfig(std::ostream& os,
                                     const std::string& config,
                                     std::vector<std::string> &missingTargets)
@@ -155,7 +148,6 @@ void cmExportFileGenerator::GenerateImportConfig(std::ostream& os,
   this->GenerateImportTargetsConfig(os, config, suffix, missingTargets);
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::PopulateInterfaceProperty(
                                               const std::string& propName,
                                               cmGeneratorTarget *target,
@@ -168,7 +160,6 @@ void cmExportFileGenerator::PopulateInterfaceProperty(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::PopulateInterfaceProperty(
                       const std::string& propName,
                       const std::string& outputName,
@@ -209,7 +200,6 @@ void cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream& os,
   /* clang-format on */
 }
 
-//----------------------------------------------------------------------------
 bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
                       cmGeneratorTarget *target,
                       cmGeneratorExpression::PreprocessContext preprocessRule,
@@ -237,14 +227,12 @@ bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
   return false;
 }
 
-//----------------------------------------------------------------------------
 static bool isSubDirectory(const char* a, const char* b)
 {
   return (cmSystemTools::ComparePath(a, b) ||
           cmSystemTools::IsSubDirectory(a, b));
 }
 
-//----------------------------------------------------------------------------
 static bool checkInterfaceDirs(const std::string &prepro,
                       cmGeneratorTarget *target, const std::string& prop)
 {
@@ -379,7 +367,6 @@ static bool checkInterfaceDirs(const std::string &prepro,
   return !hadFatalError;
 }
 
-//----------------------------------------------------------------------------
 static void prefixItems(std::string &exportDirs)
 {
   std::vector<std::string> entries;
@@ -400,7 +387,6 @@ static void prefixItems(std::string &exportDirs)
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::PopulateSourcesInterface(
                       cmTargetExport *tei,
                       cmGeneratorExpression::PreprocessContext preprocessRule,
@@ -440,7 +426,6 @@ void cmExportFileGenerator::PopulateSourcesInterface(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
                       cmTargetExport *tei,
                       cmGeneratorExpression::PreprocessContext preprocessRule,
@@ -508,7 +493,6 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::PopulateInterfaceProperty(
                       const std::string& propName,
                       cmGeneratorTarget* target,
@@ -521,7 +505,6 @@ void cmExportFileGenerator::PopulateInterfaceProperty(
 }
 
 
-//----------------------------------------------------------------------------
 void getPropertyContents(cmGeneratorTarget const* tgt,
                          const std::string& prop,
                          std::set<std::string> &ifaceProperties)
@@ -536,7 +519,6 @@ void getPropertyContents(cmGeneratorTarget const* tgt,
   ifaceProperties.insert(content.begin(), content.end());
 }
 
-//----------------------------------------------------------------------------
 void getCompatibleInterfaceProperties(cmGeneratorTarget *target,
                                       std::set<std::string> &ifaceProperties,
                                       const std::string& config)
@@ -578,7 +560,6 @@ void getCompatibleInterfaceProperties(cmGeneratorTarget *target,
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
                                 cmGeneratorTarget *gtarget,
                                 ImportPropertyMap &properties)
@@ -623,7 +604,6 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateInterfaceProperties(
                                         const cmGeneratorTarget* target,
                                         std::ostream& os,
@@ -644,7 +624,6 @@ void cmExportFileGenerator::GenerateInterfaceProperties(
     }
 }
 
-//----------------------------------------------------------------------------
 bool
 cmExportFileGenerator::AddTargetNamespace(std::string &input,
                                     cmGeneratorTarget* target,
@@ -679,7 +658,6 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input,
   return true;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
                                     std::string &input,
@@ -716,7 +694,6 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
                                     std::string &input,
@@ -811,14 +788,12 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator::ReplaceInstallPrefix(std::string &)
 {
   // Do nothing
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator
 ::SetImportLinkInterface(const std::string& config, std::string const& suffix,
@@ -893,7 +868,6 @@ cmExportFileGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator
 ::SetImportDetailProperties(const std::string& config,
@@ -956,7 +930,6 @@ cmExportFileGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 template <typename T>
 void
 cmExportFileGenerator
@@ -995,7 +968,6 @@ cmExportFileGenerator
   properties[prop] = link_entries;
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os,
                                                     const std::string& config)
 {
@@ -1014,14 +986,12 @@ void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os,
   this->GenerateImportVersionCode(os);
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateImportFooterCode(std::ostream& os)
 {
   os << "# Commands beyond this point should not need to know the version.\n"
      << "set(CMAKE_IMPORT_FILE_VERSION)\n";
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateImportVersionCode(std::ostream& os)
 {
   // Store an import file format version.  This will let us change the
@@ -1033,7 +1003,6 @@ void cmExportFileGenerator::GenerateImportVersionCode(std::ostream& os)
   /* clang-format on */
 }
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os,
                                             const std::string &expectedTargets)
 {
@@ -1071,7 +1040,6 @@ void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os,
         "\n\n";
   /* clang-format on */
 }
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator
 ::GenerateImportTargetCode(std::ostream& os, const cmGeneratorTarget* target)
@@ -1136,7 +1104,6 @@ cmExportFileGenerator
   os << "\n";
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator
 ::GenerateImportPropertyCode(std::ostream& os, const std::string& config,
@@ -1174,7 +1141,6 @@ cmExportFileGenerator
 }
 
 
-//----------------------------------------------------------------------------
 void cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream& os,
                                 const std::vector<std::string>& missingTargets)
 {
@@ -1229,7 +1195,6 @@ void cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream& os,
 }
 
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
 {
@@ -1265,7 +1230,6 @@ cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
 }
 
 
-//----------------------------------------------------------------------------
 void
 cmExportFileGenerator
 ::GenerateImportedFileChecksCode(std::ostream& os, cmGeneratorTarget* target,

Source/cmExportInstallFileGenerator.cxx

@@ -21,14 +21,12 @@
 #include "cmLocalGenerator.h"
 #include "cmTargetExport.h"
 
-//----------------------------------------------------------------------------
 cmExportInstallFileGenerator
 ::cmExportInstallFileGenerator(cmInstallExportGenerator* iegen):
   IEGen(iegen)
 {
 }
 
-//----------------------------------------------------------------------------
 std::string cmExportInstallFileGenerator::GetConfigImportFileGlob()
 {
   std::string glob = this->FileBase;
@@ -37,7 +35,6 @@ std::string cmExportInstallFileGenerator::GetConfigImportFileGlob()
   return glob;
 }
 
-//----------------------------------------------------------------------------
 bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
 {
   std::vector<cmTargetExport*> allTargets;
@@ -258,7 +255,6 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
   return result;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportInstallFileGenerator::ReplaceInstallPrefix(std::string &input)
 {
@@ -273,7 +269,6 @@ cmExportInstallFileGenerator::ReplaceInstallPrefix(std::string &input)
     }
 }
 
-//----------------------------------------------------------------------------
 bool
 cmExportInstallFileGenerator::GenerateImportFileConfig(
                                     const std::string& config,
@@ -328,7 +323,6 @@ cmExportInstallFileGenerator::GenerateImportFileConfig(
   return true;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportInstallFileGenerator
 ::GenerateImportTargetsConfig(std::ostream& os,
@@ -390,7 +384,6 @@ cmExportInstallFileGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportInstallFileGenerator
 ::SetImportLocationProperty(const std::string& config,
@@ -459,7 +452,6 @@ cmExportInstallFileGenerator
     }
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportInstallFileGenerator::HandleMissingTarget(std::string& link_libs,
   std::vector<std::string>& missingTargets,
@@ -485,7 +477,6 @@ cmExportInstallFileGenerator::HandleMissingTarget(std::string& link_libs,
     }
 }
 
-//----------------------------------------------------------------------------
 std::vector<std::string>
 cmExportInstallFileGenerator
 ::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
@@ -525,7 +516,6 @@ cmExportInstallFileGenerator
   return namespaces;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportInstallFileGenerator
 ::ComplainAboutMissingTarget(cmGeneratorTarget* depender,

Source/cmExportTryCompileFileGenerator.cxx

@@ -17,7 +17,6 @@
 #include "cmGlobalGenerator.h"
 #include "cmLocalGenerator.h"
 
-//----------------------------------------------------------------------------
 cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator(
     cmGlobalGenerator* gg,
     const std::vector<std::string>& targets,
@@ -98,7 +97,6 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
   return result;
 }
 
-//----------------------------------------------------------------------------
 void
 cmExportTryCompileFileGenerator::PopulateProperties(
                                  const cmGeneratorTarget* target,

Source/cmExtraCodeBlocksGenerator.cxx

@@ -36,7 +36,6 @@ Discussion:
 http://forums.codeblocks.org/index.php/topic,6789.0.html
 */
 
-//----------------------------------------------------------------------------
 void cmExtraCodeBlocksGenerator
 ::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
 {

Source/cmExtraCodeLiteGenerator.cxx

@@ -27,7 +27,6 @@
 #include <cmsys/SystemInformation.hxx>
 #include <cmsys/SystemTools.hxx>
 
-//----------------------------------------------------------------------------
 void cmExtraCodeLiteGenerator::GetDocumentation(cmDocumentationEntry& entry,
                                                 const std::string&) const
 {

Source/cmExtraEclipseCDT4Generator.cxx

@@ -43,7 +43,6 @@ void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
   xml.EndElement();
 }
 
-//----------------------------------------------------------------------------
 cmExtraEclipseCDT4Generator
 ::cmExtraEclipseCDT4Generator() : cmExternalMakefileProjectGenerator()
 {
@@ -65,7 +64,6 @@ cmExtraEclipseCDT4Generator
   this->CXXEnabled = false;
 }
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator
 ::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
 {
@@ -73,7 +71,6 @@ void cmExtraEclipseCDT4Generator
   entry.Brief = "Generates Eclipse CDT 4.0 project files.";
 }
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator
 ::EnableLanguage(std::vector<std::string> const& languages,
                  cmMakefile *, bool)
@@ -99,7 +96,6 @@ void cmExtraEclipseCDT4Generator
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::Generate()
 {
   cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0];
@@ -213,7 +209,6 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile()
 }
 
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
                                             const char* envVar,
                                             cmLocalGenerator* lg)
@@ -277,7 +272,6 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
 }
 
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::CreateProjectFile()
 {
   cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0];
@@ -512,7 +506,6 @@ void cmExtraEclipseCDT4Generator::WriteGroups(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
 {
   std::string linkName = "[Targets]";
@@ -579,7 +572,6 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
 }
 
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
                        cmXMLWriter& xml, const std::string& baseDir)
 {
@@ -619,7 +611,6 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
 }
 
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
                             cmXMLWriter& xml,
                             const std::vector<std::string>& includeDirs,
@@ -657,7 +648,6 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
     }
 }
 
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
 {
   std::set<std::string> emmited;
@@ -1146,7 +1136,6 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   xml.EndElement(); // cproject
 }
 
-//----------------------------------------------------------------------------
 std::string
 cmExtraEclipseCDT4Generator::GetEclipsePath(const std::string& path)
 {
@@ -1194,9 +1183,7 @@ cmExtraEclipseCDT4Generator::GenerateProjectName(const std::string& name,
   return name + (type.empty() ? "" : "-") + type + "@" + path;
 }
 
-//----------------------------------------------------------------------------
 // Helper functions
-//----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator
 ::AppendStorageScanners(cmXMLWriter& xml,
                         const cmMakefile& makefile)

Source/cmExtraKateGenerator.cxx

@@ -22,7 +22,6 @@
 
 #include <cmsys/SystemTools.hxx>
 
-//----------------------------------------------------------------------------
 void cmExtraKateGenerator
 ::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
 {

Source/cmExtraSublimeTextGenerator.cxx

@@ -38,7 +38,6 @@ http://www.sublimetext.com/docs/2/projects.html
 http://sublimetext.info/docs/en/reference/build_systems.html
 */
 
-//----------------------------------------------------------------------------
 void cmExtraSublimeTextGenerator
 ::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
 {

Source/cmFileCommand.cxx

@@ -218,7 +218,6 @@ bool cmFileCommand
   return false;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
   bool append)
 {
@@ -282,7 +281,6 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
 {
   if ( args.size() < 3 )
@@ -399,7 +397,6 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
@@ -434,7 +431,6 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
 #endif
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
 {
   if(args.size() < 3)
@@ -885,7 +881,6 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
   bool recurse)
 {
@@ -1070,7 +1065,6 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleMakeDirectoryCommand(
   std::vector<std::string> const& args)
 {
@@ -1109,7 +1103,6 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
 {
@@ -1170,7 +1163,6 @@ cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 // File installation helper class.
 struct cmFileCopier
 {
@@ -1380,7 +1372,6 @@ protected:
     }
 };
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::Parse(std::vector<std::string> const& args)
 {
   this->Doing = DoingFiles;
@@ -1427,7 +1418,6 @@ bool cmFileCopier::Parse(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::CheckKeyword(std::string const& arg)
 {
   if(arg == "DESTINATION")
@@ -1540,7 +1530,6 @@ bool cmFileCopier::CheckKeyword(std::string const& arg)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::CheckValue(std::string const& arg)
 {
   switch(this->Doing)
@@ -1633,7 +1622,6 @@ bool cmFileCopier::CheckValue(std::string const& arg)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::Run(std::vector<std::string> const& args)
 {
   if(!this->Parse(args))
@@ -1677,7 +1665,6 @@ bool cmFileCopier::Run(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::Install(const char* fromFile, const char* toFile)
 {
   if(!*fromFile)
@@ -1716,7 +1703,6 @@ bool cmFileCopier::Install(const char* fromFile, const char* toFile)
   return this->ReportMissing(fromFile);
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::InstallSymlink(const char* fromFile, const char* toFile)
 {
   // Read the original symlink.
@@ -1767,7 +1753,6 @@ bool cmFileCopier::InstallSymlink(const char* fromFile, const char* toFile)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::InstallFile(const char* fromFile, const char* toFile,
                                MatchProperties const& match_properties)
 {
@@ -1827,7 +1812,6 @@ bool cmFileCopier::InstallFile(const char* fromFile, const char* toFile,
   return this->SetPermissions(toFile, permissions);
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCopier::InstallDirectory(const char* source,
                                     const char* destination,
                                     MatchProperties const& match_properties)
@@ -1911,14 +1895,12 @@ bool cmFileCopier::InstallDirectory(const char* source,
   return this->SetPermissions(destination, permissions_after);
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleCopyCommand(std::vector<std::string> const& args)
 {
   cmFileCopier copier(this);
   return copier.Run(args);
 }
 
-//----------------------------------------------------------------------------
 struct cmFileInstaller: public cmFileCopier
 {
   cmFileInstaller(cmFileCommand* command):
@@ -2031,7 +2013,6 @@ protected:
   bool HandleInstallDestination();
 };
 
-//----------------------------------------------------------------------------
 bool cmFileInstaller::Parse(std::vector<std::string> const& args)
 {
   if(!this->cmFileCopier::Parse(args))
@@ -2074,7 +2055,6 @@ bool cmFileInstaller::Parse(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileInstaller::CheckKeyword(std::string const& arg)
 {
   if(arg == "TYPE")
@@ -2201,7 +2181,6 @@ bool cmFileInstaller::CheckKeyword(std::string const& arg)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileInstaller::CheckValue(std::string const& arg)
 {
   switch(this->Doing)
@@ -2221,7 +2200,6 @@ bool cmFileInstaller::CheckValue(std::string const& arg)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileInstaller
 ::GetTargetTypeFromString(const std::string& stype)
 {
@@ -2263,7 +2241,6 @@ bool cmFileInstaller
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileInstaller::HandleInstallDestination()
 {
   std::string& destination = this->Destination;
@@ -2359,7 +2336,6 @@ bool cmFileInstaller::HandleInstallDestination()
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmFileCommand::HandleRPathChangeCommand(std::vector<std::string> const& args)
 {
@@ -2466,7 +2442,6 @@ cmFileCommand::HandleRPathChangeCommand(std::vector<std::string> const& args)
   return success;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmFileCommand::HandleRPathRemoveCommand(std::vector<std::string> const& args)
 {
@@ -2539,7 +2514,6 @@ cmFileCommand::HandleRPathRemoveCommand(std::vector<std::string> const& args)
   return success;
 }
 
-//----------------------------------------------------------------------------
 bool
 cmFileCommand::HandleRPathCheckCommand(std::vector<std::string> const& args)
 {
@@ -2599,14 +2573,12 @@ cmFileCommand::HandleRPathCheckCommand(std::vector<std::string> const& args)
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
 {
   cmFileInstaller installer(this);
   return installer.Run(args);
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleRelativePathCommand(
   std::vector<std::string> const& args)
 {
@@ -2645,7 +2617,6 @@ bool cmFileCommand::HandleRelativePathCommand(
 }
 
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
 {
   if(args.size() != 3)
@@ -2686,7 +2657,6 @@ bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
 }
 
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
                                  bool recurse)
 {
@@ -2717,7 +2687,6 @@ bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleCMakePathCommand(std::vector<std::string>
                                            const& args,
                                            bool nativePath)
@@ -3573,7 +3542,6 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
 #endif
 }
 
-//----------------------------------------------------------------------------
 void cmFileCommand::AddEvaluationFile(const std::string &inputName,
                                       const std::string &outputExpr,
                                       const std::string &condition,
@@ -3594,7 +3562,6 @@ void cmFileCommand::AddEvaluationFile(const std::string &inputName,
                                     conditionCge, inputIsContent);
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleGenerateCommand(
   std::vector<std::string> const& args)
 {
@@ -3642,7 +3609,6 @@ bool cmFileCommand::HandleGenerateCommand(
   return true;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleLockCommand(
   std::vector<std::string> const& args)
 {
@@ -3841,7 +3807,6 @@ bool cmFileCommand::HandleLockCommand(
 #endif
 }
 
-//----------------------------------------------------------------------------
 bool cmFileCommand::HandleTimestampCommand(
   std::vector<std::string> const& args)
 {

Source/cmFileTimeComparison.cxx

@@ -32,7 +32,6 @@
 #  include <windows.h>
 #endif
 
-//----------------------------------------------------------------------------
 class cmFileTimeComparisonInternal
 {
 public:
@@ -74,7 +73,6 @@ private:
                           cmFileTimeComparison_Type* st2);
 };
 
-//----------------------------------------------------------------------------
 bool cmFileTimeComparisonInternal::Stat(const char* fname,
                                         cmFileTimeComparison_Type* st)
 {
@@ -118,32 +116,27 @@ bool cmFileTimeComparisonInternal::Stat(const char* fname,
   return true;
 }
 
-//----------------------------------------------------------------------------
 cmFileTimeComparison::cmFileTimeComparison()
 {
   this->Internals = new cmFileTimeComparisonInternal;
 }
 
-//----------------------------------------------------------------------------
 cmFileTimeComparison::~cmFileTimeComparison()
 {
   delete this->Internals;
 }
 
-//----------------------------------------------------------------------------
 bool cmFileTimeComparison::FileTimeCompare(const char* f1,
                                            const char* f2, int* result)
 {
   return this->Internals->FileTimeCompare(f1, f2, result);
 }
 
-//----------------------------------------------------------------------------
 bool cmFileTimeComparison::FileTimesDiffer(const char* f1, const char* f2)
 {
   return this->Internals->FileTimesDiffer(f1, f2);
 }
 
-//----------------------------------------------------------------------------
 int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1,
                                           cmFileTimeComparison_Type* s2)
 {
@@ -203,7 +196,6 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1,
 #endif
 }
 
-//----------------------------------------------------------------------------
 bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
                                                cmFileTimeComparison_Type* s2)
 {
@@ -280,7 +272,6 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
 #endif
 }
 
-//----------------------------------------------------------------------------
 bool cmFileTimeComparisonInternal::FileTimeCompare(const char* f1,
                                                    const char* f2,
                                                    int* result)
@@ -303,7 +294,6 @@ bool cmFileTimeComparisonInternal::FileTimeCompare(const char* f1,
     }
 }
 
-//----------------------------------------------------------------------------
 bool cmFileTimeComparisonInternal::FileTimesDiffer(const char* f1,
                                                    const char* f2)
 {