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

Merge topic 'clang-format-prep' 

0ac18d40 Remove `//------...` horizontal separator comments
This commit is contained in:
Brad King 2016-05-09 12:56:43 -04:00 committed by CMake Topic Stage
parent d95fbdb709 0ac18d40c8
commit 3ecdddfc35
221 changed files with 0 additions and 2631 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Modules/CMakeCCompilerABI.c
View File

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

2
Modules/CMakeCXXCompilerABI.cpp
View File

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

2
Modules/CMakeCompilerABI.h
View File

@ -1,4 +1,3 @@
/*--------------------------------------------------------------------------*/
/* Size of a pointer-to-data in bytes. */ /* Size of a pointer-to-data in bytes. */
#define SIZEOF_DPTR (sizeof(void*)) #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 */ /* clang-format needs this comment to break after the opening brace */
}; };
/*--------------------------------------------------------------------------*/
/* Application Binary Interface. */ /* Application Binary Interface. */
#if defined(__sgi) && defined(_ABIO32) #if defined(__sgi) && defined(_ABIO32)

22
Source/CPack/IFW/cmCPackIFWGenerator.cxx
View File

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

9
Source/CPack/IFW/cmCPackIFWInstaller.cxx
View File

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

14
Source/CPack/IFW/cmCPackIFWPackage.cxx
View File

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

2
Source/CPack/cmCPack7zGenerator.cxx
View File

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

8
Source/CPack/cmCPackArchiveGenerator.cxx
View File

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

6
Source/CPack/cmCPackBundleGenerator.cxx
View File

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

2
Source/CPack/cmCPackComponentGroup.cxx
View File

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

4
Source/CPack/cmCPackCygwinBinaryGenerator.cxx
View File

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

4
Source/CPack/cmCPackCygwinSourceGenerator.cxx
View File

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

7
Source/CPack/cmCPackDebGenerator.cxx
View File

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

9
Source/CPack/cmCPackDragNDropGenerator.cxx
View File

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

38
Source/CPack/cmCPackGenerator.cxx
View File

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

5
Source/CPack/cmCPackGeneratorFactory.cxx
View File

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

5
Source/CPack/cmCPackLog.cxx
View File

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

13
Source/CPack/cmCPackNSISGenerator.cxx
View File

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

7
Source/CPack/cmCPackOSXX11Generator.cxx
View File

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

17
Source/CPack/cmCPackPackageMakerGenerator.cxx
View File

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

7
Source/CPack/cmCPackRPMGenerator.cxx
View File

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

5
Source/CPack/cmCPackSTGZGenerator.cxx
View File

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

2
Source/CPack/cmCPackTGZGenerator.cxx
View File

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

2
Source/CPack/cmCPackTXZGenerator.cxx
View File

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

2
Source/CPack/cmCPackTarBZip2Generator.cxx
View File

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

2
Source/CPack/cmCPackTarCompressGenerator.cxx
View File

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

2
Source/CPack/cmCPackZIPGenerator.cxx
View File

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

7
Source/CPack/cpack.cxx
View File

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

13
Source/CTest/cmCTestBZR.cxx
View File

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

5
Source/CTest/cmCTestBatchTestHandler.cxx
View File

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

10
Source/CTest/cmCTestBuildAndTestHandler.cxx
View File

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

3
Source/CTest/cmCTestBuildCommand.cxx
View File

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

20
Source/CTest/cmCTestBuildHandler.cxx
View File

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

9
Source/CTest/cmCTestCVS.cxx
View File

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

3
Source/CTest/cmCTestConfigureHandler.cxx
View File

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

4
Source/CTest/cmCTestCoverageCommand.cxx
View File

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

37
Source/CTest/cmCTestCoverageHandler.cxx
View File

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

18
Source/CTest/cmCTestGIT.cxx
View File

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

8
Source/CTest/cmCTestGenericHandler.cxx
View File

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

8
Source/CTest/cmCTestGlobalVC.cxx
View File

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

11
Source/CTest/cmCTestHG.cxx
View File

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

2
Source/CTest/cmCTestHandlerCommand.cxx
View File

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

24
Source/CTest/cmCTestLaunch.cxx
View File

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

15
Source/CTest/cmCTestMemCheckHandler.cxx
View File

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

22
Source/CTest/cmCTestMultiProcessHandler.cxx
View File

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

16
Source/CTest/cmCTestP4.cxx
View File

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

10
Source/CTest/cmCTestRunTest.cxx
View File

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

22
Source/CTest/cmCTestSVN.cxx
View File

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

19
Source/CTest/cmCTestScriptHandler.cxx
View File

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

1
Source/CTest/cmCTestStartCommand.cxx
View File

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

3
Source/CTest/cmCTestSubmitCommand.cxx
View File

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

14
Source/CTest/cmCTestSubmitHandler.cxx
View File

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

43
Source/CTest/cmCTestTestHandler.cxx
View File

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

7
Source/CTest/cmCTestUpdateHandler.cxx
View File

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

2
Source/CTest/cmCTestUploadCommand.cxx
View File

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

3
Source/CTest/cmCTestUploadHandler.cxx
View File

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

18
Source/CTest/cmCTestVC.cxx
View File

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

1
Source/CTest/cmParseCoberturaCoverage.cxx
View File

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

3
Source/CTest/cmProcess.cxx
View File

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

4
Source/CursesDialog/ccmake.cxx
View File

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

3
Source/QtDialog/CMakeSetup.cxx
View File

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

1
Source/cmAddCustomCommandCommand.cxx
View File

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

1
Source/cmAddTestCommand.cxx
View File

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

11
Source/cmArchiveWrite.cxx
View File

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

3
Source/cmBuildCommand.cxx
View File

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

1
Source/cmCMakeMinimumRequired.cxx
View File

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

3
Source/cmCMakePolicyCommand.cxx
View File

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

79
Source/cmCTest.cxx
View File

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

13
Source/cmCacheManager.cxx
View File

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

11
Source/cmCallVisualStudioMacro.cxx
View File

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

10
Source/cmCommonTargetGenerator.cxx
View File

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

5
Source/cmComputeComponentGraph.cxx
View File

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

25
Source/cmComputeLinkDepends.cxx
View File

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

42
Source/cmComputeLinkInformation.cxx
View File

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

17
Source/cmComputeTargetDepends.cxx
View File

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

8
Source/cmCryptoHash.cxx
View File

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

1
Source/cmCurl.cxx
View File

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

19
Source/cmCustomCommand.cxx
View File

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

12
Source/cmCustomCommandGenerator.cxx
View File

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

7
Source/cmDefinitions.cxx
View File

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

9
Source/cmDepends.cxx
View File

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

10
Source/cmDependsC.cxx
View File

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

16
Source/cmDependsFortran.cxx
View File

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

3
Source/cmDependsJava.cxx
View File

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

45
Source/cmDocumentation.cxx
View File

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

3
Source/cmDocumentationSection.cxx
View File

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

22
Source/cmELF.cxx
View File

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

2
Source/cmExecuteProcessCommand.cxx
View File

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

10
Source/cmExportBuildFileGenerator.cxx
View File

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

4
Source/cmExportCommand.cxx
View File

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

36
Source/cmExportFileGenerator.cxx
View File

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

10
Source/cmExportInstallFileGenerator.cxx
View File

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

2
Source/cmExportTryCompileFileGenerator.cxx
View File

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

1
Source/cmExtraCodeBlocksGenerator.cxx
View File

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

1
Source/cmExtraCodeLiteGenerator.cxx
View File

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

13
Source/cmExtraEclipseCDT4Generator.cxx
View File

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

1
Source/cmExtraKateGenerator.cxx
View File

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

1
Source/cmExtraSublimeTextGenerator.cxx
View File

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

35
Source/cmFileCommand.cxx
View File

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

10
Source/cmFileTimeComparison.cxx
View File

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

Some files were not shown because too many files have changed in this diff Show More