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

Revise C++ coding style using clang-format 

Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.
This commit is contained in:
Kitware Robot 2016-05-16 10:34:04 -04:00 committed by Brad King
parent 82df6deaaf
commit d9fd2f5402
1450 changed files with 62404 additions and 83728 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Modules/CMakeCCompilerABI.c
View File

@ -1,19 +1,18 @@
#ifdef __cplusplus
# error "A C++ compiler has been selected for C."
#error "A C++ compiler has been selected for C."
#endif
#ifdef __CLASSIC_C__
# define const
#define const
#endif
#include "CMakeCompilerABI.h"
#ifdef __CLASSIC_C__
int main(argc, argv) int argc; char *argv[];
int main(argc, argv) int argc;
char* argv[];
#else
int main(int argc, char *argv[])
int main(int argc, char* argv[])
#endif
{
int require = 0;

4
Modules/CMakeCXXCompilerABI.cpp
View File

@ -1,11 +1,9 @@
#ifndef __cplusplus
# error "A C compiler has been selected for C++."
#error "A C compiler has been selected for C++."
#endif
#include "CMakeCompilerABI.h"
int main(int argc, char* argv[])
{
int require = 0;

22
Modules/CMakeCompilerABI.h
View File

@ -2,33 +2,31 @@
/* Size of a pointer-to-data in bytes. */
#define SIZEOF_DPTR (sizeof(void*))
const char info_sizeof_dptr[] = {
'I', 'N', 'F', 'O', ':', 's', 'i', 'z', 'e', 'o', 'f', '_', 'd', 'p', 't', 'r', '[',
('0' + ((SIZEOF_DPTR / 10)%10)),
('0' + (SIZEOF_DPTR % 10)),
']','\0'
'I', 'N', 'F', 'O', ':', 's', 'i', 'z', 'e', 'o', 'f', '_', 'd', 'p', 't',
'r', '[', ('0' + ((SIZEOF_DPTR / 10) % 10)), ('0' + (SIZEOF_DPTR % 10)), ']',
'\0'
/* clang-format needs this comment to break after the opening brace */
};
/* Application Binary Interface. */
#if defined(__sgi) && defined(_ABIO32)
# define ABI_ID "ELF O32"
#define ABI_ID "ELF O32"
#elif defined(__sgi) && defined(_ABIN32)
# define ABI_ID "ELF N32"
#define ABI_ID "ELF N32"
#elif defined(__sgi) && defined(_ABI64)
# define ABI_ID "ELF 64"
#define ABI_ID "ELF 64"
/* Check for (some) ARM ABIs.
* See e.g. http://wiki.debian.org/ArmEabiPort for some information on this. */
#elif defined(__GNU__) && defined(__ELF__) && defined(__ARM_EABI__)
# define ABI_ID "ELF ARMEABI"
#define ABI_ID "ELF ARMEABI"
#elif defined(__GNU__) && defined(__ELF__) && defined(__ARMEB__)
# define ABI_ID "ELF ARM"
#define ABI_ID "ELF ARM"
#elif defined(__GNU__) && defined(__ELF__) && defined(__ARMEL__)
# define ABI_ID "ELF ARM"
#define ABI_ID "ELF ARM"
#elif defined(__ELF__)
# define ABI_ID "ELF"
#define ABI_ID "ELF"
#endif
#if defined(ABI_ID)

17
Modules/CheckForPthreads.c
View File

@ -6,11 +6,13 @@ void* runner(void*);
int res = 0;
#ifdef __CLASSIC_C__
int main(){
int main()
{
int ac;
char*av[];
char* av[];
#else
int main(int ac, char*av[]){
int main(int ac, char* av[])
{
#endif
pthread_t tid[2];
pthread_create(&tid[0], 0, runner, (void*)1);
@ -22,17 +24,18 @@ int main(int ac, char*av[]){
pthread_join(tid[0], 0);
pthread_join(tid[1], 0);
if(ac > 1000){return *av[0];}
if (ac > 1000) {
return *av[0];
}
return res;
}
void* runner(void* args)
{
int cc;
for ( cc = 0; cc < 10; cc ++ )
{
for (cc = 0; cc < 10; cc++) {
printf("%p CC: %d\n", args, cc);
}
res ++;
res++;
return 0;
}

16
Modules/CheckFunctionExists.c
View File

@ -3,17 +3,19 @@
#ifdef __cplusplus
extern "C"
#endif
char CHECK_FUNCTION_EXISTS();
char
CHECK_FUNCTION_EXISTS();
#ifdef __CLASSIC_C__
int main(){
int main()
{
int ac;
char*av[];
char* av[];
#else
int main(int ac, char*av[]){
int main(int ac, char* av[])
{
#endif
CHECK_FUNCTION_EXISTS();
if(ac > 1000)
{
if (ac > 1000) {
return *av[0];
}
return 0;
@ -21,6 +23,6 @@ int main(int ac, char*av[]){
#else /* CHECK_FUNCTION_EXISTS */
# error "CHECK_FUNCTION_EXISTS has to specify the function"
#error "CHECK_FUNCTION_EXISTS has to specify the function"
#endif /* CHECK_FUNCTION_EXISTS */

14
Modules/CheckVariableExists.c
View File

@ -3,18 +3,22 @@
extern int CHECK_VARIABLE_EXISTS;
#ifdef __CLASSIC_C__
int main(){
int main()
{
int ac;
char*av[];
char* av[];
#else
int main(int ac, char*av[]){
int main(int ac, char* av[])
{
#endif
if(ac > 1000){return *av[0];}
if (ac > 1000) {
return *av[0];
}
return CHECK_VARIABLE_EXISTS;
}
#else /* CHECK_VARIABLE_EXISTS */
# error "CHECK_VARIABLE_EXISTS has to specify the variable"
#error "CHECK_VARIABLE_EXISTS has to specify the variable"
#endif /* CHECK_VARIABLE_EXISTS */

4
Modules/FortranCInterface/my_module_.c
View File

@ -1 +1,3 @@
void my_module_(void) {}
void my_module_(void)
{
}

4
Modules/FortranCInterface/mymodule_.c
View File

@ -1 +1,3 @@
void mymodule_(void) {}
void mymodule_(void)
{
}

2
Modules/TestForANSIStreamHeaders.cxx
View File

@ -1,6 +1,6 @@
#include <iostream>
int main(int,char *[])
int main(int, char* [])
{
return 0;
}

5
Modules/TestForAnsiForScope.cxx
View File

@ -1,7 +1,8 @@
int main(int, char*[])
int main(int, char* [])
{
int i;
for(int i=0; i < 1; ++i);
for (int i = 0; i < 1; ++i)
;
(void)i;
return 0;
}

5
Modules/TestForSSTREAM.cxx
View File

@ -1,10 +1,9 @@
#include <sstream>
int main(int, char*[])
int main(int, char* [])
{
std::ostringstream os;
os << "12345";
if(os.str().size() == 5)
{
if (os.str().size() == 5) {
return 0;
}
return -1;

2
Modules/TestForSTDNamespace.cxx
View File

@ -1,5 +1,5 @@
#include <list>
int main(int, char*[])
int main(int, char* [])
{
std::list<int>();
return 0;

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

@ -39,19 +39,19 @@ cmCPackIFWGenerator::~cmCPackIFWGenerator()
{
}
bool cmCPackIFWGenerator::IsVersionLess(const char *version)
bool cmCPackIFWGenerator::IsVersionLess(const char* version)
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
FrameworkVersion.data(), version);
}
bool cmCPackIFWGenerator::IsVersionGreater(const char *version)
bool cmCPackIFWGenerator::IsVersionGreater(const char* version)
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
FrameworkVersion.data(), version);
}
bool cmCPackIFWGenerator::IsVersionEqual(const char *version)
bool cmCPackIFWGenerator::IsVersionEqual(const char* version)
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
FrameworkVersion.data(), version);
@ -72,51 +72,41 @@ int cmCPackIFWGenerator::PackageFiles()
ifwTmpFile += "/IFWOutput.log";
// Run repogen
if (!Installer.Repositories.empty())
{
if (!Installer.Repositories.empty()) {
std::string ifwCmd = RepoGen;
if(IsVersionLess("2.0.0"))
{
if (IsVersionLess("2.0.0")) {
ifwCmd += " -c " + this->toplevel + "/config/config.xml";
}
ifwCmd += " -p " + this->toplevel + "/packages";
if(!PkgsDirsVector.empty())
{
for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
it != PkgsDirsVector.end(); ++it)
{
if (!PkgsDirsVector.empty()) {
for (std::vector<std::string>::iterator it = PkgsDirsVector.begin();
it != PkgsDirsVector.end(); ++it) {
ifwCmd += " -p " + *it;
}
}
if (!OnlineOnly && !DownloadedPackages.empty())
{
if (!OnlineOnly && !DownloadedPackages.empty()) {
ifwCmd += " -i ";
std::set<cmCPackIFWPackage*>::iterator it
= DownloadedPackages.begin();
std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
ifwCmd += (*it)->Name;
++it;
while(it != DownloadedPackages.end())
{
while (it != DownloadedPackages.end()) {
ifwCmd += "," + (*it)->Name;
++it;
}
}
ifwCmd += " " + this->toplevel + "/repository";
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
<< std::endl);
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd << std::endl);
std::string output;
int retVal = 1;
cmCPackLogger(cmCPackLog::LOG_OUTPUT,
"- Generate repository" << std::endl);
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate repository"
<< std::endl);
bool res = cmSystemTools::RunSingleCommand(
ifwCmd.c_str(), &output, &output,
&retVal, 0, this->GeneratorVerbose, 0);
if ( !res || retVal )
{
ifwCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
if (!res || retVal) {
cmGeneratedFileStream ofs(ifwTmpFile.c_str());
ofs << "# Run command: " << ifwCmd << std::endl
<< "# Output:" << std::endl
@ -127,8 +117,8 @@ int cmCPackIFWGenerator::PackageFiles()
<< std::endl);
return 0;
}
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: " << this->toplevel
<< "/repository generated" << std::endl);
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: "
<< this->toplevel << "/repository generated" << std::endl);
}
// Run binary creator
@ -137,39 +127,30 @@ int cmCPackIFWGenerator::PackageFiles()
ifwCmd += " -c " + this->toplevel + "/config/config.xml";
ifwCmd += " -p " + this->toplevel + "/packages";
if(!PkgsDirsVector.empty())
{
for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
it != PkgsDirsVector.end(); ++it)
{
if (!PkgsDirsVector.empty()) {
for (std::vector<std::string>::iterator it = PkgsDirsVector.begin();
it != PkgsDirsVector.end(); ++it) {
ifwCmd += " -p " + *it;
}
}
if (OnlineOnly)
{
if (OnlineOnly) {
ifwCmd += " --online-only";
}
else if (!DownloadedPackages.empty() && !Installer.Repositories.empty())
{
} else if (!DownloadedPackages.empty() &&
!Installer.Repositories.empty()) {
ifwCmd += " -e ";
std::set<cmCPackIFWPackage*>::iterator it
= DownloadedPackages.begin();
std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
ifwCmd += (*it)->Name;
++it;
while(it != DownloadedPackages.end())
{
while (it != DownloadedPackages.end()) {
ifwCmd += "," + (*it)->Name;
++it;
}
}
else if (!DependentPackages.empty())
{
} else if (!DependentPackages.empty()) {
ifwCmd += " -i ";
// Binary
std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
while(bit != BinaryPackages.end())
{
while (bit != BinaryPackages.end()) {
ifwCmd += (*bit)->Name + ",";
++bit;
}
@ -177,31 +158,24 @@ int cmCPackIFWGenerator::PackageFiles()
DependenceMap::iterator it = DependentPackages.begin();
ifwCmd += it->second.Name;
++it;
while(it != DependentPackages.end())
{
while (it != DependentPackages.end()) {
ifwCmd += "," + it->second.Name;
++it;
}
}
// TODO: set correct name for multipackages
if (!this->packageFileNames.empty())
{
if (!this->packageFileNames.empty()) {
ifwCmd += " " + packageFileNames[0];
}
else
{
} else {
ifwCmd += " installer";
}
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
<< std::endl);
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd << std::endl);
std::string output;
int retVal = 1;
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl);
bool res = cmSystemTools::RunSingleCommand(
ifwCmd.c_str(), &output, &output,
&retVal, 0, this->GeneratorVerbose, 0);
if ( !res || retVal )
{
ifwCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
if (!res || retVal) {
cmGeneratedFileStream ofs(ifwTmpFile.c_str());
ofs << "# Run command: " << ifwCmd << std::endl
<< "# Output:" << std::endl
@ -217,14 +191,13 @@ int cmCPackIFWGenerator::PackageFiles()
return 1;
}
const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
const char* cmCPackIFWGenerator::GetPackagingInstallPrefix()
{
const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
const char* defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
std::string tmpPref = defPrefix ? defPrefix : "";
if(this->Components.empty())
{
if (this->Components.empty()) {
tmpPref += "packages/" + GetRootPackageName() + "/data";
}
@ -233,7 +206,7 @@ const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
}
const char *cmCPackIFWGenerator::GetOutputExtension()
const char* cmCPackIFWGenerator::GetOutputExtension()
{
return ExecutableSuffix.c_str();
}
@ -246,27 +219,21 @@ int cmCPackIFWGenerator::InitializeInternal()
const std::string RepoGenOpt = "CPACK_IFW_REPOGEN_EXECUTABLE";
const std::string FrameworkVersionOpt = "CPACK_IFW_FRAMEWORK_VERSION";
if(!this->IsSet(BinCreatorOpt) ||
!this->IsSet(RepoGenOpt) ||
!this->IsSet(FrameworkVersionOpt))
{
if (!this->IsSet(BinCreatorOpt) || !this->IsSet(RepoGenOpt) ||
!this->IsSet(FrameworkVersionOpt)) {
this->ReadListFile("CPackIFW.cmake");
}
// Look 'binarycreator' executable (needs)
const char *BinCreatorStr = this->GetOption(BinCreatorOpt);
if(!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr))
{
const char* BinCreatorStr = this->GetOption(BinCreatorOpt);
if (!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr)) {
BinCreator = "";
}
else
{
} else {
BinCreator = BinCreatorStr;
}
if (BinCreator.empty())
{
if (BinCreator.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find QtIFW compiler \"binarycreator\": "
"likely it is not installed, or not in your PATH"
@ -276,24 +243,17 @@ int cmCPackIFWGenerator::InitializeInternal()
// Look 'repogen' executable (optional)
const char *RepoGenStr = this->GetOption(RepoGenOpt);
if(!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr))
{
const char* RepoGenStr = this->GetOption(RepoGenOpt);
if (!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr)) {
RepoGen = "";
}
else
{
} else {
RepoGen = RepoGenStr;
}
// Framework version
if(const char* FrameworkVersionSrt =
this->GetOption(FrameworkVersionOpt))
{
if (const char* FrameworkVersionSrt = this->GetOption(FrameworkVersionOpt)) {
FrameworkVersion = FrameworkVersionSrt;
}
else
{
} else {
FrameworkVersion = "1.9.9";
}
@ -304,28 +264,20 @@ int cmCPackIFWGenerator::InitializeInternal()
// Additional packages dirs
PkgsDirsVector.clear();
if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES"))
{
cmSystemTools::ExpandListArgument(dirs,
PkgsDirsVector);
if (const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES")) {
cmSystemTools::ExpandListArgument(dirs, PkgsDirsVector);
}
// Installer
Installer.Generator = this;
Installer.ConfigureFromOptions();
if (const char* ifwDownloadAll =
this->GetOption("CPACK_IFW_DOWNLOAD_ALL"))
{
if (const char* ifwDownloadAll = this->GetOption("CPACK_IFW_DOWNLOAD_ALL")) {
OnlineOnly = cmSystemTools::IsOn(ifwDownloadAll);
}
else if (const char* cpackDownloadAll =
this->GetOption("CPACK_DOWNLOAD_ALL"))
{
} else if (const char* cpackDownloadAll =
this->GetOption("CPACK_DOWNLOAD_ALL")) {
OnlineOnly = cmSystemTools::IsOn(cpackDownloadAll);
}
else
{
} else {
OnlineOnly = false;
}
@ -338,28 +290,22 @@ int cmCPackIFWGenerator::InitializeInternal()
}
// Executable suffix
if(const char *optExeSuffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX"))
{
if (const char* optExeSuffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX")) {
ExecutableSuffix = optExeSuffix;
if(ExecutableSuffix.empty())
{
if (ExecutableSuffix.empty()) {
std::string sysName(this->GetOption("CMAKE_SYSTEM_NAME"));
if(sysName == "Linux")
{
if (sysName == "Linux") {
ExecutableSuffix = ".run";
}
}
}
else
{
} else {
ExecutableSuffix = cmCPackGenerator::GetOutputExtension();
}
return this->Superclass::InitializeInternal();
}
std::string
cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
std::string cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
const std::string& componentName)
{
const std::string prefix = "packages/";
@ -369,92 +315,78 @@ cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
return std::string(prefix + GetRootPackageName() + suffix);
}
return prefix
+ GetComponentPackageName(&Components[componentName])
+ suffix;
return prefix + GetComponentPackageName(&Components[componentName]) + suffix;
}
cmCPackComponent*
cmCPackIFWGenerator::GetComponent(const std::string &projectName,
const std::string &componentName)
cmCPackComponent* cmCPackIFWGenerator::GetComponent(
const std::string& projectName, const std::string& componentName)
{
ComponentsMap::iterator cit = Components.find(componentName);
if ( cit != Components.end() ) return &(cit->second);
if (cit != Components.end())
return &(cit->second);
cmCPackComponent* component
= cmCPackGenerator::GetComponent(projectName, componentName);
if(!component) return component;
cmCPackComponent* component =
cmCPackGenerator::GetComponent(projectName, componentName);
if (!component)
return component;
std::string name = GetComponentPackageName(component);
PackagesMap::iterator pit = Packages.find(name);
if(pit != Packages.end()) return component;
if (pit != Packages.end())
return component;
cmCPackIFWPackage *package = &Packages[name];
cmCPackIFWPackage* package = &Packages[name];
package->Name = name;
package->Generator = this;
if(package->ConfigureFromComponent(component))
{
if (package->ConfigureFromComponent(component)) {
package->Installer = &Installer;
Installer.Packages.insert(
std::pair<std::string, cmCPackIFWPackage*>(
name, package));
std::pair<std::string, cmCPackIFWPackage*>(name, package));
ComponentPackages.insert(
std::pair<cmCPackComponent*, cmCPackIFWPackage*>(
component, package));
if(component->IsDownloaded)
{
std::pair<cmCPackComponent*, cmCPackIFWPackage*>(component, package));
if (component->IsDownloaded) {
DownloadedPackages.insert(package);
}
else
{
} else {
BinaryPackages.insert(package);
}
}
else
{
} else {
Packages.erase(name);
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot configure package \"" << name <<
"\" for component \"" << component->Name << "\""
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot configure package \""
<< name << "\" for component \"" << component->Name << "\""
<< std::endl);
}
return component;
}
cmCPackComponentGroup*
cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName,
const std::string &groupName)
cmCPackComponentGroup* cmCPackIFWGenerator::GetComponentGroup(
const std::string& projectName, const std::string& groupName)
{
cmCPackComponentGroup* group
= cmCPackGenerator::GetComponentGroup(projectName, groupName);
if(!group) return group;
cmCPackComponentGroup* group =
cmCPackGenerator::GetComponentGroup(projectName, groupName);
if (!group)
return group;
std::string name = GetGroupPackageName(group);
PackagesMap::iterator pit = Packages.find(name);
if(pit != Packages.end()) return group;
if (pit != Packages.end())
return group;
cmCPackIFWPackage *package = &Packages[name];
cmCPackIFWPackage* package = &Packages[name];
package->Name = name;
package->Generator = this;
if(package->ConfigureFromGroup(group))
{
if (package->ConfigureFromGroup(group)) {
package->Installer = &Installer;
Installer.Packages.insert(
std::pair<std::string, cmCPackIFWPackage*>(
name, package));
std::pair<std::string, cmCPackIFWPackage*>(name, package));
GroupPackages.insert(
std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(
group, package));
std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(group, package));
BinaryPackages.insert(package);
}
else
{
} else {
Packages.erase(name);
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot configure package \"" << name <<
"\" for component group \"" << group->Name << "\""
<< std::endl);
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot configure package \""
<< name << "\" for component group \"" << group->Name
<< "\"" << std::endl);
}
return group;
}
@ -485,53 +417,44 @@ std::string cmCPackIFWGenerator::GetRootPackageName()
// Default value
std::string name = "root";
if (const char* optIFW_PACKAGE_GROUP =
this->GetOption("CPACK_IFW_PACKAGE_GROUP"))
{
this->GetOption("CPACK_IFW_PACKAGE_GROUP")) {
// Configure from root group
cmCPackIFWPackage package;
package.Generator = this;
package.ConfigureFromGroup(optIFW_PACKAGE_GROUP);
name = package.Name;
}
else if (const char* optIFW_PACKAGE_NAME =
this->GetOption("CPACK_IFW_PACKAGE_NAME"))
{
} else if (const char* optIFW_PACKAGE_NAME =
this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
// Configure from root package name
name = optIFW_PACKAGE_NAME;
}
else if (const char* optPACKAGE_NAME =
this->GetOption("CPACK_PACKAGE_NAME"))
{
} else if (const char* optPACKAGE_NAME =
this->GetOption("CPACK_PACKAGE_NAME")) {
// Configure from package name
name = optPACKAGE_NAME;
}
return name;
}
std::string
cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
std::string cmCPackIFWGenerator::GetGroupPackageName(
cmCPackComponentGroup* group) const
{
std::string name;
if (!group) return name;
if (cmCPackIFWPackage* package = GetGroupPackage(group))
{
if (!group)
return name;
if (cmCPackIFWPackage* package = GetGroupPackage(group)) {
return package->Name;
}
const char* option = GetOption(
"CPACK_IFW_COMPONENT_GROUP_"
+ cmsys::SystemTools::UpperCase(group->Name)
+ "_NAME");
const char* option =
GetOption("CPACK_IFW_COMPONENT_GROUP_" +
cmsys::SystemTools::UpperCase(group->Name) + "_NAME");
name = option ? option : group->Name;
if(group->ParentGroup)
{
if (group->ParentGroup) {
cmCPackIFWPackage* package = GetGroupPackage(group->ParentGroup);
bool dot = !ResolveDuplicateNames;
if(dot && name.substr(0, package->Name.size()) == package->Name)
{
if (dot && name.substr(0, package->Name.size()) == package->Name) {
dot = false;
}
if(dot)
{
if (dot) {
name = package->Name + "." + name;
}
}
@ -539,34 +462,29 @@ cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
}
std::string cmCPackIFWGenerator::GetComponentPackageName(
cmCPackComponent *component) const
cmCPackComponent* component) const
{
std::string name;
if (!component) return name;
if (cmCPackIFWPackage* package = GetComponentPackage(component))
{
if (!component)
return name;
if (cmCPackIFWPackage* package = GetComponentPackage(component)) {
return package->Name;
}
std::string prefix = "CPACK_IFW_COMPONENT_"
+ cmsys::SystemTools::UpperCase(component->Name)
+ "_";
std::string prefix = "CPACK_IFW_COMPONENT_" +
cmsys::SystemTools::UpperCase(component->Name) + "_";
const char* option = GetOption(prefix + "NAME");
name = option ? option : component->Name;
if(component->Group)
{
if (component->Group) {
cmCPackIFWPackage* package = GetGroupPackage(component->Group);
if((componentPackageMethod == ONE_PACKAGE_PER_GROUP)
|| IsOn(prefix + "COMMON"))
{
if ((componentPackageMethod == ONE_PACKAGE_PER_GROUP) ||
IsOn(prefix + "COMMON")) {
return package->Name;
}
bool dot = !ResolveDuplicateNames;
if(dot && name.substr(0, package->Name.size()) == package->Name)
{
if (dot && name.substr(0, package->Name.size()) == package->Name) {
dot = false;
}
if(dot)
{
if (dot) {
name = package->Name + "." + name;
}
}
@ -574,32 +492,29 @@ std::string cmCPackIFWGenerator::GetComponentPackageName(
}
cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
cmCPackComponentGroup *group) const
cmCPackComponentGroup* group) const
{
std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit
= GroupPackages.find(group);
std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit =
GroupPackages.find(group);
return pit != GroupPackages.end() ? pit->second : 0;
}
cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
cmCPackComponent *component) const
cmCPackComponent* component) const
{
std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit
= ComponentPackages.find(component);
std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit =
ComponentPackages.find(component);
return pit != ComponentPackages.end() ? pit->second : 0;
}
void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmXMLWriter &xout)
void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmXMLWriter& xout)
{
std::stringstream comment;
comment << "Generated by CPack " << CMake_VERSION << " IFW generator "
<< "for QtIFW ";
if(IsVersionLess("2.0"))
{
if (IsVersionLess("2.0")) {
comment << "less 2.0";
}
else
{
} else {
comment << FrameworkVersion;
}
comment << " tools at " << cmTimestamp().CurrentTime("", true);

20
Source/CPack/IFW/cmCPackIFWGenerator.h
View File

@ -49,17 +49,17 @@ public:
/**
* Compare \a version with QtIFW framework version
*/
bool IsVersionLess(const char *version);
bool IsVersionLess(const char* version);
/**
* Compare \a version with QtIFW framework version
*/
bool IsVersionGreater(const char *version);
bool IsVersionGreater(const char* version);
/**
* Compare \a version with QtIFW framework version
*/
bool IsVersionEqual(const char *version);
bool IsVersionEqual(const char* version);
protected:
// cmCPackGenerator reimplementation
@ -90,8 +90,7 @@ protected:
*
* @return Pointer to component
*/
virtual cmCPackComponent* GetComponent(
const std::string& projectName,
virtual cmCPackComponent* GetComponent(const std::string& projectName,
const std::string& componentName);
/**
@ -104,8 +103,7 @@ protected:
* @return Pointer to component group
*/
virtual cmCPackComponentGroup* GetComponentGroup(
const std::string& projectName,
const std::string& groupName);
const std::string& projectName, const std::string& groupName);
enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
virtual bool SupportsAbsoluteDestination() const;
@ -118,11 +116,11 @@ protected:
std::string GetRootPackageName();
std::string GetGroupPackageName(cmCPackComponentGroup *group) const;
std::string GetComponentPackageName(cmCPackComponent *component) const;
std::string GetGroupPackageName(cmCPackComponentGroup* group) const;
std::string GetComponentPackageName(cmCPackComponent* component) const;
cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup *group) const;
cmCPackIFWPackage* GetComponentPackage(cmCPackComponent *component) const;
cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup* group) const;
cmCPackIFWPackage* GetComponentPackage(cmCPackComponent* component) const;
void WriteGeneratedByToStrim(cmXMLWriter& xout);

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

@ -20,299 +20,229 @@
#include <cmXMLWriter.h>
#ifdef cmCPackLogger
# undef cmCPackLogger
#undef cmCPackLogger
#endif
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
if(Generator) { \
if (Generator) { \
Generator->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} \
} while ( 0 )
} while (0)
cmCPackIFWInstaller::cmCPackIFWInstaller() :
Generator(0)
cmCPackIFWInstaller::cmCPackIFWInstaller()
: 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;
}
bool cmCPackIFWInstaller::IsOn(const std::string &op) const
bool cmCPackIFWInstaller::IsOn(const std::string& op) const
{
return Generator ? Generator->IsOn(op) : false;
}
bool cmCPackIFWInstaller::IsVersionLess(const char *version)
bool cmCPackIFWInstaller::IsVersionLess(const char* version)
{
return Generator ? Generator->IsVersionLess(version) : false;
}
bool cmCPackIFWInstaller::IsVersionGreater(const char *version)
bool cmCPackIFWInstaller::IsVersionGreater(const char* version)
{
return Generator ? Generator->IsVersionGreater(version) : false;
}
bool cmCPackIFWInstaller::IsVersionEqual(const char *version)
bool cmCPackIFWInstaller::IsVersionEqual(const char* version)
{
return Generator ? Generator->IsVersionEqual(version) : false;
}
void cmCPackIFWInstaller::ConfigureFromOptions()
{
// Name;
if (const char* optIFW_PACKAGE_NAME =
this->GetOption("CPACK_IFW_PACKAGE_NAME"))
{
this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
Name = optIFW_PACKAGE_NAME;
}
else if (const char* optPACKAGE_NAME =
this->GetOption("CPACK_PACKAGE_NAME"))
{
} else if (const char* optPACKAGE_NAME =
this->GetOption("CPACK_PACKAGE_NAME")) {
Name = optPACKAGE_NAME;
}
else
{
} else {
Name = "Your package";
}
// Title;
if (const char* optIFW_PACKAGE_TITLE =
GetOption("CPACK_IFW_PACKAGE_TITLE"))
{
GetOption("CPACK_IFW_PACKAGE_TITLE")) {
Title = optIFW_PACKAGE_TITLE;
}
else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
{
} else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
Title = optPACKAGE_DESCRIPTION_SUMMARY;
}
else
{
} else {
Title = "Your package description";
}
// Version;
if (const char* option = GetOption("CPACK_PACKAGE_VERSION"))
{
if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) {
Version = option;
}
else
{
} else {
Version = "1.0.0";
}
// Publisher
if(const char* optIFW_PACKAGE_PUBLISHER =
GetOption("CPACK_IFW_PACKAGE_PUBLISHER"))
{
if (const char* optIFW_PACKAGE_PUBLISHER =
GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) {
Publisher = optIFW_PACKAGE_PUBLISHER;
}
else if(const char* optPACKAGE_VENDOR = GetOption("CPACK_PACKAGE_VENDOR"))
{
} else if (const char* optPACKAGE_VENDOR =
GetOption("CPACK_PACKAGE_VENDOR")) {
Publisher = optPACKAGE_VENDOR;
}
// ProductUrl
if(const char* option = GetOption("CPACK_IFW_PRODUCT_URL"))
{
if (const char* option = GetOption("CPACK_IFW_PRODUCT_URL")) {
ProductUrl = option;
}
// ApplicationIcon
if(const char* option = GetOption("CPACK_IFW_PACKAGE_ICON"))
{
if(cmSystemTools::FileExists(option))
{
if (const char* option = GetOption("CPACK_IFW_PACKAGE_ICON")) {
if (cmSystemTools::FileExists(option)) {
InstallerApplicationIcon = option;
}
else
{
} else {
// TODO: implement warning
}
}
// WindowIcon
if(const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON"))
{
if(cmSystemTools::FileExists(option))
{
if (const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON")) {
if (cmSystemTools::FileExists(option)) {
InstallerWindowIcon = option;
}
else
{
} else {
// TODO: implement warning
}
}
// Logo
if(const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO"))
{
if(cmSystemTools::FileExists(option))
{
if (const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO")) {
if (cmSystemTools::FileExists(option)) {
Logo = option;
}
else
{
} else {
// TODO: implement warning
}
}
// Start menu
if (const char* optIFW_START_MENU_DIR =
this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY"))
{
this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY")) {
StartMenuDir = optIFW_START_MENU_DIR;
}
else
{
} else {
StartMenuDir = Name;
}
// Default target directory for installation
if (const char* optIFW_TARGET_DIRECTORY =
GetOption("CPACK_IFW_TARGET_DIRECTORY"))
{
GetOption("CPACK_IFW_TARGET_DIRECTORY")) {
TargetDir = optIFW_TARGET_DIRECTORY;
}
else if (const char *optPACKAGE_INSTALL_DIRECTORY =
GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY"))
{
} else if (const char* optPACKAGE_INSTALL_DIRECTORY =
GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY")) {
TargetDir = "@ApplicationsDir@/";
TargetDir += optPACKAGE_INSTALL_DIRECTORY;
}
else
{
} else {
TargetDir = "@RootDir@/usr/local";
}
// Default target directory for installation with administrator rights
if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY"))
{
if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY")) {
AdminTargetDir = option;
}
// Repositories
Repositories.clear();
RepositoryStruct Repo;
if(const char *site = this->GetOption("CPACK_DOWNLOAD_SITE"))
{
if (const char* site = this->GetOption("CPACK_DOWNLOAD_SITE")) {
Repo.Url = site;
Repositories.push_back(Repo);
}
if(const char *RepoAllStr = this->GetOption("CPACK_IFW_REPOSITORIES_ALL"))
{
if (const char* RepoAllStr = this->GetOption("CPACK_IFW_REPOSITORIES_ALL")) {
std::vector<std::string> RepoAllVector;
cmSystemTools::ExpandListArgument(RepoAllStr,
RepoAllVector);
for(std::vector<std::string>::iterator
rit = RepoAllVector.begin(); rit != RepoAllVector.end(); ++rit)
{
std::string prefix = "CPACK_IFW_REPOSITORY_"
+ cmsys::SystemTools::UpperCase(*rit)
+ "_";
cmSystemTools::ExpandListArgument(RepoAllStr, RepoAllVector);
for (std::vector<std::string>::iterator rit = RepoAllVector.begin();
rit != RepoAllVector.end(); ++rit) {
std::string prefix =
"CPACK_IFW_REPOSITORY_" + cmsys::SystemTools::UpperCase(*rit) + "_";
// Url
if (const char* url = GetOption(prefix + "URL"))
{
if (const char* url = GetOption(prefix + "URL")) {
Repo.Url = url;
}
else
{
} else {
Repo.Url = "";
}
// Enabled
if (IsOn(prefix + "DISABLED"))
{
if (IsOn(prefix + "DISABLED")) {
Repo.Enabled = "0";
}
else
{
} else {
Repo.Enabled = "";
}
// Username
if (const char* username = GetOption(prefix + "USERNAME"))
{
if (const char* username = GetOption(prefix + "USERNAME")) {
Repo.Username = username;
}
else
{
} else {
Repo.Username = "";
}
// Password
if (const char* password = GetOption(prefix + "PASSWORD"))
{
if (const char* password = GetOption(prefix + "PASSWORD")) {
Repo.Password = password;
}
else
{
} else {
Repo.Password = "";
}
// DisplayName
if (const char* displayName = GetOption(prefix + "DISPLAY_NAME"))
{
if (const char* displayName = GetOption(prefix + "DISPLAY_NAME")) {
Repo.DisplayName = displayName;
}
else
{
} else {
Repo.DisplayName = "";
}
if(!Repo.Url.empty())
{
if (!Repo.Url.empty()) {
Repositories.push_back(Repo);
}
}
}
// Maintenance tool
if(const char* optIFW_MAINTENANCE_TOOL =
this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME"))
{
if (const char* optIFW_MAINTENANCE_TOOL =
this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME")) {
MaintenanceToolName = optIFW_MAINTENANCE_TOOL;
}
// Maintenance tool ini file
if(const char* optIFW_MAINTENANCE_TOOL_INI =
this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE"))
{
if (const char* optIFW_MAINTENANCE_TOOL_INI =
this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE")) {
MaintenanceToolIniFile = optIFW_MAINTENANCE_TOOL_INI;
}
// Allow non-ASCII characters
if(this->GetOption("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS"))
{
if(IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS"))
{
if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
if (IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
AllowNonAsciiCharacters = "true";
}
else
{
} else {
AllowNonAsciiCharacters = "false";
}
}
// Space in path
if(this->GetOption("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH"))
{
if(IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH"))
{
if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
if (IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
AllowSpaceInPath = "true";
}
else
{
} else {
AllowSpaceInPath = "false";
}
}
// Control script
if(const char* optIFW_CONTROL_SCRIPT =
this->GetOption("CPACK_IFW_PACKAGE_CONTROL_SCRIPT"))
{
if (const char* optIFW_CONTROL_SCRIPT =
this->GetOption("CPACK_IFW_PACKAGE_CONTROL_SCRIPT")) {
ControlScript = optIFW_CONTROL_SCRIPT;
}
}
@ -320,8 +250,7 @@ void cmCPackIFWInstaller::ConfigureFromOptions()
void cmCPackIFWInstaller::GenerateInstallerFile()
{
// Lazy directory initialization
if(Directory.empty() && Generator)
{
if (Directory.empty() && Generator) {
Directory = Generator->toplevel;
}
@ -339,41 +268,36 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
xout.Element("Version", Version);
xout.Element("Title", Title);
if(!Publisher.empty())
{
if (!Publisher.empty()) {
xout.Element("Publisher", Publisher);
}
if(!ProductUrl.empty())
{
if (!ProductUrl.empty()) {
xout.Element("ProductUrl", ProductUrl);
}
// ApplicationIcon
if(!InstallerApplicationIcon.empty())
{
if (!InstallerApplicationIcon.empty()) {
std::string name =
cmSystemTools::GetFilenameName(InstallerApplicationIcon);
std::string path = Directory + "/config/" + name;
name = cmSystemTools::GetFilenameWithoutExtension(name);
cmsys::SystemTools::CopyFileIfDifferent(
InstallerApplicationIcon.data(), path.data());
cmsys::SystemTools::CopyFileIfDifferent(InstallerApplicationIcon.data(),
path.data());
xout.Element("InstallerApplicationIcon", name);
}
// WindowIcon
if(!InstallerWindowIcon.empty())
{
if (!InstallerWindowIcon.empty()) {
std::string name = cmSystemTools::GetFilenameName(InstallerWindowIcon);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(
InstallerWindowIcon.data(), path.data());
cmsys::SystemTools::CopyFileIfDifferent(InstallerWindowIcon.data(),
path.data());
xout.Element("InstallerWindowIcon", name);
}
// Logo
if(!Logo.empty())
{
if (!Logo.empty()) {
std::string name = cmSystemTools::GetFilenameName(Logo);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Logo.data(), path.data());
@ -381,51 +305,42 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
}
// Start menu
if(!IsVersionLess("2.0"))
{
if (!IsVersionLess("2.0")) {
xout.Element("StartMenuDir", StartMenuDir);
}
// Target dir
if(!TargetDir.empty())
{
if (!TargetDir.empty()) {
xout.Element("TargetDir", TargetDir);
}
// Admin target dir
if(!AdminTargetDir.empty())
{
if (!AdminTargetDir.empty()) {
xout.Element("AdminTargetDir", AdminTargetDir);
}
// Remote repositories
if (!Repositories.empty())
{
if (!Repositories.empty()) {
xout.StartElement("RemoteRepositories");
for(std::vector<RepositoryStruct>::iterator
rit = Repositories.begin(); rit != Repositories.end(); ++rit)
{
for (std::vector<RepositoryStruct>::iterator rit = Repositories.begin();
rit != Repositories.end(); ++rit) {
xout.StartElement("Repository");
// Url
xout.Element("Url", rit->Url);
// Enabled
if(!rit->Enabled.empty())
{
if (!rit->Enabled.empty()) {
xout.Element("Enabled", rit->Enabled);
}
// Username
if(!rit->Username.empty())
{
if (!rit->Username.empty()) {
xout.Element("Username", rit->Username);
}
// Password
if(!rit->Password.empty())
{
if (!rit->Password.empty()) {
xout.Element("Password", rit->Password);
}
// DisplayName
if(!rit->DisplayName.empty())
{
if (!rit->DisplayName.empty()) {
xout.Element("DisplayName", rit->DisplayName);
}
xout.EndElement();
@ -434,40 +349,32 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
}
// Maintenance tool
if(!IsVersionLess("2.0") && !MaintenanceToolName.empty())
{
if (!IsVersionLess("2.0") && !MaintenanceToolName.empty()) {
xout.Element("MaintenanceToolName", MaintenanceToolName);
}
// Maintenance tool ini file
if(!IsVersionLess("2.0") && !MaintenanceToolIniFile.empty())
{
if (!IsVersionLess("2.0") && !MaintenanceToolIniFile.empty()) {
xout.Element("MaintenanceToolIniFile", MaintenanceToolIniFile);
}
// Different allows
if(IsVersionLess("2.0"))
{
if (IsVersionLess("2.0")) {
// CPack IFW default policy
xout.Comment("CPack IFW default policy for QtIFW less 2.0");
xout.Element("AllowNonAsciiCharacters", "true");
xout.Element("AllowSpaceInPath", "true");
}
else
{
if(!AllowNonAsciiCharacters.empty())
{
} else {
if (!AllowNonAsciiCharacters.empty()) {
xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
}
if(!AllowSpaceInPath.empty())
{
if (!AllowSpaceInPath.empty()) {
xout.Element("AllowSpaceInPath", AllowSpaceInPath);
}
}
// Control script (copy to config dir)
if(!IsVersionLess("2.0") && !ControlScript.empty())
{
if (!IsVersionLess("2.0") && !ControlScript.empty()) {
std::string name = cmSystemTools::GetFilenameName(ControlScript);
std::string path = Directory + "/config/" + name;
cmsys::SystemTools::CopyFileIfDifferent(ControlScript.data(), path.data());
@ -480,20 +387,16 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
void cmCPackIFWInstaller::GeneratePackageFiles()
{
if (Packages.empty() || Generator->IsOnePackage())
{
if (Packages.empty() || Generator->IsOnePackage()) {
// Generate default package
cmCPackIFWPackage package;
package.Generator = Generator;
package.Installer = this;
// Check package group
if (const char* option = GetOption("CPACK_IFW_PACKAGE_GROUP"))
{
if (const char* option = GetOption("CPACK_IFW_PACKAGE_GROUP")) {
package.ConfigureFromGroup(option);
package.ForcedInstallation = "true";
}
else
{
} else {
package.ConfigureFromOptions();
}
package.GeneratePackageFile();
@ -501,15 +404,15 @@ void cmCPackIFWInstaller::GeneratePackageFiles()
}
// Generate packages meta information
for(PackagesMap::iterator pit = Packages.begin();
pit != Packages.end(); ++pit)
{
for (PackagesMap::iterator pit = Packages.begin(); pit != Packages.end();
++pit) {
cmCPackIFWPackage* package = pit->second;
package->GeneratePackageFile();
}
}
void cmCPackIFWInstaller::WriteGeneratedByToStrim(cmXMLWriter &xout)
void cmCPackIFWInstaller::WriteGeneratedByToStrim(cmXMLWriter& xout)
{
if(Generator) Generator->WriteGeneratedByToStrim(xout);
if (Generator)
Generator->WriteGeneratedByToStrim(xout);
}

6
Source/CPack/IFW/cmCPackIFWInstaller.h
View File

@ -103,9 +103,9 @@ public:
const char* GetOption(const std::string& op) const;
bool IsOn(const std::string& op) const;
bool IsVersionLess(const char *version);
bool IsVersionGreater(const char *version);
bool IsVersionEqual(const char *version);
bool IsVersionLess(const char* version);
bool IsVersionGreater(const char* version);
bool IsVersionEqual(const char* version);
void ConfigureFromOptions();

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

@ -22,21 +22,21 @@
//----------------------------------------------------------------- Logger ---
#ifdef cmCPackLogger
# undef cmCPackLogger
#undef cmCPackLogger
#endif
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
if(Generator) { \
if (Generator) { \
Generator->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} \
} while ( 0 )
} while (0)
//---------------------------------------------------------- CompareStruct ---
cmCPackIFWPackage::CompareStruct::CompareStruct() :
Type(CompareNone)
cmCPackIFWPackage::CompareStruct::CompareStruct()
: Type(CompareNone)
{
}
@ -46,32 +46,23 @@ cmCPackIFWPackage::DependenceStruct::DependenceStruct()
}
cmCPackIFWPackage::DependenceStruct::DependenceStruct(
const std::string &dependence)
const std::string& dependence)
{
// Search compare section
size_t pos = std::string::npos;
if((pos = dependence.find("<=")) != std::string::npos)
{
if ((pos = dependence.find("<=")) != std::string::npos) {
Compare.Type = CompareLessOrEqual;
Compare.Value = dependence.substr(pos + 2);
}
else if((pos = dependence.find(">=")) != std::string::npos)
{
} else if ((pos = dependence.find(">=")) != std::string::npos) {
Compare.Type = CompareGreaterOrEqual;
Compare.Value = dependence.substr(pos + 2);
}
else if((pos = dependence.find("<")) != std::string::npos)
{
} else if ((pos = dependence.find("<")) != std::string::npos) {
Compare.Type = CompareLess;
Compare.Value = dependence.substr(pos + 1);
}
else if((pos = dependence.find("=")) != std::string::npos)
{
} else if ((pos = dependence.find("=")) != std::string::npos) {
Compare.Type = CompareEqual;
Compare.Value = dependence.substr(pos + 1);
}
else if((pos = dependence.find(">")) != std::string::npos)
{
} else if ((pos = dependence.find(">")) != std::string::npos) {
Compare.Type = CompareGreater;
Compare.Value = dependence.substr(pos + 1);
}
@ -80,28 +71,20 @@ cmCPackIFWPackage::DependenceStruct::DependenceStruct(
std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
{
if (Compare.Type == CompareNone) return Name;
if (Compare.Type == CompareNone)
return Name;
std::string result = Name;
if (Compare.Type == CompareLessOrEqual)
{
if (Compare.Type == CompareLessOrEqual) {
result += "<=";
}
else if (Compare.Type == CompareGreaterOrEqual)
{
} else if (Compare.Type == CompareGreaterOrEqual) {
result += ">=";
}
else if (Compare.Type == CompareLess)
{
} else if (Compare.Type == CompareLess) {
result += "<";
}
else if (Compare.Type == CompareEqual)
{
} else if (Compare.Type == CompareEqual) {
result += "=";
}
else if (Compare.Type == CompareGreater)
{
} else if (Compare.Type == CompareGreater) {
result += ">";
}
@ -111,45 +94,45 @@ std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
}
//------------------------------------------------------ cmCPackIFWPackage ---
cmCPackIFWPackage::cmCPackIFWPackage() :
Generator(0),
Installer(0)
cmCPackIFWPackage::cmCPackIFWPackage()
: Generator(0)
, Installer(0)
{
}
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;
}
bool cmCPackIFWPackage::IsOn(const std::string &op) const
bool cmCPackIFWPackage::IsOn(const std::string& op) const
{
return Generator ? Generator->IsOn(op) : false;
}
bool cmCPackIFWPackage::IsVersionLess(const char *version)
bool cmCPackIFWPackage::IsVersionLess(const char* version)
{
return Generator ? Generator->IsVersionLess(version) : false;
}
bool cmCPackIFWPackage::IsVersionGreater(const char *version)
bool cmCPackIFWPackage::IsVersionGreater(const char* version)
{
return Generator ? Generator->IsVersionGreater(version) : false;
}
bool cmCPackIFWPackage::IsVersionEqual(const char *version)
bool cmCPackIFWPackage::IsVersionEqual(const char* version)
{
return Generator ? Generator->IsVersionEqual(version) : false;
}
std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent* component)
{
if (!component) return "";
const char* option = GetOption(
"CPACK_IFW_COMPONENT_"
+ cmsys::SystemTools::UpperCase(component->Name)
+ "_NAME");
if (!component)
return "";
const char* option =
GetOption("CPACK_IFW_COMPONENT_" +
cmsys::SystemTools::UpperCase(component->Name) + "_NAME");
return option ? option : component->Name;
}
@ -177,33 +160,24 @@ int cmCPackIFWPackage::ConfigureFromOptions()
Name = Generator->GetRootPackageName();
// Display name
if (const char *option = this->GetOption("CPACK_PACKAGE_NAME"))
{
if (const char* option = this->GetOption("CPACK_PACKAGE_NAME")) {
DisplayName = option;
}
else
{
} else {
DisplayName = "Your package";
}
// Description
if (const char* option =
this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
{
this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
Description = option;
}
else
{
} else {
Description = "Your package description";
}
// Version
if(const char* option = GetOption("CPACK_PACKAGE_VERSION"))
{
if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) {
Version = option;
}
else
{
} else {
Version = "1.0.0";
}
@ -212,16 +186,16 @@ int cmCPackIFWPackage::ConfigureFromOptions()
return 1;
}
int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
{
if(!component) return 0;
if (!component)
return 0;
// Restore defaul configuration
DefaultConfiguration();
std::string prefix = "CPACK_IFW_COMPONENT_"
+ cmsys::SystemTools::UpperCase(component->Name)
+ "_";
std::string prefix = "CPACK_IFW_COMPONENT_" +
cmsys::SystemTools::UpperCase(component->Name) + "_";
// Display name
DisplayName = component->DisplayName;
@ -230,55 +204,40 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
Description = component->Description;
// Version
if(const char* optVERSION = GetOption(prefix + "VERSION"))
{
if (const char* optVERSION = GetOption(prefix + "VERSION")) {
Version = optVERSION;
}
else if(const char* optPACKAGE_VERSION =
GetOption("CPACK_PACKAGE_VERSION"))
{
} else if (const char* optPACKAGE_VERSION =
GetOption("CPACK_PACKAGE_VERSION")) {
Version = optPACKAGE_VERSION;
}
else
{
} else {
Version = "1.0.0";
}
// Script
if (const char* option = GetOption(prefix + "SCRIPT"))
{
if (const char* option = GetOption(prefix + "SCRIPT")) {
Script = option;
}
// CMake dependencies
if (!component->Dependencies.empty())
{
if (!component->Dependencies.empty()) {
std::vector<cmCPackComponent*>::iterator dit;
for(dit = component->Dependencies.begin();
dit != component->Dependencies.end();
++dit)
{
for (dit = component->Dependencies.begin();
dit != component->Dependencies.end(); ++dit) {
Dependencies.insert(Generator->ComponentPackages[*dit]);
}
}
// QtIFW dependencies
if(const char* option = this->GetOption(prefix + "DEPENDS"))
{
if (const char* option = this->GetOption(prefix + "DEPENDS")) {
std::vector<std::string> deps;
cmSystemTools::ExpandListArgument(option,
deps);
for(std::vector<std::string>::iterator
dit = deps.begin(); dit != deps.end(); ++dit)
{
cmSystemTools::ExpandListArgument(option, deps);
for (std::vector<std::string>::iterator dit = deps.begin();
dit != deps.end(); ++dit) {
DependenceStruct dep(*dit);
if (!Generator->Packages.count(dep.Name))
{
if (!Generator->Packages.count(dep.Name)) {
bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
DependenceStruct &depRef =
Generator->DependentPackages[dep.Name];
if(!hasDep)
{
DependenceStruct& depRef = Generator->DependentPackages[dep.Name];
if (!hasDep) {
depRef = dep;
}
AlienDependencies.insert(&depRef);
@ -287,13 +246,13 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
}
// Licenses
if (const char* option = this->GetOption(prefix + "LICENSES"))
{
if (const char* option = this->GetOption(prefix + "LICENSES")) {
Licenses.clear();
cmSystemTools::ExpandListArgument( option, Licenses );
if ( Licenses.size() % 2 != 0 )
{
cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
cmSystemTools::ExpandListArgument(option, Licenses);
if (Licenses.size() % 2 != 0) {
cmCPackLogger(
cmCPackLog::LOG_WARNING, prefix
<< "LICENSES"
<< " should contain pairs of <display_name> and <file_path>."
<< std::endl);
Licenses.clear();
@ -301,8 +260,7 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
}
// Priority
if(const char* option = this->GetOption(prefix + "PRIORITY"))
{
if (const char* option = this->GetOption(prefix + "PRIORITY")) {
SortingPriority = option;
}
@ -318,50 +276,43 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
return 1;
}
int
cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
{
if(!group) return 0;
if (!group)
return 0;
// Restore defaul configuration
DefaultConfiguration();
std::string prefix = "CPACK_IFW_COMPONENT_GROUP_"
+ cmsys::SystemTools::UpperCase(group->Name)
+ "_";
std::string prefix = "CPACK_IFW_COMPONENT_GROUP_" +
cmsys::SystemTools::UpperCase(group->Name) + "_";
DisplayName = group->DisplayName;
Description = group->Description;
// Version
if(const char* optVERSION = GetOption(prefix + "VERSION"))
{
if (const char* optVERSION = GetOption(prefix + "VERSION")) {
Version = optVERSION;
}
else if(const char* optPACKAGE_VERSION =
GetOption("CPACK_PACKAGE_VERSION"))
{
} else if (const char* optPACKAGE_VERSION =
GetOption("CPACK_PACKAGE_VERSION")) {
Version = optPACKAGE_VERSION;
}
else
{
} else {
Version = "1.0.0";
}
// Script
if (const char* option = GetOption(prefix + "SCRIPT"))
{
if (const char* option = GetOption(prefix + "SCRIPT")) {
Script = option;
}
// Licenses
if (const char* option = this->GetOption(prefix + "LICENSES"))
{
if (const char* option = this->GetOption(prefix + "LICENSES")) {
Licenses.clear();
cmSystemTools::ExpandListArgument( option, Licenses );
if ( Licenses.size() % 2 != 0 )
{
cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
cmSystemTools::ExpandListArgument(option, Licenses);
if (Licenses.size() % 2 != 0) {
cmCPackLogger(
cmCPackLog::LOG_WARNING, prefix
<< "LICENSES"
<< " should contain pairs of <display_name> and <file_path>."
<< std::endl);
Licenses.clear();
@ -369,34 +320,28 @@ cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
}
// Priority
if(const char* option = this->GetOption(prefix + "PRIORITY"))
{
if (const char* option = this->GetOption(prefix + "PRIORITY")) {
SortingPriority = option;
}
return 1;
}
int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
int cmCPackIFWPackage::ConfigureFromGroup(const std::string& groupName)
{
// Group configuration
cmCPackComponentGroup group;
std::string prefix = "CPACK_COMPONENT_GROUP_"
+ cmsys::SystemTools::UpperCase(groupName)
+ "_";
std::string prefix =
"CPACK_COMPONENT_GROUP_" + cmsys::SystemTools::UpperCase(groupName) + "_";
if (const char *option = GetOption(prefix + "DISPLAY_NAME"))
{
if (const char* option = GetOption(prefix + "DISPLAY_NAME")) {
group.DisplayName = option;
}
else
{
} else {
group.DisplayName = group.Name;
}
if (const char* option = GetOption(prefix + "DESCRIPTION"))
{
if (const char* option = GetOption(prefix + "DESCRIPTION")) {
group.Description = option;
}
group.IsBold = IsOn(prefix + "BOLD_TITLE");
@ -406,12 +351,9 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
group.Name = groupName;
if(Generator)
{
if (Generator) {
Name = Generator->GetGroupPackageName(&group);
}
else
{
} else {
Name = group.Name;
}
@ -421,14 +363,10 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
void cmCPackIFWPackage::GeneratePackageFile()
{
// Lazy directory initialization
if (Directory.empty())
{
if(Installer)
{
if (Directory.empty()) {
if (Installer) {
Directory = Installer->Directory + "/packages/" + Name;
}
else if (Generator)
{
} else if (Generator) {
Directory = Generator->toplevel + "/packages/" + Name;
}
}
@ -448,18 +386,14 @@ void cmCPackIFWPackage::GeneratePackageFile()
xout.Element("Name", Name);
xout.Element("Version", Version);
if (!ReleaseDate.empty())
{
if (!ReleaseDate.empty()) {
xout.Element("ReleaseDate", ReleaseDate);
}
else
{
} else {
xout.Element("ReleaseDate", cmTimestamp().CurrentTime("%Y-%m-%d", true));
}
// Script (copy to meta dir)
if(!Script.empty())
{
if (!Script.empty()) {
std::string name = cmSystemTools::GetFilenameName(Script);
std::string path = Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data());
@ -468,25 +402,21 @@ void cmCPackIFWPackage::GeneratePackageFile()
// Dependencies
std::set<DependenceStruct> compDepSet;
for(std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
ait != AlienDependencies.end(); ++ait)
{
for (std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
ait != AlienDependencies.end(); ++ait) {
compDepSet.insert(*(*ait));
}
for(std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
it != Dependencies.end(); ++it)
{
for (std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
it != Dependencies.end(); ++it) {
compDepSet.insert(DependenceStruct((*it)->Name));
}
// Write dependencies
if (!compDepSet.empty())
{
if (!compDepSet.empty()) {
std::stringstream dependencies;
std::set<DependenceStruct>::iterator it = compDepSet.begin();
dependencies << it->NameWithCompare();
++it;
while(it != compDepSet.end())
{
while (it != compDepSet.end()) {
dependencies << "," << it->NameWithCompare();
++it;
}
@ -495,18 +425,15 @@ void cmCPackIFWPackage::GeneratePackageFile()
// Licenses (copy to meta dir)
std::vector<std::string> licenses = Licenses;
for(size_t i = 1; i < licenses.size(); i += 2)
{
for (size_t i = 1; i < licenses.size(); i += 2) {
std::string name = cmSystemTools::GetFilenameName(licenses[i]);
std::string path = Directory + "/meta/" + name;
cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data());
licenses[i] = name;
}
if(!licenses.empty())
{
if (!licenses.empty()) {
xout.StartElement("Licenses");
for(size_t i = 0; i < licenses.size(); i += 2)
{
for (size_t i = 0; i < licenses.size(); i += 2) {
xout.StartElement("License");
xout.Attribute("name", licenses[i]);
xout.Attribute("file", licenses[i + 1]);
@ -515,23 +442,18 @@ void cmCPackIFWPackage::GeneratePackageFile()
xout.EndElement();
}
if (!ForcedInstallation.empty())
{
if (!ForcedInstallation.empty()) {
xout.Element("ForcedInstallation", ForcedInstallation);
}
if (!Virtual.empty())
{
if (!Virtual.empty()) {
xout.Element("Virtual", Virtual);
}
else if (!Default.empty())
{
} else if (!Default.empty()) {
xout.Element("Default", Default);
}
// Priority
if(!SortingPriority.empty())
{
if (!SortingPriority.empty()) {
xout.Element("SortingPriority", SortingPriority);
}
@ -539,7 +461,8 @@ void cmCPackIFWPackage::GeneratePackageFile()
xout.EndDocument();
}
void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter &xout)
void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter& xout)
{
if(Generator) Generator->WriteGeneratedByToStrim(xout);
if (Generator)
Generator->WriteGeneratedByToStrim(xout);
}

18
Source/CPack/IFW/cmCPackIFWPackage.h
View File

@ -50,14 +50,14 @@ public:
struct DependenceStruct
{
DependenceStruct();
DependenceStruct(const std::string &dependence);
DependenceStruct(const std::string& dependence);
std::string Name;
CompareStruct Compare;
std::string NameWithCompare() const;
bool operator < (const DependenceStruct &other) const
bool operator<(const DependenceStruct& other) const
{
return Name < other.Name;
}
@ -113,18 +113,18 @@ public:
const char* GetOption(const std::string& op) const;
bool IsOn(const std::string& op) const;
bool IsVersionLess(const char *version);
bool IsVersionGreater(const char *version);
bool IsVersionEqual(const char *version);
bool IsVersionLess(const char* version);
bool IsVersionGreater(const char* version);
bool IsVersionEqual(const char* version);
std::string GetComponentName(cmCPackComponent *component);
std::string GetComponentName(cmCPackComponent* component);
void DefaultConfiguration();
int ConfigureFromOptions();
int ConfigureFromComponent(cmCPackComponent *component);
int ConfigureFromGroup(cmCPackComponentGroup *group);
int ConfigureFromGroup(const std::string &groupName);
int ConfigureFromComponent(cmCPackComponent* component);
int ConfigureFromGroup(cmCPackComponentGroup* group);
int ConfigureFromGroup(const std::string& groupName);
void GeneratePackageFile();

70
Source/CPack/OSXScriptLauncher.cxx
View File

@ -26,64 +26,57 @@
int main(int argc, char* argv[])
{
//if ( cmsys::SystemTools::FileExists(
// if ( cmsys::SystemTools::FileExists(
std::string cwd = cmsys::SystemTools::GetCurrentWorkingDirectory();
cmsys::ofstream ofs("/tmp/output.txt");
CFStringRef fileName;
CFBundleRef appBundle;
CFURLRef scriptFileURL;
UInt8 *path;
UInt8* path;
//get CF URL for script
if (! (appBundle = CFBundleGetMainBundle()))
{
// get CF URL for script
if (!(appBundle = CFBundleGetMainBundle())) {
DebugError("Cannot get main bundle");
return 1;
}
fileName = CFSTR("RuntimeScript");
if (! (scriptFileURL = CFBundleCopyResourceURL(appBundle, fileName, NULL,
NULL)))
{
if (!(scriptFileURL =
CFBundleCopyResourceURL(appBundle, fileName, NULL, NULL))) {
DebugError("CFBundleCopyResourceURL failed");
return 1;
}
//create path string
if (! (path = new UInt8[PATH_MAX]))
{
// create path string
if (!(path = new UInt8[PATH_MAX])) {
return 1;
}
//get the file system path of the url as a cstring
//in an encoding suitable for posix apis
if ( CFURLGetFileSystemRepresentation(scriptFileURL, true, path,
PATH_MAX) == false)
{
// get the file system path of the url as a cstring
// in an encoding suitable for posix apis
if (CFURLGetFileSystemRepresentation(scriptFileURL, true, path, PATH_MAX) ==
false) {
DebugError("CFURLGetFileSystemRepresentation failed");
return 1;
}
//dispose of the CF variable
// dispose of the CF variable
CFRelease(scriptFileURL);
std::string fullScriptPath = reinterpret_cast<char*>(path);
delete [] path;
delete[] path;
if (! cmsys::SystemTools::FileExists(fullScriptPath.c_str()))
{
if (!cmsys::SystemTools::FileExists(fullScriptPath.c_str())) {
return 1;
}
std::string scriptDirectory = cmsys::SystemTools::GetFilenamePath(
fullScriptPath);
std::string scriptDirectory =
cmsys::SystemTools::GetFilenamePath(fullScriptPath);
ofs << fullScriptPath.c_str() << std::endl;
std::vector<const char*> args;
args.push_back(fullScriptPath.c_str());
int cc;
for ( cc = 1; cc < argc; ++ cc )
{
for (cc = 1; cc < argc; ++cc) {
args.push_back(argv[cc]);
}
args.push_back(0);
@ -98,15 +91,12 @@ int main(int argc, char* argv[])
std::vector<char> tempOutput;
char* data;
int length;
while(cmsysProcess_WaitForData(cp, &data, &length, 0))
{
while (cmsysProcess_WaitForData(cp, &data, &length, 0)) {
// Translate NULL characters in the output into valid text.
// Visual Studio 7 puts these characters in the output of its
// build process.
for(int i=0; i < length; ++i)
{
if(data[i] == '\0')
{
for (int i = 0; i < length; ++i) {
if (data[i] == '\0') {
data[i] = ' ';
}
}
@ -116,27 +106,19 @@ int main(int argc, char* argv[])
cmsysProcess_WaitForExit(cp, 0);
bool result = true;
if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exited)
{
if ( cmsysProcess_GetExitValue(cp) != 0 )
{
if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
if (cmsysProcess_GetExitValue(cp) != 0) {
result = false;
}
}
else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exception)
{
} else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exception) {
const char* exception_str = cmsysProcess_GetExceptionString(cp);
std::cerr << exception_str << std::endl;
result = false;
}
else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Error)
{
} else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
const char* error_str = cmsysProcess_GetErrorString(cp);
std::cerr << error_str << std::endl;
result = false;
}
else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Expired)
{
} else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Expired) {
const char* error_str = "Process terminated due to timeout\n";
std::cerr << error_str << std::endl;
result = false;

637
Source/CPack/WiX/cmCPackWIXGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

69
Source/CPack/WiX/cmCPackWIXGenerator.h
View File

@ -42,25 +42,16 @@ protected:
virtual int PackageFiles();
virtual const char* GetOutputExtension()
{
return ".msi";
}
virtual const char* GetOutputExtension() { return ".msi"; }
virtual enum CPackSetDestdirSupport SupportsSetDestdir() const
{
return SETDESTDIR_UNSUPPORTED;
}
virtual bool SupportsAbsoluteDestination() const
{
return false;
}
virtual bool SupportsAbsoluteDestination() const { return false; }
virtual bool SupportsComponentInstallation() const
{
return true;
}
virtual bool SupportsComponentInstallation() const { return true; }
private:
typedef std::map<std::string, std::string> id_map_t;
@ -77,11 +68,10 @@ private:
void CreateWiXProductFragmentIncludeFile();
void CopyDefinition(
cmWIXSourceWriter &source, std::string const& name);
void CopyDefinition(cmWIXSourceWriter& source, std::string const& name);
void AddDefinition(cmWIXSourceWriter& source,
std::string const& name, std::string const& value);
void AddDefinition(cmWIXSourceWriter& source, std::string const& name,
std::string const& value);
bool CreateWiXSourceFiles();
@ -89,19 +79,15 @@ private:
bool GenerateMainSourceFileFromTemplate();
bool CreateFeatureHierarchy(
cmWIXFeaturesSourceWriter& featureDefinitions);
bool CreateFeatureHierarchy(cmWIXFeaturesSourceWriter& featureDefinitions);
bool AddComponentsToFeature(
std::string const& rootPath,
std::string const& featureId,
std::string const& rootPath, std::string const& featureId,
cmWIXDirectoriesSourceWriter& directoryDefinitions,
cmWIXFilesSourceWriter& fileDefinitions,
cmWIXFeaturesSourceWriter& featureDefinitions,
cmWIXShortcuts& shortcuts);
cmWIXFeaturesSourceWriter& featureDefinitions, cmWIXShortcuts& shortcuts);
bool CreateShortcuts(
std::string const& cpackComponentName,
bool CreateShortcuts(std::string const& cpackComponentName,
std::string const& featureId,
cmWIXShortcuts const& shortcuts,
bool emitUninstallShortcut,
@ -109,12 +95,9 @@ private:
cmWIXFeaturesSourceWriter& featureDefinitions);
bool CreateShortcutsOfSpecificType(
cmWIXShortcuts::Type type,
std::string const& cpackComponentName,
std::string const& featureId,
std::string const& idPrefix,
cmWIXShortcuts const& shortcuts,
bool emitUninstallShortcut,
cmWIXShortcuts::Type type, std::string const& cpackComponentName,
std::string const& featureId, std::string const& idPrefix,
cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
cmWIXFilesSourceWriter& fileDefinitions,
cmWIXFeaturesSourceWriter& featureDefinitions);
@ -126,13 +109,13 @@ private:
bool RunWiXCommand(std::string const& command);
bool RunCandleCommand(
std::string const& sourceFile, std::string const& objectFile);
bool RunCandleCommand(std::string const& sourceFile,
std::string const& objectFile);
bool RunLightCommand(std::string const& objectFiles);
void AddDirectoryAndFileDefinitons(std::string const& topdir,
std::string const& directoryId,
void AddDirectoryAndFileDefinitons(
std::string const& topdir, std::string const& directoryId,
cmWIXDirectoriesSourceWriter& directoryDefinitions,
cmWIXFilesSourceWriter& fileDefinitions,
cmWIXFeaturesSourceWriter& featureDefinitions,
@ -154,22 +137,20 @@ private:
std::string CreateNewIdForPath(std::string const& path);
static std::string CreateHashedId(
std::string const& path, std::string const& normalizedFilename);
static std::string CreateHashedId(std::string const& path,
std::string const& normalizedFilename);
std::string NormalizeComponentForId(
std::string const& component, size_t& replacementCount);
std::string NormalizeComponentForId(std::string const& component,
size_t& replacementCount);
static bool IsLegalIdCharacter(char c);
void CollectExtensions(
std::string const& variableName, extension_set_t& extensions);
void CollectExtensions(std::string const& variableName,
extension_set_t& extensions);
void AddCustomFlags(
std::string const& variableName, std::ostream& stream);
void AddCustomFlags(std::string const& variableName, std::ostream& stream);
std::string RelativePathWithoutComponentPrefix(
std::string const& path);
std::string RelativePathWithoutComponentPrefix(std::string const& path);
std::vector<std::string> WixSources;
id_map_t PathToIdMap;

58
Source/CPack/WiX/cmWIXAccessControlList.cxx
View File

@ -17,14 +17,12 @@
#include <cmSystemTools.h>
cmWIXAccessControlList::cmWIXAccessControlList(
cmCPackLog *logger,
cmInstalledFile const& installedFile,
cmWIXSourceWriter &sourceWriter):
Logger(logger),
InstalledFile(installedFile),
SourceWriter(sourceWriter)
cmCPackLog* logger, cmInstalledFile const& installedFile,
cmWIXSourceWriter& sourceWriter)
: Logger(logger)
, InstalledFile(installedFile)
, SourceWriter(sourceWriter)
{
}
bool cmWIXAccessControlList::Apply()
@ -32,20 +30,17 @@ bool cmWIXAccessControlList::Apply()
std::vector<std::string> entries;
this->InstalledFile.GetPropertyAsList("CPACK_WIX_ACL", entries);
for(size_t i = 0; i < entries.size(); ++i)
{
for (size_t i = 0; i < entries.size(); ++i) {
this->CreatePermissionElement(entries[i]);
}
return true;
}
void cmWIXAccessControlList::CreatePermissionElement(
std::string const& entry)
void cmWIXAccessControlList::CreatePermissionElement(std::string const& entry)
{
std::string::size_type pos = entry.find('=');
if(pos == std::string::npos)
{
if (pos == std::string::npos) {
this->ReportError(entry, "Did not find mandatory '='");
return;
}
@ -56,13 +51,10 @@ void cmWIXAccessControlList::CreatePermissionElement(
pos = user_and_domain.find('@');
std::string user;
std::string domain;
if(pos != std::string::npos)
{
if (pos != std::string::npos) {
user = user_and_domain.substr(0, pos);
domain = user_and_domain.substr(pos + 1);
}
else
{
} else {
user = user_and_domain;
}
@ -71,31 +63,26 @@ void cmWIXAccessControlList::CreatePermissionElement(
this->SourceWriter.BeginElement("Permission");
this->SourceWriter.AddAttribute("User", user);
if(!domain.empty())
{
if (!domain.empty()) {
this->SourceWriter.AddAttribute("Domain", domain);
}
for(size_t i = 0; i < permissions.size(); ++i)
{
for (size_t i = 0; i < permissions.size(); ++i) {
this->EmitBooleanAttribute(entry,
cmSystemTools::TrimWhitespace(permissions[i]));
}
this->SourceWriter.EndElement("Permission");
}
void cmWIXAccessControlList::ReportError(
std::string const& entry,
void cmWIXAccessControlList::ReportError(std::string const& entry,
std::string const& message)
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Failed processing ACL entry '" << entry <<
"': " << message << std::endl);
cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed processing ACL entry '"
<< entry << "': " << message << std::endl);
}
bool cmWIXAccessControlList::IsBooleanAttribute(std::string const& name)
{
static const char* validAttributes[] =
{
static const char* validAttributes[] = {
/* clang-format needs this comment to break after the opening brace */
"Append",
"ChangePermission",
@ -128,19 +115,18 @@ bool cmWIXAccessControlList::IsBooleanAttribute(std::string const& name)
};
size_t i = 0;
while(validAttributes[i])
{
if(name == validAttributes[i++]) return true;
while (validAttributes[i]) {
if (name == validAttributes[i++])
return true;
}
return false;
}
void cmWIXAccessControlList::EmitBooleanAttribute(
std::string const& entry, std::string const& name)
void cmWIXAccessControlList::EmitBooleanAttribute(std::string const& entry,
std::string const& name)
{
if(!this->IsBooleanAttribute(name))
{
if (!this->IsBooleanAttribute(name)) {
std::stringstream message;
message << "Unknown boolean attribute '" << name << "'";
this->ReportError(entry, message.str());

10
Source/CPack/WiX/cmWIXAccessControlList.h
View File

@ -21,10 +21,9 @@
class cmWIXAccessControlList
{
public:
cmWIXAccessControlList(
cmCPackLog *logger,
cmWIXAccessControlList(cmCPackLog* logger,
cmInstalledFile const& installedFile,
cmWIXSourceWriter &sourceWriter);
cmWIXSourceWriter& sourceWriter);
bool Apply();
@ -35,12 +34,11 @@ private:
bool IsBooleanAttribute(std::string const& name);
void EmitBooleanAttribute(
std::string const& entry, std::string const& name);
void EmitBooleanAttribute(std::string const& entry, std::string const& name);
cmCPackLog* Logger;
cmInstalledFile const& InstalledFile;
cmWIXSourceWriter &SourceWriter;
cmWIXSourceWriter& SourceWriter;
};
#endif

23
Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
View File

@ -12,11 +12,10 @@
#include "cmWIXDirectoriesSourceWriter.h"
cmWIXDirectoriesSourceWriter::cmWIXDirectoriesSourceWriter(cmCPackLog* logger,
std::string const& filename):
cmWIXSourceWriter(logger, filename)
cmWIXDirectoriesSourceWriter::cmWIXDirectoriesSourceWriter(
cmCPackLog* logger, std::string const& filename)
: cmWIXSourceWriter(logger, filename)
{
}
void cmWIXDirectoriesSourceWriter::EmitStartMenuFolder(
@ -60,21 +59,16 @@ size_t cmWIXDirectoriesSourceWriter::BeginInstallationPrefixDirectory(
cmSystemTools::SplitPath(installRootString.c_str(), installRoot);
if(!installRoot.empty() && installRoot.back().empty())
{
if (!installRoot.empty() && installRoot.back().empty()) {
installRoot.pop_back();
}
for(size_t i = 1; i < installRoot.size(); ++i)
{
for (size_t i = 1; i < installRoot.size(); ++i) {
BeginElement("Directory");
if(i == installRoot.size() - 1)
{
if (i == installRoot.size() - 1) {
AddAttribute("Id", "INSTALL_ROOT");
}
else
{
} else {
std::stringstream tmp;
tmp << "INSTALL_PREFIX_" << i;
AddAttribute("Id", tmp.str());
@ -88,8 +82,7 @@ size_t cmWIXDirectoriesSourceWriter::BeginInstallationPrefixDirectory(
void cmWIXDirectoriesSourceWriter::EndInstallationPrefixDirectory(size_t size)
{
for(size_t i = 0; i < size; ++i)
{
for (size_t i = 0; i < size; ++i) {
EndElement("Directory");
}
}

31
Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx
View File

@ -12,16 +12,14 @@
#include "cmWIXFeaturesSourceWriter.h"
cmWIXFeaturesSourceWriter::cmWIXFeaturesSourceWriter(cmCPackLog* logger,
std::string const& filename):
cmWIXSourceWriter(logger, filename)
cmWIXFeaturesSourceWriter::cmWIXFeaturesSourceWriter(
cmCPackLog* logger, std::string const& filename)
: cmWIXSourceWriter(logger, filename)
{
}
void cmWIXFeaturesSourceWriter::CreateCMakePackageRegistryEntry(
std::string const& package,
std::string const& upgradeGuid)
std::string const& package, std::string const& upgradeGuid)
{
BeginElement("Component");
AddAttribute("Id", "CM_PACKAGE_REGISTRY");
@ -49,23 +47,22 @@ void cmWIXFeaturesSourceWriter::EmitFeatureForComponentGroup(
BeginElement("Feature");
AddAttribute("Id", "CM_G_" + group.Name);
if(group.IsExpandedByDefault)
{
if (group.IsExpandedByDefault) {
AddAttribute("Display", "expand");
}
AddAttributeUnlessEmpty("Title", group.DisplayName);
AddAttributeUnlessEmpty("Description", group.Description);
for(std::vector<cmCPackComponentGroup*>::const_iterator
i = group.Subgroups.begin(); i != group.Subgroups.end(); ++i)
{
for (std::vector<cmCPackComponentGroup*>::const_iterator i =
group.Subgroups.begin();
i != group.Subgroups.end(); ++i) {
EmitFeatureForComponentGroup(**i);
}
for(std::vector<cmCPackComponent*>::const_iterator
i = group.Components.begin(); i != group.Components.end(); ++i)
{
for (std::vector<cmCPackComponent*>::const_iterator i =
group.Components.begin();
i != group.Components.end(); ++i) {
EmitFeatureForComponent(**i);
}
@ -81,13 +78,11 @@ void cmWIXFeaturesSourceWriter::EmitFeatureForComponent(
AddAttributeUnlessEmpty("Title", component.DisplayName);
AddAttributeUnlessEmpty("Description", component.Description);
if(component.IsRequired)
{
if (component.IsRequired) {
AddAttribute("Absent", "disallow");
}
if(component.IsHidden)
{
if (component.IsHidden) {
AddAttribute("Display", "hidden");
}

6
Source/CPack/WiX/cmWIXFeaturesSourceWriter.h
View File

@ -23,11 +23,9 @@
class cmWIXFeaturesSourceWriter : public cmWIXSourceWriter
{
public:
cmWIXFeaturesSourceWriter(cmCPackLog* logger,
std::string const& filename);
cmWIXFeaturesSourceWriter(cmCPackLog* logger, std::string const& filename);
void CreateCMakePackageRegistryEntry(
std::string const& package,
void CreateCMakePackageRegistryEntry(std::string const& package,
std::string const& upgradeGuid);
void EmitFeatureForComponentGroup(const cmCPackComponentGroup& group);

47
Source/CPack/WiX/cmWIXFilesSourceWriter.cxx
View File

@ -21,14 +21,12 @@
#include <sys/stat.h>
cmWIXFilesSourceWriter::cmWIXFilesSourceWriter(cmCPackLog* logger,
std::string const& filename):
cmWIXSourceWriter(logger, filename)
std::string const& filename)
: cmWIXSourceWriter(logger, filename)
{
}
void cmWIXFilesSourceWriter::EmitShortcut(
std::string const& id,
void cmWIXFilesSourceWriter::EmitShortcut(std::string const& id,
cmWIXShortcut const& shortcut,
std::string const& shortcutPrefix,
size_t shortcutIndex)
@ -36,8 +34,7 @@ void cmWIXFilesSourceWriter::EmitShortcut(
std::stringstream shortcutId;
shortcutId << shortcutPrefix << id;
if(shortcutIndex > 0)
{
if (shortcutIndex > 0) {
shortcutId << "_" << shortcutIndex;
}
@ -61,13 +58,11 @@ void cmWIXFilesSourceWriter::EmitRemoveFolder(std::string const& id)
}
void cmWIXFilesSourceWriter::EmitInstallRegistryValue(
std::string const& registryKey,
std::string const& cpackComponentName,
std::string const& registryKey, std::string const& cpackComponentName,
std::string const& suffix)
{
std::string valueName;
if(!cpackComponentName.empty())
{
if (!cpackComponentName.empty()) {
valueName = cpackComponentName + "_";
}
@ -97,12 +92,10 @@ void cmWIXFilesSourceWriter::EmitUninstallShortcut(
}
std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
std::string const& directoryId,
std::string const& guid,
std::string const& directoryId, std::string const& guid,
cmInstalledFile const* installedFile)
{
std::string componentId =
std::string("CM_C_EMPTY_") + directoryId;
std::string componentId = std::string("CM_C_EMPTY_") + directoryId;
BeginElement("DirectoryRef");
AddAttribute("Id", directoryId);
@ -113,8 +106,7 @@ std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
BeginElement("CreateFolder");
if(installedFile)
{
if (installedFile) {
cmWIXAccessControlList acl(Logger, *installedFile, *this);
acl.Apply();
}
@ -127,10 +119,8 @@ std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
}
std::string cmWIXFilesSourceWriter::EmitComponentFile(
std::string const& directoryId,
std::string const& id,
std::string const& filePath,
cmWIXPatch &patch,
std::string const& directoryId, std::string const& id,
std::string const& filePath, cmWIXPatch& patch,
cmInstalledFile const* installedFile)
{
std::string componentId = std::string("CM_C") + id;
@ -143,14 +133,11 @@ std::string cmWIXFilesSourceWriter::EmitComponentFile(
AddAttribute("Id", componentId);
AddAttribute("Guid", "*");
if(installedFile)
{
if(installedFile->GetPropertyAsBool("CPACK_NEVER_OVERWRITE"))
{
if (installedFile) {
if (installedFile->GetPropertyAsBool("CPACK_NEVER_OVERWRITE")) {
AddAttribute("NeverOverwrite", "yes");
}
if(installedFile->GetPropertyAsBool("CPACK_PERMANENT"))
{
if (installedFile->GetPropertyAsBool("CPACK_PERMANENT")) {
AddAttribute("Permanent", "yes");
}
}
@ -163,13 +150,11 @@ std::string cmWIXFilesSourceWriter::EmitComponentFile(
mode_t fileMode = 0;
cmSystemTools::GetPermissions(filePath.c_str(), fileMode);
if(!(fileMode & S_IWRITE))
{
if (!(fileMode & S_IWRITE)) {
AddAttribute("ReadOnly", "yes");
}
if(installedFile)
{
if (installedFile) {
cmWIXAccessControlList acl(Logger, *installedFile, *this);
acl.Apply();
}

23
Source/CPack/WiX/cmWIXFilesSourceWriter.h
View File

@ -26,36 +26,27 @@
class cmWIXFilesSourceWriter : public cmWIXSourceWriter
{
public:
cmWIXFilesSourceWriter(cmCPackLog* logger,
std::string const& filename);
cmWIXFilesSourceWriter(cmCPackLog* logger, std::string const& filename);
void EmitShortcut(
std::string const& id,
cmWIXShortcut const& shortcut,
std::string const& shortcutPrefix,
size_t shortcutIndex);
void EmitShortcut(std::string const& id, cmWIXShortcut const& shortcut,
std::string const& shortcutPrefix, size_t shortcutIndex);
void EmitRemoveFolder(std::string const& id);
void EmitInstallRegistryValue(
std::string const& registryKey,
void EmitInstallRegistryValue(std::string const& registryKey,
std::string const& cpackComponentName,
std::string const& suffix);
void EmitUninstallShortcut(std::string const& packageName);
std::string EmitComponentCreateFolder(
std::string const& directoryId,
std::string EmitComponentCreateFolder(std::string const& directoryId,
std::string const& guid,
cmInstalledFile const* installedFile);
std::string EmitComponentFile(
std::string const& directoryId,
std::string EmitComponentFile(std::string const& directoryId,
std::string const& id,
std::string const& filePath,
cmWIXPatch &patch,
std::string const& filePath, cmWIXPatch& patch,
cmInstalledFile const* installedFile);
};
#endif

60
Source/CPack/WiX/cmWIXPatch.cxx
View File

@ -14,31 +14,29 @@
#include <CPack/cmCPackGenerator.h>
cmWIXPatch::cmWIXPatch(cmCPackLog* logger):
Logger(logger)
cmWIXPatch::cmWIXPatch(cmCPackLog* logger)
: Logger(logger)
{
}
bool cmWIXPatch::LoadFragments(std::string const& patchFilePath)
{
cmWIXPatchParser parser(Fragments, Logger);
if(!parser.ParseFile(patchFilePath.c_str()))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Failed parsing XML patch file: '" <<
patchFilePath << "'" << std::endl);
if (!parser.ParseFile(patchFilePath.c_str())) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed parsing XML patch file: '"
<< patchFilePath << "'" << std::endl);
return false;
}
return true;
}
void cmWIXPatch::ApplyFragment(
std::string const& id, cmWIXSourceWriter& writer)
void cmWIXPatch::ApplyFragment(std::string const& id,
cmWIXSourceWriter& writer)
{
cmWIXPatchParser::fragment_map_t::iterator i = Fragments.find(id);
if(i == Fragments.end()) return;
if (i == Fragments.end())
return;
const cmWIXPatchElement& fragment = i->second;
@ -47,16 +45,15 @@ void cmWIXPatch::ApplyFragment(
Fragments.erase(i);
}
void cmWIXPatch::ApplyElementChildren(
const cmWIXPatchElement& element, cmWIXSourceWriter& writer)
void cmWIXPatch::ApplyElementChildren(const cmWIXPatchElement& element,
cmWIXSourceWriter& writer)
{
for(cmWIXPatchElement::child_list_t::const_iterator
j = element.children.begin(); j != element.children.end(); ++j)
{
cmWIXPatchNode *node = *j;
for (cmWIXPatchElement::child_list_t::const_iterator j =
element.children.begin();
j != element.children.end(); ++j) {
cmWIXPatchNode* node = *j;
switch(node->type())
{
switch (node->type()) {
case cmWIXPatchNode::ELEMENT:
ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer);
break;
@ -67,14 +64,14 @@ void cmWIXPatch::ApplyElementChildren(
}
}
void cmWIXPatch::ApplyElement(
const cmWIXPatchElement& element, cmWIXSourceWriter& writer)
void cmWIXPatch::ApplyElement(const cmWIXPatchElement& element,
cmWIXSourceWriter& writer)
{
writer.BeginElement(element.name);
for(cmWIXPatchElement::attributes_t::const_iterator
i = element.attributes.begin(); i != element.attributes.end(); ++i)
{
for (cmWIXPatchElement::attributes_t::const_iterator i =
element.attributes.begin();
i != element.attributes.end(); ++i) {
writer.AddAttribute(i->first, i->second);
}
@ -86,11 +83,9 @@ void cmWIXPatch::ApplyElement(
bool cmWIXPatch::CheckForUnappliedFragments()
{
std::string fragmentList;
for(cmWIXPatchParser::fragment_map_t::const_iterator
i = Fragments.begin(); i != Fragments.end(); ++i)
{
if(!fragmentList.empty())
{
for (cmWIXPatchParser::fragment_map_t::const_iterator i = Fragments.begin();
i != Fragments.end(); ++i) {
if (!fragmentList.empty()) {
fragmentList += ", ";
}
@ -99,11 +94,10 @@ bool cmWIXPatch::CheckForUnappliedFragments()
fragmentList += "'";
}
if(!fragmentList.empty())
{
if (!fragmentList.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Some XML patch fragments did not have matching IDs: " <<
fragmentList << std::endl);
"Some XML patch fragments did not have matching IDs: "
<< fragmentList << std::endl);
return false;
}

1
Source/CPack/WiX/cmWIXPatch.h
View File

@ -44,5 +44,4 @@ private:
cmWIXPatchParser::fragment_map_t Fragments;
};
#endif

97
Source/CPack/WiX/cmWIXPatchParser.cxx
View File

@ -28,65 +28,50 @@ cmWIXPatchNode::Type cmWIXPatchElement::type()
cmWIXPatchNode::~cmWIXPatchNode()
{
}
cmWIXPatchElement::~cmWIXPatchElement()
{
for(child_list_t::iterator i = children.begin(); i != children.end(); ++i)
{
for (child_list_t::iterator i = children.begin(); i != children.end(); ++i) {
delete *i;
}
}
cmWIXPatchParser::cmWIXPatchParser(
fragment_map_t& fragments, cmCPackLog* logger):
Logger(logger),
State(BEGIN_DOCUMENT),
Valid(true),
Fragments(fragments)
cmWIXPatchParser::cmWIXPatchParser(fragment_map_t& fragments,
cmCPackLog* logger)
: Logger(logger)
, State(BEGIN_DOCUMENT)
, Valid(true)
, Fragments(fragments)
{
}
void cmWIXPatchParser::StartElement(const std::string& name, const char **atts)
void cmWIXPatchParser::StartElement(const std::string& name, const char** atts)
{
if(State == BEGIN_DOCUMENT)
{
if(name == "CPackWiXPatch")
{
if (State == BEGIN_DOCUMENT) {
if (name == "CPackWiXPatch") {
State = BEGIN_FRAGMENTS;
}
else
{
} else {
ReportValidationError("Expected root element 'CPackWiXPatch'");
}
}
else if(State == BEGIN_FRAGMENTS)
{
if(name == "CPackWiXFragment")
{
} else if (State == BEGIN_FRAGMENTS) {
if (name == "CPackWiXFragment") {
State = INSIDE_FRAGMENT;
StartFragment(atts);
}
else
{
} else {
ReportValidationError("Expected 'CPackWixFragment' element");
}
}
else if(State == INSIDE_FRAGMENT)
{
cmWIXPatchElement &parent = *ElementStack.back();
} else if (State == INSIDE_FRAGMENT) {
cmWIXPatchElement& parent = *ElementStack.back();
cmWIXPatchElement *element = new cmWIXPatchElement;
cmWIXPatchElement* element = new cmWIXPatchElement;
parent.children.push_back(element);
element->name = name;
for(size_t i = 0; atts[i]; i += 2)
{
for (size_t i = 0; atts[i]; i += 2) {
std::string key = atts[i];
std::string value = atts[i+1];
std::string value = atts[i + 1];
element->attributes[key] = value;
}
@ -95,26 +80,21 @@ void cmWIXPatchParser::StartElement(const std::string& name, const char **atts)
}
}
void cmWIXPatchParser::StartFragment(const char **attributes)
void cmWIXPatchParser::StartFragment(const char** attributes)
{
for(size_t i = 0; attributes[i]; i += 2)
{
for (size_t i = 0; attributes[i]; i += 2) {
std::string key = attributes[i];
std::string value = attributes[i+1];
std::string value = attributes[i + 1];
if(key == "Id")
{
if(Fragments.find(value) != Fragments.end())
{
if (key == "Id") {
if (Fragments.find(value) != Fragments.end()) {
std::stringstream tmp;
tmp << "Invalid reuse of 'CPackWixFragment' 'Id': " << value;
ReportValidationError(tmp.str());
}
ElementStack.push_back(&Fragments[value]);
}
else
{
} else {
ReportValidationError(
"The only allowed 'CPackWixFragment' attribute is 'Id'");
}
@ -123,15 +103,11 @@ void cmWIXPatchParser::StartFragment(const char **attributes)
void cmWIXPatchParser::EndElement(const std::string& name)
{
if(State == INSIDE_FRAGMENT)
{
if(name == "CPackWiXFragment")
{
if (State == INSIDE_FRAGMENT) {
if (name == "CPackWiXFragment") {
State = BEGIN_FRAGMENTS;
ElementStack.clear();
}
else
{
} else {
ElementStack.pop_back();
}
}
@ -141,18 +117,16 @@ void cmWIXPatchParser::CharacterDataHandler(const char* data, int length)
{
const char* whitespace = "\x20\x09\x0d\x0a";
if(State == INSIDE_FRAGMENT)
{
cmWIXPatchElement &parent = *ElementStack.back();
if (State == INSIDE_FRAGMENT) {
cmWIXPatchElement& parent = *ElementStack.back();
std::string text(data, length);
std::string::size_type first = text.find_first_not_of(whitespace);
std::string::size_type last = text.find_last_not_of(whitespace);
if(first != std::string::npos && last != std::string::npos)
{
cmWIXPatchText *text_node = new cmWIXPatchText;
if (first != std::string::npos && last != std::string::npos) {
cmWIXPatchText* text_node = new cmWIXPatchText;
text_node->text = text.substr(first, last - first + 1);
parent.children.push_back(text_node);
@ -163,14 +137,15 @@ void cmWIXPatchParser::CharacterDataHandler(const char* data, int length)
void cmWIXPatchParser::ReportError(int line, int column, const char* msg)
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error while processing XML patch file at " << line << ":" << column <<
": "<< msg << std::endl);
"Error while processing XML patch file at "
<< line << ":" << column << ": " << msg << std::endl);
Valid = false;
}
void cmWIXPatchParser::ReportValidationError(std::string const& message)
{
ReportError(XML_GetCurrentLineNumber(static_cast<XML_Parser>(this->Parser)),
ReportError(
XML_GetCurrentLineNumber(static_cast<XML_Parser>(this->Parser)),
XML_GetCurrentColumnNumber(static_cast<XML_Parser>(this->Parser)),
message.c_str());
}

4
Source/CPack/WiX/cmWIXPatchParser.h
View File

@ -65,9 +65,9 @@ public:
cmWIXPatchParser(fragment_map_t& Fragments, cmCPackLog* logger);
private:
virtual void StartElement(const std::string& name, const char **atts);
virtual void StartElement(const std::string& name, const char** atts);
void StartFragment(const char **attributes);
void StartFragment(const char** attributes);
virtual void EndElement(const std::string& name);

82
Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx
View File

@ -15,8 +15,8 @@
#include <cmVersion.h>
cmWIXRichTextFormatWriter::cmWIXRichTextFormatWriter(
std::string const& filename):
File(filename.c_str(), std::ios::binary)
std::string const& filename)
: File(filename.c_str(), std::ios::binary)
{
StartGroup();
WriteHeader();
@ -37,12 +37,10 @@ void cmWIXRichTextFormatWriter::AddText(std::string const& text)
{
typedef unsigned char rtf_byte_t;
for(size_t i = 0; i < text.size(); ++i)
{
for (size_t i = 0; i < text.size(); ++i) {
rtf_byte_t c = rtf_byte_t(text[i]);
switch(c)
{
switch (c) {
case '\\':
File << "\\\\";
break;
@ -57,52 +55,30 @@ void cmWIXRichTextFormatWriter::AddText(std::string const& text)
break;
case '\r':
continue;
default:
{
if(c <= 0x7F)
{
default: {
if (c <= 0x7F) {
File << c;
}
else
{
if(c <= 0xC0)
{
} else {
if (c <= 0xC0) {
EmitInvalidCodepoint(c);
}
else if(c < 0xE0 && i+1 < text.size())
{
EmitUnicodeCodepoint(
(text[i+1] & 0x3F) |
((c & 0x1F) << 6)
);
i+= 1;
}
else if(c < 0xF0 && i+2 < text.size())
{
EmitUnicodeCodepoint(
(text[i+2] & 0x3F) |
((text[i+1] & 0x3F) << 6) |
((c & 0xF) << 12)
);
} else if (c < 0xE0 && i + 1 < text.size()) {
EmitUnicodeCodepoint((text[i + 1] & 0x3F) | ((c & 0x1F) << 6));
i += 1;
} else if (c < 0xF0 && i + 2 < text.size()) {
EmitUnicodeCodepoint((text[i + 2] & 0x3F) |
((text[i + 1] & 0x3F) << 6) |
((c & 0xF) << 12));
i += 2;
}
else if(c < 0xF8 && i+3 < text.size())
{
} else if (c < 0xF8 && i + 3 < text.size()) {
EmitUnicodeCodepoint(
(text[i+3] & 0x3F) |
((text[i+2] & 0x3F) << 6) |
((text[i+1] & 0x3F) << 12) |
((c & 0x7) << 18)
);
(text[i + 3] & 0x3F) | ((text[i + 2] & 0x3F) << 6) |
((text[i + 1] & 0x3F) << 12) | ((c & 0x7) << 18));
i += 3;
}
else
{
} else {
EmitInvalidCodepoint(c);
}
}
}
break;
} break;
}
}
}
@ -190,16 +166,11 @@ void cmWIXRichTextFormatWriter::EndGroup()
void cmWIXRichTextFormatWriter::EmitUnicodeCodepoint(int c)
{
// Do not emit byte order mark (BOM)
if(c == 0xFEFF)
{
if (c == 0xFEFF) {
return;
}
else if(c <= 0xFFFF)
{
} else if (c <= 0xFFFF) {
EmitUnicodeSurrogate(c);
}
else
{
} else {
c -= 0x10000;
EmitUnicodeSurrogate(((c >> 10) & 0x3FF) + 0xD800);
EmitUnicodeSurrogate((c & 0x3FF) + 0xDC00);
@ -209,12 +180,9 @@ void cmWIXRichTextFormatWriter::EmitUnicodeCodepoint(int c)
void cmWIXRichTextFormatWriter::EmitUnicodeSurrogate(int c)
{
ControlWord("u");
if(c <= 32767)
{
if (c <= 32767) {
File << c;
}
else
{
} else {
File << (c - 65536);
}
File << "?";

60
Source/CPack/WiX/cmWIXShortcut.cxx
View File

@ -14,8 +14,8 @@
#include "cmWIXFilesSourceWriter.h"
void cmWIXShortcuts::insert(
Type type, std::string const& id, cmWIXShortcut const& shortcut)
void cmWIXShortcuts::insert(Type type, std::string const& id,
cmWIXShortcut const& shortcut)
{
this->Shortcuts[type][id].push_back(shortcut);
}
@ -26,15 +26,13 @@ bool cmWIXShortcuts::empty(Type type) const
}
bool cmWIXShortcuts::EmitShortcuts(
Type type,
std::string const& registryKey,
Type type, std::string const& registryKey,
std::string const& cpackComponentName,
cmWIXFilesSourceWriter& fileDefinitions) const
{
shortcut_type_map_t::const_iterator i = this->Shortcuts.find(type);
if(i == this->Shortcuts.end())
{
if (i == this->Shortcuts.end()) {
return false;
}
@ -43,8 +41,7 @@ bool cmWIXShortcuts::EmitShortcuts(
std::string shortcutPrefix;
std::string registrySuffix;
switch(type)
{
switch (type) {
case START_MENU:
shortcutPrefix = "CM_S";
break;
@ -60,63 +57,56 @@ bool cmWIXShortcuts::EmitShortcuts(
return false;
}
for(shortcut_id_map_t::const_iterator j = id_map.begin();
j != id_map.end(); ++j)
{
for (shortcut_id_map_t::const_iterator j = id_map.begin(); j != id_map.end();
++j) {
std::string const& id = j->first;
shortcut_list_t const& shortcutList = j->second;
for(size_t shortcutListIndex = 0;
shortcutListIndex < shortcutList.size(); ++shortcutListIndex)
{
for (size_t shortcutListIndex = 0; shortcutListIndex < shortcutList.size();
++shortcutListIndex) {
cmWIXShortcut const& shortcut = shortcutList[shortcutListIndex];
fileDefinitions.EmitShortcut(id, shortcut,
shortcutPrefix, shortcutListIndex);
fileDefinitions.EmitShortcut(id, shortcut, shortcutPrefix,
shortcutListIndex);
}
}
fileDefinitions.EmitInstallRegistryValue(
registryKey, cpackComponentName, registrySuffix);
fileDefinitions.EmitInstallRegistryValue(registryKey, cpackComponentName,
registrySuffix);
return true;
}
void cmWIXShortcuts::AddShortcutTypes(std::set<Type>& types)
{
for(shortcut_type_map_t::const_iterator i = this->Shortcuts.begin();
i != this->Shortcuts.end(); ++i)
{
for (shortcut_type_map_t::const_iterator i = this->Shortcuts.begin();
i != this->Shortcuts.end(); ++i) {
types.insert(i->first);
}
}
void cmWIXShortcuts::CreateFromProperties(
std::string const& id,
void cmWIXShortcuts::CreateFromProperties(std::string const& id,
std::string const& directoryId,
cmInstalledFile const& installedFile)
{
CreateFromProperty("CPACK_START_MENU_SHORTCUTS",
START_MENU, id, directoryId, installedFile);
CreateFromProperty("CPACK_START_MENU_SHORTCUTS", START_MENU, id, directoryId,
installedFile);
CreateFromProperty("CPACK_DESKTOP_SHORTCUTS",
DESKTOP, id, directoryId, installedFile);
CreateFromProperty("CPACK_DESKTOP_SHORTCUTS", DESKTOP, id, directoryId,
installedFile);
CreateFromProperty("CPACK_STARTUP_SHORTCUTS",
STARTUP, id, directoryId, installedFile);
CreateFromProperty("CPACK_STARTUP_SHORTCUTS", STARTUP, id, directoryId,
installedFile);
}
void cmWIXShortcuts::CreateFromProperty(
std::string const& propertyName,
Type type,
std::string const& id,
void cmWIXShortcuts::CreateFromProperty(std::string const& propertyName,
Type type, std::string const& id,
std::string const& directoryId,
cmInstalledFile const& installedFile)
{
std::vector<std::string> list;
installedFile.GetPropertyAsList(propertyName, list);
for(size_t i = 0; i < list.size(); ++i)
{
for (size_t i = 0; i < list.size(); ++i) {
cmWIXShortcut shortcut;
shortcut.label = list[i];
shortcut.workingDirectoryId = directoryId;

11
Source/CPack/WiX/cmWIXShortcut.h
View File

@ -45,23 +45,20 @@ public:
bool empty(Type type) const;
bool EmitShortcuts(
Type type,
std::string const& registryKey,
bool EmitShortcuts(Type type, std::string const& registryKey,
std::string const& cpackComponentName,
cmWIXFilesSourceWriter& fileDefinitions) const;
void AddShortcutTypes(std::set<Type>& types);
void CreateFromProperties(std::string const& id,
std::string const& directoryId, cmInstalledFile const& installedFile);
std::string const& directoryId,
cmInstalledFile const& installedFile);
private:
typedef std::map<Type, shortcut_id_map_t> shortcut_type_map_t;
void CreateFromProperty(
std::string const& propertyName,
Type type,
void CreateFromProperty(std::string const& propertyName, Type type,
std::string const& id,
std::string const& directoryId,
cmInstalledFile const& installedFile);

110
Source/CPack/WiX/cmWIXSourceWriter.cxx
View File

@ -18,20 +18,17 @@
cmWIXSourceWriter::cmWIXSourceWriter(cmCPackLog* logger,
std::string const& filename,
bool isIncludeFile):
Logger(logger),
File(filename.c_str()),
State(DEFAULT),
SourceFilename(filename)
bool isIncludeFile)
: Logger(logger)
, File(filename.c_str())
, State(DEFAULT)
, SourceFilename(filename)
{
WriteXMLDeclaration();
if(isIncludeFile)
{
if (isIncludeFile) {
BeginElement("Include");
}
else
{
} else {
BeginElement("Wix");
}
@ -40,11 +37,10 @@ cmWIXSourceWriter::cmWIXSourceWriter(cmCPackLog* logger,
cmWIXSourceWriter::~cmWIXSourceWriter()
{
if(Elements.size() > 1)
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
Elements.size() - 1 << " WiX elements were still open when closing '" <<
SourceFilename << "'" << std::endl);
if (Elements.size() > 1) {
cmCPackLogger(cmCPackLog::LOG_ERROR, Elements.size() - 1
<< " WiX elements were still open when closing '"
<< SourceFilename << "'" << std::endl);
return;
}
@ -53,8 +49,7 @@ cmWIXSourceWriter::~cmWIXSourceWriter()
void cmWIXSourceWriter::BeginElement(std::string const& name)
{
if(State == BEGIN)
{
if (State == BEGIN) {
File << ">";
}
@ -68,31 +63,25 @@ void cmWIXSourceWriter::BeginElement(std::string const& name)
void cmWIXSourceWriter::EndElement(std::string const& name)
{
if(Elements.empty())
{
if (Elements.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"can not end WiX element with no open elements in '" <<
SourceFilename << "'" << std::endl);
"can not end WiX element with no open elements in '"
<< SourceFilename << "'" << std::endl);
return;
}
if(Elements.back() != name)
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"WiX element <" << Elements.back() <<
"> can not be closed by </" << name << "> in '" <<
SourceFilename << "'" << std::endl);
if (Elements.back() != name) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "WiX element <"
<< Elements.back() << "> can not be closed by </" << name
<< "> in '" << SourceFilename << "'" << std::endl);
return;
}
if(State == DEFAULT)
{
if (State == DEFAULT) {
File << "\n";
Indent(Elements.size()-1);
Indent(Elements.size() - 1);
File << "</" << Elements.back() << ">";
}
else
{
} else {
File << "/>";
}
@ -102,16 +91,14 @@ void cmWIXSourceWriter::EndElement(std::string const& name)
void cmWIXSourceWriter::AddTextNode(std::string const& text)
{
if(State == BEGIN)
{
if (State == BEGIN) {
File << ">";
}
if(Elements.empty())
{
if (Elements.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"can not add text without open WiX element in '" <<
SourceFilename << "'" << std::endl);
"can not add text without open WiX element in '"
<< SourceFilename << "'" << std::endl);
return;
}
@ -119,11 +106,10 @@ void cmWIXSourceWriter::AddTextNode(std::string const& text)
State = DEFAULT;
}
void cmWIXSourceWriter::AddProcessingInstruction(
std::string const& target, std::string const& content)
void cmWIXSourceWriter::AddProcessingInstruction(std::string const& target,
std::string const& content)
{
if(State == BEGIN)
{
if (State == BEGIN) {
File << ">";
}
@ -134,19 +120,18 @@ void cmWIXSourceWriter::AddProcessingInstruction(
State = DEFAULT;
}
void cmWIXSourceWriter::AddAttribute(
std::string const& key, std::string const& value)
void cmWIXSourceWriter::AddAttribute(std::string const& key,
std::string const& value)
{
std::string utf8 = CMakeEncodingToUtf8(value);
File << " " << key << "=\"" << EscapeAttributeValue(utf8) << '"';
}
void cmWIXSourceWriter::AddAttributeUnlessEmpty(
std::string const& key, std::string const& value)
void cmWIXSourceWriter::AddAttributeUnlessEmpty(std::string const& key,
std::string const& value)
{
if(!value.empty())
{
if (!value.empty()) {
AddAttribute(key, value);
}
}
@ -156,30 +141,26 @@ std::string cmWIXSourceWriter::CMakeEncodingToUtf8(std::string const& value)
#ifdef CMAKE_ENCODING_UTF8
return value;
#else
if(value.empty())
{
if (value.empty()) {
return std::string();
}
int characterCount = MultiByteToWideChar(
CP_ACP, 0, value.c_str(), static_cast<int>(value.size()), 0, 0);
if(characterCount == 0)
{
if (characterCount == 0) {
return std::string();
}
std::vector<wchar_t> utf16(characterCount);
MultiByteToWideChar(
CP_ACP, 0, value.c_str(), static_cast<int>(value.size()),
MultiByteToWideChar(CP_ACP, 0, value.c_str(), static_cast<int>(value.size()),
&utf16[0], static_cast<int>(utf16.size()));
int utf8ByteCount = WideCharToMultiByte(
CP_UTF8, 0, &utf16[0], static_cast<int>(utf16.size()), 0, 0, 0, 0);
if(utf8ByteCount == 0)
{
if (utf8ByteCount == 0) {
return std::string();
}
@ -192,7 +173,6 @@ std::string cmWIXSourceWriter::CMakeEncodingToUtf8(std::string const& value)
#endif
}
void cmWIXSourceWriter::WriteXMLDeclaration()
{
File << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
@ -200,24 +180,20 @@ void cmWIXSourceWriter::WriteXMLDeclaration()
void cmWIXSourceWriter::Indent(size_t count)
{
for(size_t i = 0; i < count; ++i)
{
for (size_t i = 0; i < count; ++i) {
File << " ";
}
}
std::string cmWIXSourceWriter::EscapeAttributeValue(
std::string const& value)
std::string cmWIXSourceWriter::EscapeAttributeValue(std::string const& value)
{
std::string result;
result.reserve(value.size());
char c = 0;
for(size_t i = 0 ; i < value.size(); ++i)
{
for (size_t i = 0; i < value.size(); ++i) {
c = value[i];
switch(c)
{
switch (c) {
case '<':
result += "&lt;";
break;
@ -225,7 +201,7 @@ std::string cmWIXSourceWriter::EscapeAttributeValue(
result += "&gt;";
break;
case '&':
result +="&amp;";
result += "&amp;";
break;
case '"':
result += "&quot;";

15
Source/CPack/WiX/cmWIXSourceWriter.h
View File

@ -26,8 +26,8 @@
class cmWIXSourceWriter
{
public:
cmWIXSourceWriter(cmCPackLog* logger,
std::string const& filename, bool isIncludeFile = false);
cmWIXSourceWriter(cmCPackLog* logger, std::string const& filename,
bool isIncludeFile = false);
~cmWIXSourceWriter();
@ -37,14 +37,13 @@ public:
void AddTextNode(std::string const& text);
void AddProcessingInstruction(
std::string const& target, std::string const& content);
void AddProcessingInstruction(std::string const& target,
std::string const& content);
void AddAttribute(
std::string const& key, std::string const& value);
void AddAttribute(std::string const& key, std::string const& value);
void AddAttributeUnlessEmpty(
std::string const& key, std::string const& value);
void AddAttributeUnlessEmpty(std::string const& key,
std::string const& value);
static std::string CMakeEncodingToUtf8(std::string const& value);

3
Source/CPack/cmCPack7zGenerator.cxx
View File

@ -13,8 +13,7 @@
#include "cmCPack7zGenerator.h"
cmCPack7zGenerator::cmCPack7zGenerator()
:cmCPackArchiveGenerator(cmArchiveWrite::CompressNone,
"7zip")
: cmCPackArchiveGenerator(cmArchiveWrite::CompressNone, "7zip")
{
}

186
Source/CPack/cmCPackArchiveGenerator.cxx
View File

@ -40,45 +40,38 @@ int cmCPackArchiveGenerator::InitializeInternal()
this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
return this->Superclass::InitializeInternal();
}
int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
cmCPackComponent* component)
int cmCPackArchiveGenerator::addOneComponentToArchive(
cmArchiveWrite& archive, cmCPackComponent* component)
{
cmCPackLogger(cmCPackLog::LOG_VERBOSE, " - packaging component: "
<< component->Name
<< std::endl);
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
" - packaging component: " << component->Name << std::endl);
// Add the files of this component to the archive
std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
localToplevel += "/"+ component->Name;
localToplevel += "/" + component->Name;
std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
// Change to local toplevel
cmSystemTools::ChangeDirectory(localToplevel);
std::string filePrefix;
if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY"))
{
if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
filePrefix = this->GetOption("CPACK_PACKAGE_FILE_NAME");
filePrefix += "/";
}
const char* installPrefix =
this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
if(installPrefix && installPrefix[0] == '/' && installPrefix[1] != 0)
{
if (installPrefix && installPrefix[0] == '/' && installPrefix[1] != 0) {
// add to file prefix and remove the leading '/'
filePrefix += installPrefix+1;
filePrefix += installPrefix + 1;
filePrefix += "/";
}
std::vector<std::string>::const_iterator fileIt;
for (fileIt = component->Files.begin(); fileIt != component->Files.end();
++fileIt )
{
++fileIt) {
std::string rp = filePrefix + *fileIt;
cmCPackLogger(cmCPackLog::LOG_DEBUG,"Adding file: "
<< rp << std::endl);
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file: " << rp << std::endl);
archive.Add(rp, 0, 0, false);
if (!archive)
{
if (!archive) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: "
<< archive.GetError()
<< std::endl);
<< archive.GetError() << std::endl);
return 0;
}
}
@ -92,24 +85,19 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
* an declare and open the associated
* cmArchiveWrite 'archive' object.
*/
#define DECLARE_AND_OPEN_ARCHIVE(filename,archive) \
cmGeneratedFileStream gf; \
gf.Open(filename.c_str(), false, true); \
if (!GenerateHeader(&gf)) \
{ \
#define DECLARE_AND_OPEN_ARCHIVE(filename, archive) \
cmGeneratedFileStream gf; \
gf.Open(filename.c_str(), false, true); \
if (!GenerateHeader(&gf)) { \
cmCPackLogger(cmCPackLog::LOG_ERROR, \
"Problem to generate Header for archive < " \
<< filename \
<< ">." << std::endl); \
<< filename << ">." << std::endl); \
return 0; \
} \
cmArchiveWrite archive(gf,this->Compress, this->ArchiveFormat); \
if (!archive) \
{ \
cmArchiveWrite archive(gf, this->Compress, this->ArchiveFormat); \
if (!archive) { \
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < " \
<< filename \
<< ">. ERROR =" \
<< archive.GetError() \
<< filename << ">. ERROR =" << archive.GetError() \
<< std::endl); \
return 0; \
}
@ -119,34 +107,28 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
packageFileNames.clear();
// The default behavior is to have one package by component group
// unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
if (!ignoreGroup)
{
if (!ignoreGroup) {
std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
for (compGIt=this->ComponentGroups.begin();
compGIt!=this->ComponentGroups.end(); ++compGIt)
{
for (compGIt = this->ComponentGroups.begin();
compGIt != this->ComponentGroups.end(); ++compGIt) {
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
<< compGIt->first
<< std::endl);
<< compGIt->first << std::endl);
// Begin the archive for this group
std::string packageFileName= std::string(toplevel);
packageFileName += "/"+
std::string packageFileName = std::string(toplevel);
packageFileName += "/" +
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
compGIt->first,
true)
+ this->GetOutputExtension();
compGIt->first, true) +
this->GetOutputExtension();
// open a block in order to automatically close archive
// at the end of the block
{
DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
// now iterate over the component of this group
std::vector<cmCPackComponent*>::iterator compIt;
for (compIt=(compGIt->second).Components.begin();
compIt!=(compGIt->second).Components.end();
++compIt)
{
for (compIt = (compGIt->second).Components.begin();
compIt != (compGIt->second).Components.end(); ++compIt) {
// Add the files of this component to the archive
addOneComponentToArchive(archive,*compIt);
addOneComponentToArchive(archive, *compIt);
}
}
// add the generated package to package file names list
@ -154,32 +136,28 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
}
// Handle Orphan components (components not belonging to any groups)
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();
compIt!=this->Components.end(); ++compIt )
{
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
// Does the component belong to a group?
if (compIt->second.Group==NULL)
{
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Component <"
if (compIt->second.Group == NULL) {
cmCPackLogger(
cmCPackLog::LOG_VERBOSE, "Component <"
<< compIt->second.Name
<< "> does not belong to any group, package it separately."
<< std::endl);
std::string localToplevel(
this->GetOption("CPACK_TEMPORARY_DIRECTORY")
);
this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
std::string packageFileName = std::string(toplevel);
localToplevel += "/"+ compIt->first;
packageFileName += "/"+
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
compIt->first,
false)
+ this->GetOutputExtension();
localToplevel += "/" + compIt->first;
packageFileName += "/" + GetComponentPackageFileName(
this->GetOption("CPACK_PACKAGE_FILE_NAME"),
compIt->first, false) +
this->GetOutputExtension();
{
DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
// Add the files of this component to the archive
addOneComponentToArchive(archive,&(compIt->second));
addOneComponentToArchive(archive, &(compIt->second));
}
// add the generated package to package file names list
packageFileNames.push_back(packageFileName);
@ -188,25 +166,22 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
}
// CPACK_COMPONENTS_IGNORE_GROUPS is set
// We build 1 package per component
else
{
else {
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();
compIt!=this->Components.end(); ++compIt )
{
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
std::string packageFileName = std::string(toplevel);
localToplevel += "/"+ compIt->first;
packageFileName += "/"+
localToplevel += "/" + compIt->first;
packageFileName += "/" +
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
compIt->first,
false)
+ this->GetOutputExtension();
compIt->first, false) +
this->GetOutputExtension();
{
DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
// Add the files of this component to the archive
addOneComponentToArchive(archive,&(compIt->second));
addOneComponentToArchive(archive, &(compIt->second));
}
// add the generated package to package file names list
packageFileNames.push_back(packageFileName);
@ -220,22 +195,21 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
// reset the package file names
packageFileNames.clear();
packageFileNames.push_back(std::string(toplevel));
packageFileNames[0] += "/"
+std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
+ this->GetOutputExtension();
packageFileNames[0] += "/" +
std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
this->GetOutputExtension();
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Packaging all groups in one package..."
"(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE is set)"
<< std::endl);
DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
// The ALL COMPONENTS in ONE package case
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();compIt!=this->Components.end();
++compIt )
{
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
// Add the files of this component to the archive
addOneComponentToArchive(archive,&(compIt->second));
addOneComponentToArchive(archive, &(compIt->second));
}
// archive goes out of scope so it will finalized and closed.
@ -244,47 +218,39 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
int cmCPackArchiveGenerator::PackageFiles()
{
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
<< toplevel << std::endl);
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
if (WantsComponentInstallation()) {
// CASE 1 : COMPONENT ALL-IN-ONE package
// If ALL COMPONENTS in ONE package has been requested
// then the package file is unique and should be open here.
if (componentPackageMethod == ONE_PACKAGE)
{
if (componentPackageMethod == ONE_PACKAGE) {
return PackageComponentsAllInOne();
}
// CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
// There will be 1 package for each component group
// however one may require to ignore component group and
// in this case you'll get 1 package for each component.
else
{
else {
return PackageComponents(componentPackageMethod ==
ONE_PACKAGE_PER_COMPONENT);
}
}
// CASE 3 : NON COMPONENT package.
DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
std::vector<std::string>::const_iterator fileIt;
std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::ChangeDirectory(toplevel);
for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
{
for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
// Get the relative path to the file
std::string rp = cmSystemTools::RelativePath(toplevel.c_str(),
fileIt->c_str());
std::string rp =
cmSystemTools::RelativePath(toplevel.c_str(), fileIt->c_str());
archive.Add(rp, 0, 0, false);
if(!archive)
{
if (!archive) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< "
<< *fileIt
<< "> to archive <"
<< packageFileNames[0] << "> .ERROR ="
<< archive.GetError()
<< std::endl);
<< *fileIt << "> to archive <" << packageFileNames[0]
<< "> .ERROR =" << archive.GetError() << std::endl);
return 0;
}
}
@ -298,16 +264,14 @@ int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
return 1;
}
bool cmCPackArchiveGenerator::SupportsComponentInstallation() const {
bool cmCPackArchiveGenerator::SupportsComponentInstallation() const
{
// The Component installation support should only
// be activated if explicitly requested by the user
// (for backward compatibility reason)
if (IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL"))
{
if (IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL")) {
return true;
}
else
{
} else {
return false;
}
}

6
Source/CPack/cmCPackArchiveGenerator.h
View File

@ -17,7 +17,6 @@
#include "cmArchiveWrite.h"
/** \class cmCPackArchiveGenerator
* \brief A generator base for libarchive generation.
* The generator itself uses the libarchive wrapper
@ -25,7 +24,7 @@
*
*/
class cmCPackArchiveGenerator : public cmCPackGenerator
{
{
public:
cmTypeMacro(cmCPackArchiveGenerator, cmCPackGenerator);
@ -38,6 +37,7 @@ public:
virtual int GenerateHeader(std::ostream* os);
// component support
virtual bool SupportsComponentInstallation() const;
protected:
virtual int InitializeInternal();
/**
@ -70,6 +70,6 @@ protected:
virtual const char* GetOutputExtension() = 0;
cmArchiveWrite::Compress Compress;
std::string ArchiveFormat;
};
};
#endif

132
Source/CPack/cmCPackBundleGenerator.cxx
View File

@ -28,8 +28,7 @@ cmCPackBundleGenerator::~cmCPackBundleGenerator()
int cmCPackBundleGenerator::InitializeInternal()
{
const char* name = this->GetOption("CPACK_BUNDLE_NAME");
if(0 == name)
{
if (0 == name) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"CPACK_BUNDLE_NAME must be set to use the Bundle generator."
<< std::endl);
@ -37,15 +36,12 @@ int cmCPackBundleGenerator::InitializeInternal()
return 0;
}
if(this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP"))
{
const std::string codesign_path = cmSystemTools::FindProgram("codesign",
std::vector<std::string>(), false);
if (this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")) {
const std::string codesign_path = cmSystemTools::FindProgram(
"codesign", std::vector<std::string>(), false);
if(codesign_path.empty())
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot locate codesign command"
if (codesign_path.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate codesign command"
<< std::endl);
return 0;
}
@ -69,33 +65,30 @@ int cmCPackBundleGenerator::ConstructBundle()
// Get required arguments ...
const std::string cpack_bundle_name = this->GetOption("CPACK_BUNDLE_NAME")
? this->GetOption("CPACK_BUNDLE_NAME") : "";
if(cpack_bundle_name.empty())
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"CPACK_BUNDLE_NAME must be set."
? this->GetOption("CPACK_BUNDLE_NAME")
: "";
if (cpack_bundle_name.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_NAME must be set."
<< std::endl);
return 0;
}
const std::string cpack_bundle_plist = this->GetOption("CPACK_BUNDLE_PLIST")
? this->GetOption("CPACK_BUNDLE_PLIST") : "";
if(cpack_bundle_plist.empty())
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"CPACK_BUNDLE_PLIST must be set."
? this->GetOption("CPACK_BUNDLE_PLIST")
: "";
if (cpack_bundle_plist.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_PLIST must be set."
<< std::endl);
return 0;
}
const std::string cpack_bundle_icon = this->GetOption("CPACK_BUNDLE_ICON")
? this->GetOption("CPACK_BUNDLE_ICON") : "";
if(cpack_bundle_icon.empty())
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"CPACK_BUNDLE_ICON must be set."
? this->GetOption("CPACK_BUNDLE_ICON")
: "";
if (cpack_bundle_icon.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_ICON must be set."
<< std::endl);
return 0;
@ -104,7 +97,8 @@ int cmCPackBundleGenerator::ConstructBundle()
// Get optional arguments ...
const std::string cpack_bundle_startup_command =
this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
? this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND") : "";
? this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
: "";
// The staging directory contains everything that will end-up inside the
// final disk image ...
@ -112,25 +106,28 @@ int cmCPackBundleGenerator::ConstructBundle()
staging << toplevel;
std::ostringstream contents;
contents << staging.str() << "/" << cpack_bundle_name
<< ".app/" << "Contents";
contents << staging.str() << "/" << cpack_bundle_name << ".app/"
<< "Contents";
std::ostringstream application;
application << contents.str() << "/" << "MacOS";
application << contents.str() << "/"
<< "MacOS";
std::ostringstream resources;
resources << contents.str() << "/" << "Resources";
resources << contents.str() << "/"
<< "Resources";
// Install a required, user-provided bundle metadata file ...
std::ostringstream plist_source;
plist_source << cpack_bundle_plist;
std::ostringstream plist_target;
plist_target << contents.str() << "/" << "Info.plist";
plist_target << contents.str() << "/"
<< "Info.plist";
if(!this->CopyFile(plist_source, plist_target))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
if (!this->CopyFile(plist_source, plist_target)) {
cmCPackLogger(
cmCPackLog::LOG_ERROR,
"Error copying plist. Check the value of CPACK_BUNDLE_PLIST."
<< std::endl);
@ -144,9 +141,9 @@ int cmCPackBundleGenerator::ConstructBundle()
std::ostringstream icon_target;
icon_target << resources.str() << "/" << cpack_bundle_name << ".icns";
if(!this->CopyFile(icon_source, icon_target))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
if (!this->CopyFile(icon_source, icon_target)) {
cmCPackLogger(
cmCPackLog::LOG_ERROR,
"Error copying bundle icon. Check the value of CPACK_BUNDLE_ICON."
<< std::endl);
@ -155,16 +152,14 @@ int cmCPackBundleGenerator::ConstructBundle()
// Optionally a user-provided startup command (could be an
// executable or a script) ...
if(!cpack_bundle_startup_command.empty())
{
if (!cpack_bundle_startup_command.empty()) {
std::ostringstream command_source;
command_source << cpack_bundle_startup_command;
std::ostringstream command_target;
command_target << application.str() << "/" << cpack_bundle_name;
if(!this->CopyFile(command_source, command_target))
{
if (!this->CopyFile(command_source, command_target)) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error copying startup command. "
" Check the value of CPACK_BUNDLE_STARTUP_COMMAND."
@ -181,13 +176,11 @@ int cmCPackBundleGenerator::ConstructBundle()
int cmCPackBundleGenerator::PackageFiles()
{
if(!this->ConstructBundle())
{
if (!this->ConstructBundle()) {
return 0;
}
if(!this->SignBundle(toplevel))
{
if (!this->SignBundle(toplevel)) {
return 0;
}
@ -199,16 +192,15 @@ bool cmCPackBundleGenerator::SupportsComponentInstallation() const
return false;
}
int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
{
const std::string cpack_apple_cert_app =
this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
? this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP") : "";
? this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
: "";
// codesign the application.
if(!cpack_apple_cert_app.empty())
{
if (!cpack_apple_cert_app.empty()) {
std::string output;
std::string bundle_path;
bundle_path = src_dir + "/";
@ -223,15 +215,15 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
const std::string sign_files =
this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES") : "";
? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
: "";
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(sign_files, relFiles);
// sign the files supplied by the user, ie. frameworks.
for(std::vector<std::string>::iterator it = relFiles.begin();
it != relFiles.end(); ++it)
{
for (std::vector<std::string>::iterator it = relFiles.begin();
it != relFiles.end(); ++it) {
std::ostringstream temp_sign_file_cmd;
temp_sign_file_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
temp_sign_file_cmd << " " << sign_parameter << " -s \""
@ -242,11 +234,10 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
temp_sign_file_cmd << bundle_path;
temp_sign_file_cmd << it->c_str() << "\"";
if(!this->RunCommand(temp_sign_file_cmd, &output))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error signing file:"
<< bundle_path << it->c_str() << std::endl << output << std::endl);
if (!this->RunCommand(temp_sign_file_cmd, &output)) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error signing file:"
<< bundle_path << it->c_str() << std::endl
<< output << std::endl);
return 0;
}
@ -259,11 +250,11 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
<< cpack_apple_cert_app;
temp_sign_binary_cmd << "\" \"" << bundle_path << "\"";
if(!this->RunCommand(temp_sign_binary_cmd, &output))
{
if (!this->RunCommand(temp_sign_binary_cmd, &output)) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error signing the application binary."
<< std::endl << output << std::endl);
"Error signing the application binary." << std::endl
<< output
<< std::endl);
return 0;
}
@ -273,28 +264,27 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
temp_codesign_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
temp_codesign_cmd << " " << sign_parameter << " -s \""
<< cpack_apple_cert_app << "\"";
if(this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS"))
{
if (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")) {
temp_codesign_cmd << " --entitlements ";
temp_codesign_cmd << this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS");
}
temp_codesign_cmd << " \"" << bundle_path << "\"";
if(!this->RunCommand(temp_codesign_cmd, &output))
{
if (!this->RunCommand(temp_codesign_cmd, &output)) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error signing the application package."
<< std::endl << output << std::endl);
"Error signing the application package." << std::endl
<< output
<< std::endl);
return 0;
}
cmCPackLogger(cmCPackLog::LOG_OUTPUT,
"- Application has been codesigned"
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Application has been codesigned"
<< std::endl);
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
(this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")
? "with entitlement sandboxing" : "without entitlement sandboxing")
? "with entitlement sandboxing"
: "without entitlement sandboxing")
<< std::endl);
}

12
Source/CPack/cmCPackComponentGroup.cxx
View File

@ -20,14 +20,12 @@
unsigned long cmCPackComponent::GetInstalledSize(
const std::string& installDir) const
{
if (this->TotalSize != 0)
{
if (this->TotalSize != 0) {
return this->TotalSize;
}
std::vector<std::string>::const_iterator fileIt;
for (fileIt = this->Files.begin(); fileIt != this->Files.end(); ++fileIt)
{
for (fileIt = this->Files.begin(); fileIt != this->Files.end(); ++fileIt) {
std::string path = installDir;
path += '/';
path += *fileIt;
@ -37,9 +35,9 @@ unsigned long cmCPackComponent::GetInstalledSize(
return this->TotalSize;
}
unsigned long
cmCPackComponent::GetInstalledSizeInKbytes(const std::string& installDir) const
unsigned long cmCPackComponent::GetInstalledSizeInKbytes(
const std::string& installDir) const
{
unsigned long result = (GetInstalledSize(installDir) + 512) / 1024;
return result? result : 1;
return result ? result : 1;
}

29
Source/CPack/cmCPackComponentGroup.h
View File

@ -42,9 +42,15 @@ public:
class cmCPackComponent
{
public:
cmCPackComponent() : Group(0), IsRequired(true), IsHidden(false),
IsDisabledByDefault(false), IsDownloaded(false),
TotalSize(0) { }
cmCPackComponent()
: Group(0)
, IsRequired(true)
, IsHidden(false)
, IsDisabledByDefault(false)
, IsDownloaded(false)
, TotalSize(0)
{
}
/// The name of the component (used to reference the component).
std::string Name;
@ -53,7 +59,7 @@ public:
std::string DisplayName;
/// The component group that contains this component (if any).
cmCPackComponentGroup *Group;
cmCPackComponentGroup* Group;
/// Whether this component group must always be installed.
bool IsRequired : 1;
@ -73,17 +79,17 @@ public:
std::string Description;
/// The installation types that this component is a part of.
std::vector<cmCPackInstallationType *> InstallationTypes;
std::vector<cmCPackInstallationType*> InstallationTypes;
/// If IsDownloaded is true, the name of the archive file that
/// contains the files that are part of this component.
std::string ArchiveFile;
/// The components that this component depends on.
std::vector<cmCPackComponent *> Dependencies;
std::vector<cmCPackComponent*> Dependencies;
/// The components that depend on this component.
std::vector<cmCPackComponent *> ReverseDependencies;
std::vector<cmCPackComponent*> ReverseDependencies;
/// The list of installed files that are part of this component.
std::vector<std::string> Files;
@ -100,7 +106,7 @@ public:
/// kilobytes.
unsigned long GetInstalledSizeInKbytes(const std::string& installDir) const;
private:
private:
mutable unsigned long TotalSize;
};
@ -110,7 +116,10 @@ public:
class cmCPackComponentGroup
{
public:
cmCPackComponentGroup() : ParentGroup(0) { }
cmCPackComponentGroup()
: ParentGroup(0)
{
}
/// The name of the group (used to reference the group).
std::string Name;
@ -131,7 +140,7 @@ public:
std::vector<cmCPackComponent*> Components;
/// The parent group of this component group (if any).
cmCPackComponentGroup *ParentGroup;
cmCPackComponentGroup* ParentGroup;
/// The subgroups of this group.
std::vector<cmCPackComponentGroup*> Subgroups;

13
Source/CPack/cmCPackCygwinBinaryGenerator.cxx
View File

@ -45,8 +45,7 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
std::string manifest = "/usr/share/doc/";
manifest += packageName;
manifest += "/MANIFEST";
std::string manifestFile
= this->GetOption("CPACK_TEMPORARY_DIRECTORY");
std::string manifestFile = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
// Create a MANIFEST file that contains all of the files in
// the tar file
std::string tempdir = manifestFile;
@ -55,9 +54,8 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
// to create the file before the super class is called
{
cmGeneratedFileStream ofs(manifestFile.c_str());
for(std::vector<std::string>::const_iterator i = files.begin();
i != files.end(); ++i)
{
for (std::vector<std::string>::const_iterator i = files.begin();
i != files.end(); ++i) {
// remove the temp dir and replace with /usr
ofs << (*i).substr(tempdir.size()) << "\n";
}
@ -73,9 +71,8 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
const char* cmCPackCygwinBinaryGenerator::GetOutputExtension()
{
this->OutputExtension = "-";
const char* patchNumber =this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
if(!patchNumber)
{
const char* patchNumber = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
if (!patchNumber) {
patchNumber = "1";
cmCPackLogger(cmCPackLog::LOG_WARNING,
"CPACK_CYGWIN_PATCH_NUMBER not specified using 1"

1
Source/CPack/cmCPackCygwinBinaryGenerator.h
View File

@ -28,6 +28,7 @@ public:
*/
cmCPackCygwinBinaryGenerator();
virtual ~cmCPackCygwinBinaryGenerator();
protected:
virtual int InitializeInternal();
int PackageFiles();

44
Source/CPack/cmCPackCygwinSourceGenerator.cxx
View File

@ -25,8 +25,8 @@
// system tools because it is not implemented robustly enough to move
// files across directories.
#ifdef _WIN32
# include <sys/stat.h>
# include <windows.h>
#include <sys/stat.h>
#include <windows.h>
#endif
cmCPackCygwinSourceGenerator::cmCPackCygwinSourceGenerator()
@ -46,8 +46,8 @@ int cmCPackCygwinSourceGenerator::InitializeInternal()
int cmCPackCygwinSourceGenerator::PackageFiles()
{
// Create a tar file of the sources
std::string packageDirFileName
= this->GetOption("CPACK_TEMPORARY_DIRECTORY");
std::string packageDirFileName =
this->GetOption("CPACK_TEMPORARY_DIRECTORY");
packageDirFileName += ".tar.bz2";
packageFileNames[0] = packageDirFileName;
std::string output;
@ -55,8 +55,7 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
// to create tar.bz2 file with the list of source
// files
this->Compress = cmArchiveWrite::CompressBZip2;
if ( !this->cmCPackTarBZip2Generator::PackageFiles() )
{
if (!this->cmCPackTarBZip2Generator::PackageFiles()) {
return 0;
}
// Now create a tar file that contains the above .tar.bz2 file
@ -76,43 +75,37 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
// to the toplevel cpack temp dir
// copy the patch file into place
if(!this->GetOption("CPACK_CYGWIN_PATCH_FILE"))
{
if (!this->GetOption("CPACK_CYGWIN_PATCH_FILE")) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"No patch file specified for cygwin sources.");
return 0;
}
if(!cmSystemTools::CopyFileAlways(
if (!cmSystemTools::CopyFileAlways(
this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
this->GetOption("CPACK_TOPLEVEL_DIRECTORY")))
{
this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: ["
<< this->GetOption("CPACK_CYGWIN_PATCH_FILE") << "]\nto\n["
<< this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
return 0;
}
if(!this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"))
{
if (!this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT")) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"No build script specified for cygwin sources.");
return 0;
}
// copy the build script into place
if(!cmSystemTools::CopyFileAlways(
if (!cmSystemTools::CopyFileAlways(
this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
this->GetOption("CPACK_TOPLEVEL_DIRECTORY")))
{
this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: "
<< this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT") << "\nto\n"
<< this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
return 0;
}
std::string outerTarFile
= this->GetOption("CPACK_TEMPORARY_DIRECTORY");
std::string outerTarFile = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
outerTarFile += "-";
const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
if(!patch)
{
if (!patch) {
cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
<< " not specified, defaulting to 1\n");
patch = "1";
@ -126,8 +119,8 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"));
std::string patchFile = tmpDir;
patchFile += "/";
patchFile += cmSystemTools::GetFilenameName(
this->GetOption("CPACK_CYGWIN_PATCH_FILE"));
patchFile +=
cmSystemTools::GetFilenameName(this->GetOption("CPACK_CYGWIN_PATCH_FILE"));
std::string file = cmSystemTools::GetFilenameName(compressOutFile);
std::string sourceTar = cmSystemTools::GetFilenamePath(compressOutFile);
@ -146,8 +139,7 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
packageFileNames[0] = outerTarFile;
/* update the toplevel dir */
toplevel = tmpDir;
if ( !this->cmCPackTarBZip2Generator::PackageFiles() )
{
if (!this->cmCPackTarBZip2Generator::PackageFiles()) {
return 0;
}
return 1;
@ -164,8 +156,7 @@ const char* cmCPackCygwinSourceGenerator::GetOutputExtension()
{
this->OutputExtension = "-";
const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
if(!patch)
{
if (!patch) {
cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
<< " not specified, defaulting to 1\n");
patch = "1";
@ -174,4 +165,3 @@ const char* cmCPackCygwinSourceGenerator::GetOutputExtension()
this->OutputExtension += "-src.tar.bz2";
return this->OutputExtension.c_str();
}

1
Source/CPack/cmCPackCygwinSourceGenerator.h
View File

@ -28,6 +28,7 @@ public:
*/
cmCPackCygwinSourceGenerator();
virtual ~cmCPackCygwinSourceGenerator();
protected:
const char* GetPackagingInstallPrefix();
virtual int InitializeInternal();

471
Source/CPack/cmCPackDebGenerator.cxx
View File

@ -30,7 +30,8 @@
// a GNU ar.
// See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=161593 for more info
// 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()
{
@ -43,8 +44,7 @@ cmCPackDebGenerator::~cmCPackDebGenerator()
int cmCPackDebGenerator::InitializeInternal()
{
this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR")))
{
if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR"))) {
this->SetOption("CPACK_SET_DESTDIR", "I_ON");
}
return this->Superclass::InitializeInternal();
@ -52,39 +52,34 @@ int cmCPackDebGenerator::InitializeInternal()
int cmCPackDebGenerator::PackageOnePack(std::string initialTopLevel,
std::string packageName)
{
{
int retval = 1;
// Begin the archive for this pack
std::string localToplevel(initialTopLevel);
std::string packageFileName(
cmSystemTools::GetParentDirectory(toplevel)
);
std::string outputFileName(
cmsys::SystemTools::LowerCase(
std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")))
+"-"+packageName + this->GetOutputExtension()
);
std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
std::string outputFileName(cmsys::SystemTools::LowerCase(std::string(
this->GetOption("CPACK_PACKAGE_FILE_NAME"))) +
"-" + packageName + this->GetOutputExtension());
localToplevel += "/"+ packageName;
localToplevel += "/" + packageName;
/* replace the TEMP DIRECTORY with the component one */
this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
packageFileName += "/"+ outputFileName;
this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
packageFileName += "/" + outputFileName;
/* replace proposed CPACK_OUTPUT_FILE_NAME */
this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
/* replace the TEMPORARY package file name */
this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
packageFileName.c_str());
// Tell CPackDeb.cmake the name of the component GROUP.
this->SetOption("CPACK_DEB_PACKAGE_COMPONENT",packageName.c_str());
this->SetOption("CPACK_DEB_PACKAGE_COMPONENT", packageName.c_str());
// Tell CPackDeb.cmake the path where the component is.
std::string component_path = "/";
component_path += packageName;
this->SetOption("CPACK_DEB_PACKAGE_COMPONENT_PART_PATH",
component_path.c_str());
if (!this->ReadListFile("CPackDeb.cmake"))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error while execution CPackDeb.cmake" << std::endl);
if (!this->ReadListFile("CPackDeb.cmake")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
<< std::endl);
retval = 0;
return retval;
}
@ -94,17 +89,16 @@ int cmCPackDebGenerator::PackageOnePack(std::string initialTopLevel,
findExpr += "/*";
gl.RecurseOn();
gl.SetRecurseListDirs(true);
if ( !gl.FindFiles(findExpr) )
{
if (!gl.FindFiles(findExpr)) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find any files in the installed directory" << std::endl);
"Cannot find any files in the installed directory"
<< std::endl);
return 0;
}
packageFiles = gl.GetFiles();
int res = createDeb();
if (res != 1)
{
if (res != 1) {
retval = 0;
}
// add the generated package to package file names list
@ -125,45 +119,38 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
// The default behavior is to have one package by component group
// unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
if (!ignoreGroup)
{
if (!ignoreGroup) {
std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
for (compGIt=this->ComponentGroups.begin();
compGIt!=this->ComponentGroups.end(); ++compGIt)
{
for (compGIt = this->ComponentGroups.begin();
compGIt != this->ComponentGroups.end(); ++compGIt) {
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
<< compGIt->first
<< std::endl);
<< compGIt->first << std::endl);
// Begin the archive for this group
retval &= PackageOnePack(initialTopLevel,compGIt->first);
retval &= PackageOnePack(initialTopLevel, compGIt->first);
}
// Handle Orphan components (components not belonging to any groups)
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();
compIt!=this->Components.end(); ++compIt )
{
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
// Does the component belong to a group?
if (compIt->second.Group==NULL)
{
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Component <"
if (compIt->second.Group == NULL) {
cmCPackLogger(
cmCPackLog::LOG_VERBOSE, "Component <"
<< compIt->second.Name
<< "> does not belong to any group, package it separately."
<< std::endl);
// Begin the archive for this orphan component
retval &= PackageOnePack(initialTopLevel,compIt->first);
retval &= PackageOnePack(initialTopLevel, compIt->first);
}
}
}
// CPACK_COMPONENTS_IGNORE_GROUPS is set
// We build 1 package per component
else
{
else {
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();
compIt!=this->Components.end(); ++compIt )
{
retval &= PackageOnePack(initialTopLevel,compIt->first);
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
retval &= PackageOnePack(initialTopLevel, compIt->first);
}
}
return retval;
@ -186,38 +173,32 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
// The ALL GROUPS in ONE package case
std::string localToplevel(initialTopLevel);
std::string packageFileName(
cmSystemTools::GetParentDirectory(toplevel)
);
std::string outputFileName(
cmsys::SystemTools::LowerCase(
std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")))
+ this->GetOutputExtension()
);
std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
std::string outputFileName(cmsys::SystemTools::LowerCase(std::string(
this->GetOption("CPACK_PACKAGE_FILE_NAME"))) +
this->GetOutputExtension());
// all GROUP in one vs all COMPONENT in one
localToplevel += "/"+compInstDirName;
localToplevel += "/" + compInstDirName;
/* replace the TEMP DIRECTORY with the component one */
this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
packageFileName += "/"+ outputFileName;
this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
packageFileName += "/" + outputFileName;
/* replace proposed CPACK_OUTPUT_FILE_NAME */
this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
/* replace the TEMPORARY package file name */
this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
packageFileName.c_str());
if(!compInstDirName.empty())
{
if (!compInstDirName.empty()) {
// Tell CPackDeb.cmake the path where the component is.
std::string component_path = "/";
component_path += compInstDirName;
this->SetOption("CPACK_DEB_PACKAGE_COMPONENT_PART_PATH",
component_path.c_str());
}
if (!this->ReadListFile("CPackDeb.cmake"))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error while execution CPackDeb.cmake" << std::endl);
if (!this->ReadListFile("CPackDeb.cmake")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
<< std::endl);
retval = 0;
return retval;
}
@ -227,18 +208,16 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
findExpr += "/*";
gl.RecurseOn();
gl.SetRecurseListDirs(true);
if ( !gl.FindFiles(findExpr) )
{
if (!gl.FindFiles(findExpr)) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find any files in the installed directory" << std::endl);
"Cannot find any files in the installed directory"
<< std::endl);
return 0;
}
packageFiles = gl.GetFiles();
int res = createDeb();
if (res != 1)
{
if (res != 1) {
retval = 0;
}
// add the generated package to package file names list
@ -256,23 +235,20 @@ int cmCPackDebGenerator::PackageFiles()
// CASE 1 : COMPONENT ALL-IN-ONE package
// If ALL GROUPS or ALL COMPONENTS in ONE package has been requested
// then the package file is unique and should be open here.
if (componentPackageMethod == ONE_PACKAGE)
{
if (componentPackageMethod == ONE_PACKAGE) {
return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
}
// CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
// There will be 1 package for each component group
// however one may require to ignore component group and
// in this case you'll get 1 package for each component.
else
{
else {
return PackageComponents(componentPackageMethod ==
ONE_PACKAGE_PER_COMPONENT);
}
}
// CASE 3 : NON COMPONENT package.
else
{
else {
return PackageComponentsAllInOne("");
}
}
@ -294,7 +270,7 @@ int cmCPackDebGenerator::createDeb()
// debian policy enforce lower case for package name
// mandatory entries:
std::string debian_pkg_name = cmsys::SystemTools::LowerCase(
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME") );
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME"));
const char* debian_pkg_version =
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_VERSION");
const char* debian_pkg_section =
@ -305,8 +281,7 @@ int cmCPackDebGenerator::createDeb()
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ARCHITECTURE");
const char* maintainer =
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER");
const char* desc =
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
const char* desc = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
// optional entries
const char* debian_pkg_dep =
@ -332,7 +307,6 @@ int cmCPackDebGenerator::createDeb()
const char* debian_pkg_source =
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
{ // the scope is needed for cmGeneratedFileStream
cmGeneratedFileStream out(ctlfilename.c_str());
out << "Package: " << debian_pkg_name << "\n";
@ -340,48 +314,37 @@ int cmCPackDebGenerator::createDeb()
out << "Section: " << debian_pkg_section << "\n";
out << "Priority: " << debian_pkg_priority << "\n";
out << "Architecture: " << debian_pkg_arch << "\n";
if(debian_pkg_source && *debian_pkg_source)
{
if (debian_pkg_source && *debian_pkg_source) {
out << "Source: " << debian_pkg_source << "\n";
}
if(debian_pkg_dep && *debian_pkg_dep)
{
if (debian_pkg_dep && *debian_pkg_dep) {
out << "Depends: " << debian_pkg_dep << "\n";
}
if(debian_pkg_rec && *debian_pkg_rec)
{
if (debian_pkg_rec && *debian_pkg_rec) {
out << "Recommends: " << debian_pkg_rec << "\n";
}
if(debian_pkg_sug && *debian_pkg_sug)
{
if (debian_pkg_sug && *debian_pkg_sug) {
out << "Suggests: " << debian_pkg_sug << "\n";
}
if(debian_pkg_url && *debian_pkg_url)
{
if (debian_pkg_url && *debian_pkg_url) {
out << "Homepage: " << debian_pkg_url << "\n";
}
if (debian_pkg_predep && *debian_pkg_predep)
{
if (debian_pkg_predep && *debian_pkg_predep) {
out << "Pre-Depends: " << debian_pkg_predep << "\n";
}
if (debian_pkg_enhances && *debian_pkg_enhances)
{
if (debian_pkg_enhances && *debian_pkg_enhances) {
out << "Enhances: " << debian_pkg_enhances << "\n";
}
if (debian_pkg_breaks && *debian_pkg_breaks)
{
if (debian_pkg_breaks && *debian_pkg_breaks) {
out << "Breaks: " << debian_pkg_breaks << "\n";
}
if (debian_pkg_conflicts && *debian_pkg_conflicts)
{
if (debian_pkg_conflicts && *debian_pkg_conflicts) {
out << "Conflicts: " << debian_pkg_conflicts << "\n";
}
if (debian_pkg_provides && *debian_pkg_provides)
{
if (debian_pkg_provides && *debian_pkg_provides) {
out << "Provides: " << debian_pkg_provides << "\n";
}
if (debian_pkg_replaces && *debian_pkg_replaces)
{
if (debian_pkg_replaces && *debian_pkg_replaces) {
out << "Replaces: " << debian_pkg_replaces << "\n";
}
unsigned long totalSize = 0;
@ -390,8 +353,7 @@ int cmCPackDebGenerator::createDeb()
dirName += '/';
for (std::vector<std::string>::const_iterator fileIt =
packageFiles.begin();
fileIt != packageFiles.end(); ++ fileIt )
{
fileIt != packageFiles.end(); ++fileIt) {
totalSize += cmSystemTools::FileLength(*fileIt);
}
}
@ -403,12 +365,11 @@ int cmCPackDebGenerator::createDeb()
const std::string shlibsfilename = strGenWDIR + "/shlibs";
const char* debian_pkg_shlibs = this->GetOption(
"GEN_CPACK_DEBIAN_PACKAGE_SHLIBS");
const bool gen_shibs = this->IsOn("CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS")
&& debian_pkg_shlibs && *debian_pkg_shlibs;
if( gen_shibs )
{
const char* debian_pkg_shlibs =
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SHLIBS");
const bool gen_shibs = this->IsOn("CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS") &&
debian_pkg_shlibs && *debian_pkg_shlibs;
if (gen_shibs) {
cmGeneratedFileStream out(shlibsfilename.c_str());
out << debian_pkg_shlibs;
out << std::endl;
@ -416,21 +377,17 @@ int cmCPackDebGenerator::createDeb()
const std::string postinst = strGenWDIR + "/postinst";
const std::string postrm = strGenWDIR + "/postrm";
if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST"))
{
if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
cmGeneratedFileStream out(postinst.c_str());
out <<
"#!/bin/sh\n\n"
out << "#!/bin/sh\n\n"
"set -e\n\n"
"if [ \"$1\" = \"configure\" ]; then\n"
"\tldconfig\n"
"fi\n";
}
if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM"))
{
if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
cmGeneratedFileStream out(postrm.c_str());
out <<
"#!/bin/sh\n\n"
out << "#!/bin/sh\n\n"
"set -e\n\n"
"if [ \"$1\" = \"remove\" ]; then\n"
"\tldconfig\n"
@ -440,25 +397,24 @@ int cmCPackDebGenerator::createDeb()
cmArchiveWrite::Compress tar_compression_type = cmArchiveWrite::CompressGZip;
const char* debian_compression_type =
this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE");
if(!debian_compression_type)
{
if (!debian_compression_type) {
debian_compression_type = "gzip";
}
std::string compression_suffix;
if(!strcmp(debian_compression_type, "lzma")) {
if (!strcmp(debian_compression_type, "lzma")) {
compression_suffix = ".lzma";
tar_compression_type = cmArchiveWrite::CompressLZMA;
} else if(!strcmp(debian_compression_type, "xz")) {
} else if (!strcmp(debian_compression_type, "xz")) {
compression_suffix = ".xz";
tar_compression_type = cmArchiveWrite::CompressXZ;
} else if(!strcmp(debian_compression_type, "bzip2")) {
} else if (!strcmp(debian_compression_type, "bzip2")) {
compression_suffix = ".bz2";
tar_compression_type = cmArchiveWrite::CompressBZip2;
} else if(!strcmp(debian_compression_type, "gzip")) {
} else if (!strcmp(debian_compression_type, "gzip")) {
compression_suffix = ".gz";
tar_compression_type = cmArchiveWrite::CompressGZip;
} else if(!strcmp(debian_compression_type, "none")) {
} else if (!strcmp(debian_compression_type, "none")) {
compression_suffix = "";
tar_compression_type = cmArchiveWrite::CompressNone;
} else {
@ -467,19 +423,16 @@ int cmCPackDebGenerator::createDeb()
<< debian_compression_type << std::endl);
}
std::string filename_data_tar = strGenWDIR
+ "/data.tar" + compression_suffix;
std::string filename_data_tar =
strGenWDIR + "/data.tar" + compression_suffix;
// atomic file generation for data.tar
{
cmGeneratedFileStream fileStream_data_tar;
fileStream_data_tar.Open(filename_data_tar.c_str(), false, true);
if(!fileStream_data_tar)
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error opening the file \"" << filename_data_tar << "\" for writing"
<< std::endl);
if (!fileStream_data_tar) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error opening the file \""
<< filename_data_tar << "\" for writing" << std::endl);
return 0;
}
cmArchiveWrite data_tar(fileStream_data_tar, tar_compression_type, "paxr");
@ -495,8 +448,7 @@ int cmCPackDebGenerator::createDeb()
// give /usr and /opt
size_t topLevelLength = strGenWDIR.length();
cmCPackLogger(cmCPackLog::LOG_DEBUG, "WDIR: \""
<< strGenWDIR
<< "\", length = " << topLevelLength
<< strGenWDIR << "\", length = " << topLevelLength
<< std::endl);
std::set<std::string> orderedFiles;
@ -504,11 +456,9 @@ int cmCPackDebGenerator::createDeb()
for (std::vector<std::string>::const_iterator fileIt =
packageFiles.begin();
fileIt != packageFiles.end(); ++ fileIt )
{
fileIt != packageFiles.end(); ++fileIt) {
std::string currentPath = *fileIt;
while(currentPath != strGenWDIR)
{
while (currentPath != strGenWDIR) {
// the last one IS strGenWDIR, but we do not want this one:
// XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application
// should not add XXX/application
@ -517,26 +467,21 @@ int cmCPackDebGenerator::createDeb()
}
}
for (std::set<std::string>::const_iterator fileIt =
orderedFiles.begin();
fileIt != orderedFiles.end(); ++ fileIt )
{
for (std::set<std::string>::const_iterator fileIt = orderedFiles.begin();
fileIt != orderedFiles.end(); ++fileIt) {
cmCPackLogger(cmCPackLog::LOG_DEBUG, "FILEIT: \"" << *fileIt << "\""
<< std::endl);
std::string::size_type slashPos = fileIt->find('/', topLevelLength+1);
std::string relativeDir = fileIt->substr(topLevelLength,
slashPos - topLevelLength);
cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \"" << relativeDir
<< "\"" << std::endl);
std::string::size_type slashPos = fileIt->find('/', topLevelLength + 1);
std::string relativeDir =
fileIt->substr(topLevelLength, slashPos - topLevelLength);
cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \""
<< relativeDir << "\"" << std::endl);
// do not recurse because the loop will do it
if(!data_tar.Add(*fileIt, topLevelLength, ".", false))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Problem adding file to tar:" << std::endl
<< "#top level directory: "
<< strGenWDIR << std::endl
if (!data_tar.Add(*fileIt, topLevelLength, ".", false)) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem adding file to tar:"
<< std::endl
<< "#top level directory: " << strGenWDIR << std::endl
<< "#file: " << *fileIt << std::endl
<< "#error:" << data_tar.GetError() << std::endl);
return 0;
@ -544,7 +489,6 @@ int cmCPackDebGenerator::createDeb()
}
} // scope for file generation
std::string md5filename = strGenWDIR + "/md5sums";
{
// the scope is needed for cmGeneratedFileStream
@ -555,18 +499,15 @@ int cmCPackDebGenerator::createDeb()
topLevelWithTrailingSlash += '/';
for (std::vector<std::string>::const_iterator fileIt =
packageFiles.begin();
fileIt != packageFiles.end(); ++ fileIt )
{
fileIt != packageFiles.end(); ++fileIt) {
// hash only regular files
if( cmSystemTools::FileIsDirectory(*fileIt)
|| cmSystemTools::FileIsSymlink(*fileIt))
{
if (cmSystemTools::FileIsDirectory(*fileIt) ||
cmSystemTools::FileIsSymlink(*fileIt)) {
continue;
}
char md5sum[33];
if(!cmSystemTools::ComputeFileMD5(*fileIt, md5sum))
{
if (!cmSystemTools::ComputeFileMD5(*fileIt, md5sum)) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem computing the md5 of "
<< *fileIt << std::endl);
}
@ -578,31 +519,27 @@ int cmCPackDebGenerator::createDeb()
// debian md5sums entries are like this:
// 014f3604694729f3bf19263bac599765 usr/bin/ccmake
// thus strip the full path (with the trailing slash)
cmSystemTools::ReplaceString(output,
topLevelWithTrailingSlash.c_str(), "");
cmSystemTools::ReplaceString(output, topLevelWithTrailingSlash.c_str(),
"");
out << output;
}
// each line contains a eol.
// Do not end the md5sum file with yet another (invalid)
}
std::string filename_control_tar = strGenWDIR + "/control.tar.gz";
// atomic file generation for control.tar
{
cmGeneratedFileStream fileStream_control_tar;
fileStream_control_tar.Open(filename_control_tar.c_str(), false, true);
if(!fileStream_control_tar)
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error opening the file \"" << filename_control_tar
<< "\" for writing" << std::endl);
if (!fileStream_control_tar) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error opening the file \""
<< filename_control_tar << "\" for writing"
<< std::endl);
return 0;
}
cmArchiveWrite control_tar(fileStream_control_tar,
cmArchiveWrite::CompressGZip,
"paxr");
cmArchiveWrite::CompressGZip, "paxr");
// sets permissions and uid/gid for the files
control_tar.SetUIDAndGID(0u, 0u);
@ -623,27 +560,22 @@ int cmCPackDebGenerator::createDeb()
control_tar.SetPermissions(permission644);
// adds control and md5sums
if( !control_tar.Add(md5filename, strGenWDIR.length(), ".")
|| !control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), "."))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error adding file to tar:" << std::endl
<< "#top level directory: "
<< strGenWDIR << std::endl
if (!control_tar.Add(md5filename, strGenWDIR.length(), ".") ||
!control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), ".")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
<< std::endl
<< "#top level directory: " << strGenWDIR << std::endl
<< "#file: \"control\" or \"md5sums\"" << std::endl
<< "#error:" << control_tar.GetError() << std::endl);
return 0;
}
// adds generated shlibs file
if( gen_shibs )
{
if( !control_tar.Add(shlibsfilename, strGenWDIR.length(), ".") )
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error adding file to tar:" << std::endl
<< "#top level directory: "
<< strGenWDIR << std::endl
if (gen_shibs) {
if (!control_tar.Add(shlibsfilename, strGenWDIR.length(), ".")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
<< std::endl
<< "#top level directory: " << strGenWDIR << std::endl
<< "#file: \"shlibs\"" << std::endl
<< "#error:" << control_tar.GetError() << std::endl);
return 0;
@ -651,15 +583,12 @@ int cmCPackDebGenerator::createDeb()
}
// adds LDCONFIG related files
if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST"))
{
if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
control_tar.SetPermissions(permission755);
if(!control_tar.Add(postinst, strGenWDIR.length(), "."))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error adding file to tar:" << std::endl
<< "#top level directory: "
<< strGenWDIR << std::endl
if (!control_tar.Add(postinst, strGenWDIR.length(), ".")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
<< std::endl
<< "#top level directory: " << strGenWDIR << std::endl
<< "#file: \"postinst\"" << std::endl
<< "#error:" << control_tar.GetError() << std::endl);
return 0;
@ -667,15 +596,12 @@ int cmCPackDebGenerator::createDeb()
control_tar.SetPermissions(permission644);
}
if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM"))
{
if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
control_tar.SetPermissions(permission755);
if(!control_tar.Add(postrm, strGenWDIR.length(), "."))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error adding file to tar:" << std::endl
<< "#top level directory: "
<< strGenWDIR << std::endl
if (!control_tar.Add(postrm, strGenWDIR.length(), ".")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
<< std::endl
<< "#top level directory: " << strGenWDIR << std::endl
<< "#file: \"postinst\"" << std::endl
<< "#error:" << control_tar.GetError() << std::endl);
return 0;
@ -688,48 +614,42 @@ int cmCPackDebGenerator::createDeb()
// -either a permission strictly defined by the Debian policies
const char* controlExtra =
this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA");
if( controlExtra )
{
if (controlExtra) {
// permissions are now controlled by the original file permissions
const bool permissionStrictPolicy =
this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION");
static const char* strictFiles[] = {
"config", "postinst", "postrm", "preinst", "prerm"
};
static const char* strictFiles[] = { "config", "postinst", "postrm",
"preinst", "prerm" };
std::set<std::string> setStrictFiles(
strictFiles,
strictFiles + sizeof(strictFiles)/sizeof(strictFiles[0]));
strictFiles + sizeof(strictFiles) / sizeof(strictFiles[0]));
// default
control_tar.ClearPermissions();
std::vector<std::string> controlExtraList;
cmSystemTools::ExpandListArgument(controlExtra, controlExtraList);
for(std::vector<std::string>::iterator i = controlExtraList.begin();
i != controlExtraList.end(); ++i)
{
std::string filenamename =
cmsys::SystemTools::GetFilenameName(*i);
for (std::vector<std::string>::iterator i = controlExtraList.begin();
i != controlExtraList.end(); ++i) {
std::string filenamename = cmsys::SystemTools::GetFilenameName(*i);
std::string localcopy = strGenWDIR + "/" + filenamename;
if(permissionStrictPolicy)
{
control_tar.SetPermissions(setStrictFiles.count(filenamename) ?
permission755 : permission644);
if (permissionStrictPolicy) {
control_tar.SetPermissions(setStrictFiles.count(filenamename)
? permission755
: permission644);
}
// if we can copy the file, it means it does exist, let's add it:
if( cmsys::SystemTools::CopyFileIfDifferent(*i, localcopy) )
{
if (cmsys::SystemTools::CopyFileIfDifferent(*i, localcopy)) {
control_tar.Add(localcopy, strGenWDIR.length(), ".");
}
}
}
}
// ar -r your-package-name.deb debian-binary control.tar.* data.tar.*
// since debian packages require BSD ar (most Linux distros and even
// FreeBSD and NetBSD ship GNU ar) we use a copy of OpenBSD ar here.
@ -742,10 +662,9 @@ int cmCPackDebGenerator::createDeb()
outputFileName += "/";
outputFileName += this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
int res = ar_append(outputFileName.c_str(), arFiles);
if ( res!=0 )
{
std::string tmpFile = this->GetOption(
"GEN_CPACK_TEMPORARY_PACKAGE_FILE_NAME");
if (res != 0) {
std::string tmpFile =
this->GetOption("GEN_CPACK_TEMPORARY_PACKAGE_FILE_NAME");
tmpFile += "/Deb.log";
cmGeneratedFileStream ofs(tmpFile.c_str());
ofs << "# Problem creating archive using: " << res << std::endl;
@ -755,20 +674,17 @@ int cmCPackDebGenerator::createDeb()
}
bool cmCPackDebGenerator::SupportsComponentInstallation() const
{
if (IsOn("CPACK_DEB_COMPONENT_INSTALL"))
{
{
if (IsOn("CPACK_DEB_COMPONENT_INSTALL")) {
return true;
}
else
{
} else {
return false;
}
}
}
std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
const std::string& componentName)
{
{
if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
return componentName;
}
@ -778,18 +694,14 @@ std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
}
// We have to find the name of the COMPONENT GROUP
// the current COMPONENT belongs to.
std::string groupVar = "CPACK_COMPONENT_" +
cmSystemTools::UpperCase(componentName) + "_GROUP";
if (NULL != GetOption(groupVar))
{
std::string groupVar =
"CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
if (NULL != GetOption(groupVar)) {
return std::string(GetOption(groupVar));
}
else
{
} else {
return componentName;
}
}
}
// The following code is taken from OpenBSD ar:
// http://www.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ar/
@ -850,7 +762,8 @@ std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
#define HDR1 "%s%-13d%-12ld%-6u%-6u%-8o%-10lld%2s"
#define HDR2 "%-16.16s%-12ld%-6u%-6u%-8o%-10lld%2s"
struct ar_hdr {
struct ar_hdr
{
char ar_name[16]; /* name */
char ar_date[12]; /* modification time */
char ar_uid[6]; /* user id */
@ -861,20 +774,22 @@ struct ar_hdr {
};
/* Set up file copy. */
#define SETCF(from, fromname, to, toname, pad) { \
#define SETCF(from, fromname, to, toname, pad) \
{ \
cf.rFile = from; \
cf.rname = fromname; \
cf.wFile = to; \
cf.wname = toname; \
cf.flags = pad; \
}
}
/* File copy structure. */
typedef struct {
typedef struct
{
FILE* rFile; /* read file descriptor */
const char *rname; /* read name */
const char* rname; /* read name */
FILE* wFile; /* write file descriptor */
const char *wname; /* write name */
const char* wname; /* write name */
#define NOPAD 0x00 /* don't pad */
#define WPAD 0x02 /* pad on writes */
unsigned int flags; /* pad flags */
@ -882,10 +797,10 @@ typedef struct {
/* misc.c */
static const char * ar_rname(const char *path)
static const char* ar_rname(const char* path)
{
const char *ind = strrchr(path, '/');
return (ind ) ? ind + 1 : path;
const char* ind = strrchr(path, '/');
return (ind) ? ind + 1 : path;
}
/* archive.c */
@ -908,12 +823,12 @@ static size_t ar_already_written;
* because 16-bit word addressed copies were faster?) Anyhow, it should
* have been ripped out long ago.
*/
static int copy_ar(CF *cfp, off_t size)
static int copy_ar(CF* cfp, off_t size)
{
static char pad = '\n';
off_t sz = size;
size_t nr, nw;
char buf[8*1024];
char buf[8 * 1024];
if (sz == 0)
return 0;
@ -922,8 +837,9 @@ static int copy_ar(CF *cfp, off_t size)
FILE* to = cfp->wFile;
while (sz &&
(nr = fread(buf, 1, sz < static_cast<off_t>(sizeof(buf))
? static_cast<size_t>(sz) : sizeof(buf), from ))
> 0) {
? static_cast<size_t>(sz)
: sizeof(buf),
from)) > 0) {
sz -= nr;
for (size_t off = 0; off < nr; nr -= off, off += nw)
if ((nw = fwrite(buf + off, 1, nr, to)) < nr)
@ -932,18 +848,18 @@ static int copy_ar(CF *cfp, off_t size)
if (sz)
return -2;
if (cfp->flags & WPAD && (size + ar_already_written) & 1
&& fwrite(&pad, 1, 1, to) != 1)
if (cfp->flags & WPAD && (size + ar_already_written) & 1 &&
fwrite(&pad, 1, 1, to) != 1)
return -4;
return 0;
}
/* put_arobj -- Write an archive member to a file. */
static int put_arobj(CF *cfp, struct stat *sb)
static int put_arobj(CF* cfp, struct stat* sb)
{
int result = 0;
struct ar_hdr *hdr;
struct ar_hdr* hdr;
/* If passed an sb structure, reading a file from disk. Get stat(2)
* information, build a name and construct a header. (Files are named
@ -963,15 +879,13 @@ static int put_arobj(CF *cfp, struct stat *sb)
gid = USHRT_MAX;
}
if (lname > sizeof(hdr->ar_name) || strchr(name, ' '))
(void)sprintf(ar_hb, HDR1, AR_EFMT1, (int)lname,
(long int)sb->st_mtime, (unsigned)uid, (unsigned)gid,
(unsigned)sb->st_mode, (long long)sb->st_size + lname,
ARFMAG);
(void)sprintf(ar_hb, HDR1, AR_EFMT1, (int)lname, (long int)sb->st_mtime,
(unsigned)uid, (unsigned)gid, (unsigned)sb->st_mode,
(long long)sb->st_size + lname, ARFMAG);
else {
lname = 0;
(void)sprintf(ar_hb, HDR2, name,
(long int)sb->st_mtime, (unsigned)uid, (unsigned)gid,
(unsigned)sb->st_mode, (long long)sb->st_size,
(void)sprintf(ar_hb, HDR2, name, (long int)sb->st_mtime, (unsigned)uid,
(unsigned)gid, (unsigned)sb->st_mode, (long long)sb->st_size,
ARFMAG);
}
off_t size = sb->st_size;
@ -995,19 +909,20 @@ static int put_arobj(CF *cfp, struct stat *sb)
* Append files to the archive - modifies original archive or creates
* a new archive if named archive does not exist.
*/
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)
{
int eval = 0;
FILE* aFile = cmSystemTools::Fopen(archive, "wb+");
if (aFile!=NULL) {
if (aFile != NULL) {
fwrite(ARMAG, SARMAG, 1, aFile);
if (fseek(aFile, 0, SEEK_END) != -1) {
CF cf;
struct stat sb;
/* Read from disk, write to an archive; pad on write. */
SETCF(NULL, 0, aFile, archive, WPAD);
for(std::vector<std::string>::const_iterator fileIt = files.begin();
fileIt!=files.end(); ++fileIt) {
for (std::vector<std::string>::const_iterator fileIt = files.begin();
fileIt != files.end(); ++fileIt) {
const char* filename = fileIt->c_str();
FILE* file = cmSystemTools::Fopen(filename, "rb");
if (file == NULL) {
@ -1018,18 +933,16 @@ static int ar_append(const char* archive,const std::vector<std::string>& files)
cf.rname = filename;
int result = put_arobj(&cf, &sb);
(void)fclose(file);
if (result!=0) {
if (result != 0) {
eval = -2;
break;
}
}
}
else {
} else {
eval = -3;
}
fclose(aFile);
}
else {
} else {
eval = -4;
}
return eval;

3
Source/CPack/cmCPackDebGenerator.h
View File

@ -37,7 +37,7 @@ public:
std::vector<std::string> locations;
locations.push_back("/sw/bin"); // Fink
locations.push_back("/opt/local/bin"); // MacPorts
return cmSystemTools::FindProgram("dpkg",locations) != "" ? true : false;
return cmSystemTools::FindProgram("dpkg", locations) != "" ? true : false;
#else
// legacy behavior on other systems
return true;
@ -70,7 +70,6 @@ protected:
private:
int createDeb();
std::vector<std::string> packageFiles;
};
#endif

556
Source/CPack/cmCPackDragNDropGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

12
Source/CPack/cmCPackDragNDropGenerator.h
View File

@ -34,13 +34,12 @@ protected:
int PackageFiles();
bool SupportsComponentInstallation() const;
bool CopyFile(std::ostringstream& source, std::ostringstream& target);
bool CreateEmptyFile(std::ostringstream& target, size_t size);
bool RunCommand(std::ostringstream& command, std::string* output = 0);
std::string
GetComponentInstallDirNameSuffix(const std::string& componentName);
std::string GetComponentInstallDirNameSuffix(
const std::string& componentName);
int CreateDMG(const std::string& src_dir, const std::string& output_file);
@ -52,10 +51,9 @@ private:
bool WriteLicense(cmGeneratedFileStream& outputStream, int licenseNumber,
std::string licenseLanguage, std::string licenseFile,
std::string *error);
bool BreakLongLine(const std::string& line,
std::vector<std::string>& lines,
std::string *error);
std::string* error);
bool BreakLongLine(const std::string& line, std::vector<std::string>& lines,
std::string* error);
void EscapeQuotesAndBackslashes(std::string& line);
};

1025
Source/CPack/cmCPackGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

34
Source/CPack/cmCPackGenerator.h
View File

@ -20,8 +20,8 @@
#include <vector>
#include "cmCPackComponentGroup.h" // cmCPackComponent and friends
// Forward declarations are insufficient since we use them in
// std::map data members below...
// Forward declarations are insufficient since we use them in
// std::map data members below...
#define cmCPackTypeMacro(klass, superclass) \
cmTypeMacro(klass, superclass); \
@ -32,17 +32,17 @@
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
this->Logger->Log(logType, __FILE__, __LINE__,\
cmCPackLog_msg.str().c_str());\
} while ( 0 )
this->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} while (0)
#ifdef cerr
# undef cerr
#undef cerr
#endif
#define cerr no_cerr_use_cmCPack_Log
#ifdef cout
# undef cout
#undef cout
#endif
#define cout no_cout_use_cmCPack_Log
@ -62,8 +62,10 @@ public:
* If verbose then more information is printed out
*/
void SetVerbose(bool val)
{ this->GeneratorVerbose = val ?
cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE; }
{
this->GeneratorVerbose =
val ? cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE;
}
/**
* Returns true if the generator may work on this system.
@ -170,8 +172,7 @@ protected:
*/
virtual std::string GetComponentPackageFileName(
const std::string& initialPackageFileName,
const std::string& groupOrComponentName,
bool isGroupName);
const std::string& groupOrComponentName, bool isGroupName);
/**
* Package the list of files and/or components which
@ -192,7 +193,6 @@ protected:
virtual bool ConfigureString(const std::string& input, std::string& output);
virtual int InitializeInternal();
//! Run install commands if specified
virtual int InstallProjectViaInstallCommands(
bool setDestDir, const std::string& tempInstallDirectory);
@ -207,7 +207,8 @@ protected:
* The various level of support of
* CPACK_SET_DESTDIR used by the generator.
*/
enum CPackSetDestdirSupport {
enum CPackSetDestdirSupport
{
/* the generator works with or without it */
SETDESTDIR_SUPPORTED,
/* the generator works best if automatically handled */
@ -251,13 +252,11 @@ protected:
*/
virtual bool WantsComponentInstallation() const;
virtual cmCPackInstallationType* GetInstallationType(
const std::string& projectName,
const std::string& name);
const std::string& projectName, const std::string& name);
virtual cmCPackComponent* GetComponent(const std::string& projectName,
const std::string& name);
virtual cmCPackComponentGroup* GetComponentGroup(
const std::string& projectName,
const std::string& name);
const std::string& projectName, const std::string& name);
cmSystemTools::OutputOption GeneratorVerbose;
std::string Name;
@ -324,6 +323,7 @@ protected:
ComponentPackageMethod componentPackageMethod;
cmCPackLog* Logger;
private:
cmMakefile* MakefileMap;
};

98
Source/CPack/cmCPackGeneratorFactory.cxx
View File

@ -24,131 +24,112 @@
#include "cmCPackZIPGenerator.h"
#ifdef __APPLE__
# include "cmCPackBundleGenerator.h"
# include "cmCPackDragNDropGenerator.h"
# include "cmCPackOSXX11Generator.h"
# include "cmCPackPackageMakerGenerator.h"
#include "cmCPackBundleGenerator.h"
#include "cmCPackDragNDropGenerator.h"
#include "cmCPackOSXX11Generator.h"
#include "cmCPackPackageMakerGenerator.h"
#endif
#ifdef __CYGWIN__
# include "cmCPackCygwinBinaryGenerator.h"
# include "cmCPackCygwinSourceGenerator.h"
#include "cmCPackCygwinBinaryGenerator.h"
#include "cmCPackCygwinSourceGenerator.h"
#endif
#if !defined(_WIN32) \
&& !defined(__QNXNTO__) && !defined(__BEOS__) && !defined(__HAIKU__)
# include "cmCPackDebGenerator.h"
# include "cmCPackRPMGenerator.h"
#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) && \
!defined(__HAIKU__)
#include "cmCPackDebGenerator.h"
#include "cmCPackRPMGenerator.h"
#endif
#ifdef _WIN32
# include "WiX/cmCPackWIXGenerator.h"
#include "WiX/cmCPackWIXGenerator.h"
#endif
#include "cmAlgorithms.h"
#include "cmCPackLog.h"
cmCPackGeneratorFactory::cmCPackGeneratorFactory()
{
if (cmCPackTGZGenerator::CanGenerate())
{
if (cmCPackTGZGenerator::CanGenerate()) {
this->RegisterGenerator("TGZ", "Tar GZip compression",
cmCPackTGZGenerator::CreateGenerator);
}
if (cmCPackTXZGenerator::CanGenerate())
{
if (cmCPackTXZGenerator::CanGenerate()) {
this->RegisterGenerator("TXZ", "Tar XZ compression",
cmCPackTXZGenerator::CreateGenerator);
}
if (cmCPackSTGZGenerator::CanGenerate())
{
if (cmCPackSTGZGenerator::CanGenerate()) {
this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
cmCPackSTGZGenerator::CreateGenerator);
}
if (cmCPackNSISGenerator::CanGenerate())
{
if (cmCPackNSISGenerator::CanGenerate()) {
this->RegisterGenerator("NSIS", "Null Soft Installer",
cmCPackNSISGenerator::CreateGenerator);
this->RegisterGenerator("NSIS64", "Null Soft Installer (64-bit)",
cmCPackNSISGenerator::CreateGenerator64);
}
if (cmCPackIFWGenerator::CanGenerate())
{
if (cmCPackIFWGenerator::CanGenerate()) {
this->RegisterGenerator("IFW", "Qt Installer Framework",
cmCPackIFWGenerator::CreateGenerator);
}
#ifdef __CYGWIN__
if (cmCPackCygwinBinaryGenerator::CanGenerate())
{
if (cmCPackCygwinBinaryGenerator::CanGenerate()) {
this->RegisterGenerator("CygwinBinary", "Cygwin Binary Installer",
cmCPackCygwinBinaryGenerator::CreateGenerator);
}
if (cmCPackCygwinSourceGenerator::CanGenerate())
{
if (cmCPackCygwinSourceGenerator::CanGenerate()) {
this->RegisterGenerator("CygwinSource", "Cygwin Source Installer",
cmCPackCygwinSourceGenerator::CreateGenerator);
}
#endif
if (cmCPackZIPGenerator::CanGenerate())
{
if (cmCPackZIPGenerator::CanGenerate()) {
this->RegisterGenerator("ZIP", "ZIP file format",
cmCPackZIPGenerator::CreateGenerator);
}
if (cmCPack7zGenerator::CanGenerate())
{
if (cmCPack7zGenerator::CanGenerate()) {
this->RegisterGenerator("7Z", "7-Zip file format",
cmCPack7zGenerator::CreateGenerator);
}
#ifdef _WIN32
if (cmCPackWIXGenerator::CanGenerate())
{
if (cmCPackWIXGenerator::CanGenerate()) {
this->RegisterGenerator("WIX", "MSI file format via WiX tools",
cmCPackWIXGenerator::CreateGenerator);
}
#endif
if (cmCPackTarBZip2Generator::CanGenerate())
{
if (cmCPackTarBZip2Generator::CanGenerate()) {
this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
cmCPackTarBZip2Generator::CreateGenerator);
}
if (cmCPackTarCompressGenerator::CanGenerate())
{
if (cmCPackTarCompressGenerator::CanGenerate()) {
this->RegisterGenerator("TZ", "Tar Compress compression",
cmCPackTarCompressGenerator::CreateGenerator);
}
#ifdef __APPLE__
if (cmCPackDragNDropGenerator::CanGenerate())
{
if (cmCPackDragNDropGenerator::CanGenerate()) {
this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
cmCPackDragNDropGenerator::CreateGenerator);
}
if (cmCPackBundleGenerator::CanGenerate())
{
if (cmCPackBundleGenerator::CanGenerate()) {
this->RegisterGenerator("Bundle", "Mac OSX bundle",
cmCPackBundleGenerator::CreateGenerator);
}
if (cmCPackPackageMakerGenerator::CanGenerate())
{
if (cmCPackPackageMakerGenerator::CanGenerate()) {
this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
cmCPackPackageMakerGenerator::CreateGenerator);
}
if (cmCPackOSXX11Generator::CanGenerate())
{
if (cmCPackOSXX11Generator::CanGenerate()) {
this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
cmCPackOSXX11Generator::CreateGenerator);
}
#endif
#if !defined(_WIN32) \
&& !defined(__QNXNTO__) && !defined(__BEOS__) && !defined(__HAIKU__)
if (cmCPackDebGenerator::CanGenerate())
{
#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) && \
!defined(__HAIKU__)
if (cmCPackDebGenerator::CanGenerate()) {
this->RegisterGenerator("DEB", "Debian packages",
cmCPackDebGenerator::CreateGenerator);
}
if (cmCPackRPMGenerator::CanGenerate())
{
if (cmCPackRPMGenerator::CanGenerate()) {
this->RegisterGenerator("RPM", "RPM packages",
cmCPackRPMGenerator::CreateGenerator);
}
@ -164,8 +145,7 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
const std::string& name)
{
cmCPackGenerator* gen = this->NewGeneratorInternal(name);
if ( !gen )
{
if (!gen) {
return 0;
}
this->Generators.push_back(gen);
@ -176,21 +156,19 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal(
const std::string& name)
{
cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it
= this->GeneratorCreators.find(name);
if ( it == this->GeneratorCreators.end() )
{
cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it =
this->GeneratorCreators.find(name);
if (it == this->GeneratorCreators.end()) {
return 0;
}
return (it->second)();
}
void cmCPackGeneratorFactory::RegisterGenerator(const std::string& name,
const char* generatorDescription,
void cmCPackGeneratorFactory::RegisterGenerator(
const std::string& name, const char* generatorDescription,
CreateGeneratorCall* createGenerator)
{
if ( !createGenerator )
{
if (!createGenerator) {
cmCPack_Log(this->Logger, cmCPackLog::LOG_ERROR,
"Cannot register generator" << std::endl);
return;

4
Source/CPack/cmCPackGeneratorFactory.h
View File

@ -44,7 +44,9 @@ public:
typedef std::map<std::string, std::string> DescriptionsMap;
const DescriptionsMap& GetGeneratorsList() const
{ return this->GeneratorDescriptions; }
{
return this->GeneratorDescriptions;
}
private:
cmCPackGenerator* NewGeneratorInternal(const std::string& name);

136
Source/CPack/cmCPackLog.cxx
View File

@ -39,8 +39,7 @@ cmCPackLog::~cmCPackLog()
void cmCPackLog::SetLogOutputStream(std::ostream* os)
{
if ( this->LogOutputCleanup && this->LogOutput )
{
if (this->LogOutputCleanup && this->LogOutput) {
delete this->LogOutput;
}
this->LogOutputCleanup = false;
@ -49,27 +48,24 @@ void cmCPackLog::SetLogOutputStream(std::ostream* os)
bool cmCPackLog::SetLogOutputFile(const char* fname)
{
cmGeneratedFileStream *cg = 0;
if ( fname )
{
cmGeneratedFileStream* cg = 0;
if (fname) {
cg = new cmGeneratedFileStream(fname);
}
if ( cg && !*cg )
{
if (cg && !*cg) {
delete cg;
cg = 0;
}
this->SetLogOutputStream(cg);
if ( !cg )
{
if (!cg) {
return false;
}
this->LogOutputCleanup = true;
return true;
}
void cmCPackLog::Log(int tag, const char* file, int line,
const char* msg, size_t length)
void cmCPackLog::Log(int tag, const char* file, int line, const char* msg,
size_t length)
{
// By default no logging
bool display = false;
@ -86,135 +82,109 @@ void cmCPackLog::Log(int tag, const char* file, int line,
// When writing in file, add list of tags whenever tag changes.
std::string tagString;
bool needTagString = false;
if ( this->LogOutput && this->LastTag != tag )
{
if (this->LogOutput && this->LastTag != tag) {
needTagString = true;
}
if ( tag & LOG_OUTPUT )
{
if (tag & LOG_OUTPUT) {
output = true;
display = true;
if ( needTagString )
{
if (!tagString.empty()) { tagString += ","; }
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "VERBOSE";
}
}
if ( tag & LOG_WARNING )
{
if (tag & LOG_WARNING) {
warning = true;
display = true;
if ( needTagString )
{
if (!tagString.empty()) { tagString += ","; }
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "WARNING";
}
}
if ( tag & LOG_ERROR )
{
if (tag & LOG_ERROR) {
error = true;
display = true;
if ( needTagString )
{
if (!tagString.empty()) { tagString += ","; }
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "ERROR";
}
}
if ( tag & LOG_DEBUG && this->Debug )
{
if (tag & LOG_DEBUG && this->Debug) {
debug = true;
display = true;
if ( needTagString )
{
if (!tagString.empty()) { tagString += ","; }
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "DEBUG";
}
useFileAndLine = true;
}
if ( tag & LOG_VERBOSE && this->Verbose )
{
if (tag & LOG_VERBOSE && this->Verbose) {
verbose = true;
display = true;
if ( needTagString )
{
if (!tagString.empty()) { tagString += ","; }
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
tagString = "VERBOSE";
}
}
if ( this->Quiet )
{
if (this->Quiet) {
display = false;
}
if ( this->LogOutput )
{
if ( needTagString )
{
*this->LogOutput << "[" << file << ":" << line << " "
<< tagString << "] ";
if (this->LogOutput) {
if (needTagString) {
*this->LogOutput << "[" << file << ":" << line << " " << tagString
<< "] ";
}
this->LogOutput->write(msg, length);
}
this->LastTag = tag;
if ( !display )
{
if (!display) {
return;
}
if ( this->NewLine )
{
if ( error && !this->ErrorPrefix.empty() )
{
if (this->NewLine) {
if (error && !this->ErrorPrefix.empty()) {
*this->DefaultError << this->ErrorPrefix;
}
else if ( warning && !this->WarningPrefix.empty() )
{
} else if (warning && !this->WarningPrefix.empty()) {
*this->DefaultError << this->WarningPrefix;
}
else if ( output && !this->OutputPrefix.empty() )
{
} else if (output && !this->OutputPrefix.empty()) {
*this->DefaultOutput << this->OutputPrefix;
}
else if ( verbose && !this->VerbosePrefix.empty() )
{
} else if (verbose && !this->VerbosePrefix.empty()) {
*this->DefaultOutput << this->VerbosePrefix;
}
else if ( debug && !this->DebugPrefix.empty() )
{
} else if (debug && !this->DebugPrefix.empty()) {
*this->DefaultOutput << this->DebugPrefix;
}
else if ( !this->Prefix.empty() )
{
} else if (!this->Prefix.empty()) {
*this->DefaultOutput << this->Prefix;
}
if ( useFileAndLine )
{
if ( error || warning )
{
if (useFileAndLine) {
if (error || warning) {
*this->DefaultError << file << ":" << line << " ";
}
else
{
} else {
*this->DefaultOutput << file << ":" << line << " ";
}
}
}
if ( error || warning )
{
if (error || warning) {
this->DefaultError->write(msg, length);
this->DefaultError->flush();
}
else
{
} else {
this->DefaultOutput->write(msg, length);
this->DefaultOutput->flush();
}
if ( msg[length-1] == '\n' || length > 2 )
{
if (msg[length - 1] == '\n' || length > 2) {
this->NewLine = true;
}
if ( error )
{
if (error) {
cmSystemTools::SetErrorOccured();
}
}

25
Source/CPack/cmCPackLog.h
View File

@ -19,20 +19,19 @@
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
(ctSelf)->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str());\
} while ( 0 )
(ctSelf)->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str()); \
} while (0)
#ifdef cerr
# undef cerr
#undef cerr
#endif
#define cerr no_cerr_use_cmCPack_Log
#ifdef cout
# undef cout
#undef cout
#endif
#define cout no_cout_use_cmCPack_Log
/** \class cmCPackLog
* \brief A container for CPack generators
*
@ -45,7 +44,8 @@ public:
cmCPackLog();
~cmCPackLog();
enum __log_tags {
enum __log_tags
{
NOTAG = 0,
LOG_OUTPUT = 0x1,
LOG_VERBOSE = 0x2,
@ -126,11 +126,11 @@ private:
std::string WarningPrefix;
std::string ErrorPrefix;
std::ostream *DefaultOutput;
std::ostream *DefaultError;
std::ostream* DefaultOutput;
std::ostream* DefaultError;
std::string LogOutputFileName;
std::ostream *LogOutput;
std::ostream* LogOutput;
// Do we need to cleanup log output stream
bool LogOutputCleanup;
};
@ -139,13 +139,16 @@ class cmCPackLogWrite
{
public:
cmCPackLogWrite(const char* data, size_t length)
: Data(data), Length(length) {}
: Data(data)
, Length(length)
{
}
const char* Data;
size_t Length;
};
inline std::ostream& operator<< (std::ostream& os, const cmCPackLogWrite& c)
inline std::ostream& operator<<(std::ostream& os, const cmCPackLogWrite& c)
{
os.write(c.Data, c.Length);
os.flush();

634
Source/CPack/cmCPackNSISGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

23
Source/CPack/cmCPackNSISGenerator.h
View File

@ -28,7 +28,9 @@ public:
cmCPackTypeMacro(cmCPackNSISGenerator, cmCPackGenerator);
static cmCPackGenerator* CreateGenerator64()
{ return new cmCPackNSISGenerator(true); }
{
return new cmCPackNSISGenerator(true);
}
/**
* Construct generator
@ -38,8 +40,7 @@ public:
protected:
virtual int InitializeInternal();
void CreateMenuLinks( std::ostringstream& str,
std::ostringstream& deleteStr);
void CreateMenuLinks(std::ostringstream& str, std::ostringstream& deleteStr);
int PackageFiles();
virtual const char* GetOutputExtension() { return ".exe"; }
virtual const char* GetOutputPostfix() { return "win32"; }
@ -54,27 +55,23 @@ protected:
/// Produce a string that contains the NSIS code to describe a
/// particular component. Any added macros will be emitted via
/// macrosOut.
std::string
CreateComponentDescription(cmCPackComponent *component,
std::string CreateComponentDescription(cmCPackComponent* component,
std::ostringstream& macrosOut);
/// Produce NSIS code that selects all of the components that this component
/// depends on, recursively.
std::string CreateSelectionDependenciesDescription
(cmCPackComponent *component,
std::set<cmCPackComponent *>& visited);
std::string CreateSelectionDependenciesDescription(
cmCPackComponent* component, std::set<cmCPackComponent*>& visited);
/// Produce NSIS code that de-selects all of the components that are
/// dependent on this component, recursively.
std::string CreateDeselectionDependenciesDescription
(cmCPackComponent *component,
std::set<cmCPackComponent *>& visited);
std::string CreateDeselectionDependenciesDescription(
cmCPackComponent* component, std::set<cmCPackComponent*>& visited);
/// Produce a string that contains the NSIS code to describe a
/// particular component group, including its components. Any
/// added macros will be emitted via macrosOut.
std::string
CreateComponentGroupDescription(cmCPackComponentGroup *group,
std::string CreateComponentGroupDescription(cmCPackComponentGroup* group,
std::ostringstream& macrosOut);
/// Translations any newlines found in the string into \\r\\n, so that the

133
Source/CPack/cmCPackOSXX11Generator.cxx
View File

@ -36,10 +36,9 @@ int cmCPackOSXX11Generator::PackageFiles()
// TODO: Use toplevel ?
// It is used! Is this an obsolete comment?
const char* cpackPackageExecutables
= this->GetOption("CPACK_PACKAGE_EXECUTABLES");
if ( cpackPackageExecutables )
{
const char* cpackPackageExecutables =
this->GetOption("CPACK_PACKAGE_EXECUTABLES");
if (cpackPackageExecutables) {
cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
<< cpackPackageExecutables << "." << std::endl);
std::ostringstream str;
@ -47,20 +46,19 @@ int cmCPackOSXX11Generator::PackageFiles()
std::vector<std::string> cpackPackageExecutablesVector;
cmSystemTools::ExpandListArgument(cpackPackageExecutables,
cpackPackageExecutablesVector);
if ( cpackPackageExecutablesVector.size() % 2 != 0 )
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
if (cpackPackageExecutablesVector.size() % 2 != 0) {
cmCPackLogger(
cmCPackLog::LOG_ERROR,
"CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
"<icon name>." << std::endl);
"<icon name>."
<< std::endl);
return 0;
}
std::vector<std::string>::iterator it;
for ( it = cpackPackageExecutablesVector.begin();
it != cpackPackageExecutablesVector.end();
++it )
{
for (it = cpackPackageExecutablesVector.begin();
it != cpackPackageExecutablesVector.end(); ++it) {
std::string cpackExecutableName = *it;
++ it;
++it;
this->SetOptionIfNotSet("CPACK_EXECUTABLE_NAME",
cpackExecutableName.c_str());
}
@ -68,9 +66,8 @@ int cmCPackOSXX11Generator::PackageFiles()
// Disk image directories
std::string diskImageDirectory = toplevel;
std::string diskImageBackgroundImageDir
= diskImageDirectory + "/.background";
std::string diskImageBackgroundImageDir =
diskImageDirectory + "/.background";
// App bundle directories
std::string packageDirFileName = toplevel;
@ -90,14 +87,12 @@ int cmCPackOSXX11Generator::PackageFiles()
const char* contDir = contentsDirectory.c_str();
const char* rsrcFile = resourceFileName.c_str();
const char* iconFile = this->GetOption("CPACK_PACKAGE_ICON");
if ( iconFile )
{
std::string iconFileName = cmsys::SystemTools::GetFilenameName(
iconFile);
if ( !cmSystemTools::FileExists(iconFile) )
{
if (iconFile) {
std::string iconFileName = cmsys::SystemTools::GetFilenameName(iconFile);
if (!cmSystemTools::FileExists(iconFile)) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find icon file: "
<< iconFile << ". Please check CPACK_PACKAGE_ICON setting."
<< iconFile
<< ". Please check CPACK_PACKAGE_ICON setting."
<< std::endl);
return 0;
}
@ -109,25 +104,24 @@ int cmCPackOSXX11Generator::PackageFiles()
std::string applicationsLinkName = diskImageDirectory + "/Applications";
cmSystemTools::CreateSymlink("/Applications", applicationsLinkName.c_str());
if (
!this->CopyResourcePlistFile("VolumeIcon.icns",
if (!this->CopyResourcePlistFile("VolumeIcon.icns",
diskImageDirectory.c_str(),
".VolumeIcon.icns", true ) ||
".VolumeIcon.icns", true) ||
!this->CopyResourcePlistFile("DS_Store", diskImageDirectory.c_str(),
".DS_Store", true ) ||
".DS_Store", true) ||
!this->CopyResourcePlistFile("background.png",
diskImageBackgroundImageDir.c_str(), "background.png", true ) ||
diskImageBackgroundImageDir.c_str(),
"background.png", true) ||
!this->CopyResourcePlistFile("RuntimeScript", dir) ||
!this->CopyResourcePlistFile("OSXX11.Info.plist", contDir,
"Info.plist" ) ||
!this->CopyResourcePlistFile("OSXX11.main.scpt", scrDir,
"main.scpt", true ) ||
!this->CopyResourcePlistFile("OSXScriptLauncher.rsrc", dir,
rsrcFile, true) ||
"Info.plist") ||
!this->CopyResourcePlistFile("OSXX11.main.scpt", scrDir, "main.scpt",
true) ||
!this->CopyResourcePlistFile("OSXScriptLauncher.rsrc", dir, rsrcFile,
true) ||
!this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
this->GetOption("CPACK_PACKAGE_FILE_NAME"), true)
)
{
this->GetOption("CPACK_PACKAGE_FILE_NAME"),
true)) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
<< std::endl);
return 0;
@ -143,20 +137,20 @@ int cmCPackOSXX11Generator::PackageFiles()
appScriptName += this->GetOption("CPACK_PACKAGE_FILE_NAME");
mode_t mode;
if (cmsys::SystemTools::GetPermissions(runTimeScript.c_str(), mode))
{
if (cmsys::SystemTools::GetPermissions(runTimeScript.c_str(), mode)) {
mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
cmsys::SystemTools::SetPermissions(runTimeScript.c_str(), mode);
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Setting: " << runTimeScript
<< " to permission: " << mode << std::endl);
cmCPackLogger(cmCPackLog::LOG_OUTPUT,
"Setting: " << runTimeScript << " to permission: " << mode
<< std::endl);
}
if (cmsys::SystemTools::GetPermissions(appScriptName.c_str(), mode))
{
if (cmsys::SystemTools::GetPermissions(appScriptName.c_str(), mode)) {
mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
cmsys::SystemTools::SetPermissions(appScriptName.c_str(), mode);
cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Setting: " << appScriptName
<< " to permission: " << mode << std::endl);
cmCPackLogger(cmCPackLog::LOG_OUTPUT,
"Setting: " << appScriptName << " to permission: " << mode
<< std::endl);
}
std::string output;
@ -165,38 +159,35 @@ int cmCPackOSXX11Generator::PackageFiles()
std::ostringstream dmgCmd;
dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
<< "\" create -ov -format UDZO -srcfolder \""
<< diskImageDirectory.c_str()
<< "\" \"" << packageFileNames[0] << "\"";
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Compress disk image using command: "
<< diskImageDirectory.c_str() << "\" \"" << packageFileNames[0]
<< "\"";
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Compress disk image using command: "
<< dmgCmd.str().c_str() << std::endl);
// since we get random dashboard failures with this one
// try running it more than once
int retVal = 1;
int numTries = 10;
bool res = false;
while(numTries > 0)
{
res = cmSystemTools::RunSingleCommand(
dmgCmd.str().c_str(), &output, &output,
while (numTries > 0) {
res =
cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output, &output,
&retVal, 0, this->GeneratorVerbose, 0);
if ( res && !retVal )
{
if (res && !retVal) {
numTries = -1;
break;
}
cmSystemTools::Delay(500);
numTries--;
}
if ( !res || retVal )
{
if (!res || retVal) {
cmGeneratedFileStream ofs(tmpFile.c_str());
ofs << "# Run command: " << dmgCmd.str().c_str() << std::endl
<< "# Output:" << std::endl
<< output.c_str() << std::endl;
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
<< dmgCmd.str().c_str() << std::endl
<< "Please check " << tmpFile.c_str() << " for errors" << std::endl);
<< "Please check " << tmpFile.c_str() << " for errors"
<< std::endl);
return 0;
}
@ -205,12 +196,11 @@ int cmCPackOSXX11Generator::PackageFiles()
int cmCPackOSXX11Generator::InitializeInternal()
{
cmCPackLogger(cmCPackLog::LOG_DEBUG,
"cmCPackOSXX11Generator::Initialize()" << std::endl);
cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackOSXX11Generator::Initialize()"
<< std::endl);
std::vector<std::string> path;
std::string pkgPath = cmSystemTools::FindProgram("hdiutil", path, false);
if ( pkgPath.empty() )
{
if (pkgPath.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
<< std::endl);
return 0;
@ -265,23 +255,21 @@ bool cmCPackOSXX11Generator::CopyCreateResourceFile(const std::string& name)
}
*/
bool cmCPackOSXX11Generator::CopyResourcePlistFile(const std::string& name,
const std::string& dir, const char* outputFileName /* = 0 */,
bool copyOnly /* = false */)
bool cmCPackOSXX11Generator::CopyResourcePlistFile(
const std::string& name, const std::string& dir,
const char* outputFileName /* = 0 */, bool copyOnly /* = false */)
{
std::string inFName = "CPack.";
inFName += name;
inFName += ".in";
std::string inFileName = this->FindTemplate(inFName.c_str());
if ( inFileName.empty() )
{
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find input file: "
<< inFName << std::endl);
if (inFileName.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find input file: " << inFName << std::endl);
return false;
}
if ( !outputFileName )
{
if (!outputFileName) {
outputFileName = name.c_str();
}
@ -289,8 +277,9 @@ bool cmCPackOSXX11Generator::CopyResourcePlistFile(const std::string& name,
destFileName += "/";
destFileName += outputFileName;
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
<< inFileName.c_str() << " to " << destFileName.c_str() << std::endl);
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Configure file: " << inFileName.c_str() << " to "
<< destFileName.c_str() << std::endl);
this->ConfigureFile(inFileName.c_str(), destFileName.c_str(), copyOnly);
return true;
}

5
Source/CPack/cmCPackOSXX11Generator.h
View File

@ -37,10 +37,11 @@ protected:
virtual const char* GetPackagingInstallPrefix();
virtual const char* GetOutputExtension() { return ".dmg"; }
//bool CopyCreateResourceFile(const std::string& name,
// bool CopyCreateResourceFile(const std::string& name,
// const std::string& dir);
bool CopyResourcePlistFile(const std::string& name, const std::string& dir,
const char* outputFileName = 0, bool copyOnly = false);
const char* outputFileName = 0,
bool copyOnly = false);
std::string InstallPrefix;
};

536
Source/CPack/cmCPackPackageMakerGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

18
Source/CPack/cmCPackPackageMakerGenerator.h
View File

@ -37,8 +37,7 @@ public:
virtual bool SupportsComponentInstallation() const;
protected:
int CopyInstallScript(const std::string& resdir,
const std::string& script,
int CopyInstallScript(const std::string& resdir, const std::string& script,
const std::string& name);
virtual int InitializeInternal();
int PackageFiles();
@ -57,7 +56,7 @@ protected:
// Run PackageMaker with the given command line, which will (if
// successful) produce the given package file. Returns true if
// PackageMaker succeeds, false otherwise.
bool RunPackageMaker(const char *command, const char *packageFile);
bool RunPackageMaker(const char* command, const char* packageFile);
// Retrieve the name of package file that will be generated for this
// component. The name is just the file name with extension, and
@ -68,8 +67,8 @@ protected:
// component. All of the files within this component are stored in
// the directory packageDir. Returns true if successful, false
// otherwise.
bool GenerateComponentPackage(const char *packageFile,
const char *packageDir,
bool GenerateComponentPackage(const char* packageFile,
const char* packageDir,
const cmCPackComponent& component);
// Writes a distribution.dist file, which turns a metapackage into a
@ -82,15 +81,14 @@ protected:
// Subroutine of WriteDistributionFile that writes out the
// dependency attributes for inter-component dependencies.
void AddDependencyAttributes(const cmCPackComponent& component,
std::set<const cmCPackComponent *>& visited,
std::set<const cmCPackComponent*>& visited,
std::ostringstream& out);
// Subroutine of WriteDistributionFile that writes out the
// reverse dependency attributes for inter-component dependencies.
void
AddReverseDependencyAttributes(const cmCPackComponent& component,
std::set<const cmCPackComponent *>& visited,
std::ostringstream& out);
void AddReverseDependencyAttributes(
const cmCPackComponent& component,
std::set<const cmCPackComponent*>& visited, std::ostringstream& out);
// Generates XML that encodes the hierarchy of component groups and
// their components in a form that can be used by distribution

164
Source/CPack/cmCPackRPMGenerator.cxx
View File

@ -25,8 +25,7 @@ cmCPackRPMGenerator::~cmCPackRPMGenerator()
int cmCPackRPMGenerator::InitializeInternal()
{
this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR")))
{
if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR"))) {
this->SetOption("CPACK_SET_DESTDIR", "I_ON");
}
/* Replace space in CPACK_PACKAGE_NAME in order to avoid
@ -34,15 +33,15 @@ int cmCPackRPMGenerator::InitializeInternal()
* Moreover RPM file do not usually embed space in filename
*/
if (this->GetOption("CPACK_PACKAGE_NAME")) {
std::string packageName=this->GetOption("CPACK_PACKAGE_NAME");
cmSystemTools::ReplaceString(packageName," ","-");
this->SetOption("CPACK_PACKAGE_NAME",packageName.c_str());
std::string packageName = this->GetOption("CPACK_PACKAGE_NAME");
cmSystemTools::ReplaceString(packageName, " ", "-");
this->SetOption("CPACK_PACKAGE_NAME", packageName.c_str());
}
/* same for CPACK_PACKAGE_FILE_NAME */
if (this->GetOption("CPACK_PACKAGE_FILE_NAME")) {
std::string packageName=this->GetOption("CPACK_PACKAGE_FILE_NAME");
cmSystemTools::ReplaceString(packageName," ","-");
this->SetOption("CPACK_PACKAGE_FILE_NAME",packageName.c_str());
std::string packageName = this->GetOption("CPACK_PACKAGE_FILE_NAME");
cmSystemTools::ReplaceString(packageName, " ", "-");
this->SetOption("CPACK_PACKAGE_FILE_NAME", packageName.c_str());
}
return this->Superclass::InitializeInternal();
}
@ -53,14 +52,13 @@ void cmCPackRPMGenerator::AddGeneratedPackageNames()
std::string fileNames(this->GetOption("GEN_CPACK_OUTPUT_FILES"));
const char sep = ';';
std::string::size_type pos1 = 0;
std::string::size_type pos2 = fileNames.find(sep, pos1+1);
while(pos2 != std::string::npos)
{
packageFileNames.push_back(fileNames.substr(pos1, pos2-pos1));
pos1 = pos2+1;
pos2 = fileNames.find(sep, pos1+1);
std::string::size_type pos2 = fileNames.find(sep, pos1 + 1);
while (pos2 != std::string::npos) {
packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
pos1 = pos2 + 1;
pos2 = fileNames.find(sep, pos1 + 1);
}
packageFileNames.push_back(fileNames.substr(pos1, pos2-pos1));
packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
}
int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
@ -69,36 +67,31 @@ int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
int retval = 1;
// Begin the archive for this pack
std::string localToplevel(initialToplevel);
std::string packageFileName(
cmSystemTools::GetParentDirectory(toplevel)
);
std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
std::string outputFileName(
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
packageName,
true)
+ this->GetOutputExtension()
);
packageName, true) +
this->GetOutputExtension());
localToplevel += "/"+ packageName;
localToplevel += "/" + packageName;
/* replace the TEMP DIRECTORY with the component one */
this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
packageFileName += "/"+ outputFileName;
this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
packageFileName += "/" + outputFileName;
/* replace proposed CPACK_OUTPUT_FILE_NAME */
this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
/* replace the TEMPORARY package file name */
this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
packageFileName.c_str());
// Tell CPackRPM.cmake the name of the component NAME.
this->SetOption("CPACK_RPM_PACKAGE_COMPONENT",packageName.c_str());
this->SetOption("CPACK_RPM_PACKAGE_COMPONENT", packageName.c_str());
// Tell CPackRPM.cmake the path where the component is.
std::string component_path = "/";
component_path += packageName;
this->SetOption("CPACK_RPM_PACKAGE_COMPONENT_PART_PATH",
component_path.c_str());
if (!this->ReadListFile("CPackRPM.cmake"))
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error while execution CPackRPM.cmake" << std::endl);
if (!this->ReadListFile("CPackRPM.cmake")) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
<< std::endl);
retval = 0;
}
@ -115,48 +108,40 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
// The default behavior is to have one package by component group
// unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
if (!ignoreGroup)
{
if (!ignoreGroup) {
std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
for (compGIt=this->ComponentGroups.begin();
compGIt!=this->ComponentGroups.end(); ++compGIt)
{
for (compGIt = this->ComponentGroups.begin();
compGIt != this->ComponentGroups.end(); ++compGIt) {
cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
<< compGIt->first
<< std::endl);
retval &= PackageOnePack(initialTopLevel,compGIt->first);
<< compGIt->first << std::endl);
retval &= PackageOnePack(initialTopLevel, compGIt->first);
}
// Handle Orphan components (components not belonging to any groups)
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();
compIt!=this->Components.end(); ++compIt )
{
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
// Does the component belong to a group?
if (compIt->second.Group==NULL)
{
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Component <"
if (compIt->second.Group == NULL) {
cmCPackLogger(
cmCPackLog::LOG_VERBOSE, "Component <"
<< compIt->second.Name
<< "> does not belong to any group, package it separately."
<< std::endl);
retval &= PackageOnePack(initialTopLevel,compIt->first);
retval &= PackageOnePack(initialTopLevel, compIt->first);
}
}
}
// CPACK_COMPONENTS_IGNORE_GROUPS is set
// We build 1 package per component
else
{
else {
std::map<std::string, cmCPackComponent>::iterator compIt;
for (compIt=this->Components.begin();
compIt!=this->Components.end(); ++compIt )
{
retval &= PackageOnePack(initialTopLevel,compIt->first);
for (compIt = this->Components.begin(); compIt != this->Components.end();
++compIt) {
retval &= PackageOnePack(initialTopLevel, compIt->first);
}
}
if(retval)
{
if (retval) {
AddGeneratedPackageNames();
}
@ -179,27 +164,23 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
// The ALL GROUPS in ONE package case
std::string localToplevel(initialTopLevel);
std::string packageFileName(
cmSystemTools::GetParentDirectory(toplevel)
);
std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
std::string outputFileName(
std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
+ this->GetOutputExtension()
);
std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
this->GetOutputExtension());
// all GROUP in one vs all COMPONENT in one
localToplevel += "/"+compInstDirName;
localToplevel += "/" + compInstDirName;
/* replace the TEMP DIRECTORY with the component one */
this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
packageFileName += "/"+ outputFileName;
this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
packageFileName += "/" + outputFileName;
/* replace proposed CPACK_OUTPUT_FILE_NAME */
this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
/* replace the TEMPORARY package file name */
this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
packageFileName.c_str());
if(!compInstDirName.empty())
{
if (!compInstDirName.empty()) {
// Tell CPackRPM.cmake the path where the component is.
std::string component_path = "/";
component_path += compInstDirName;
@ -207,14 +188,11 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
component_path.c_str());
}
if (this->ReadListFile("CPackRPM.cmake"))
{
if (this->ReadListFile("CPackRPM.cmake")) {
AddGeneratedPackageNames();
}
else
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Error while execution CPackRPM.cmake" << std::endl);
} else {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
<< std::endl);
retval = 0;
}
@ -223,50 +201,43 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
int cmCPackRPMGenerator::PackageFiles()
{
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
<< toplevel << std::endl);
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
/* Are we in the component packaging case */
if (WantsComponentInstallation()) {
// CASE 1 : COMPONENT ALL-IN-ONE package
// If ALL COMPONENTS in ONE package has been requested
// then the package file is unique and should be open here.
if (componentPackageMethod == ONE_PACKAGE)
{
if (componentPackageMethod == ONE_PACKAGE) {
return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
}
// CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
// There will be 1 package for each component group
// however one may require to ignore component group and
// in this case you'll get 1 package for each component.
else
{
else {
return PackageComponents(componentPackageMethod ==
ONE_PACKAGE_PER_COMPONENT);
}
}
// CASE 3 : NON COMPONENT package.
else
{
else {
return PackageComponentsAllInOne("");
}
}
bool cmCPackRPMGenerator::SupportsComponentInstallation() const
{
if (IsOn("CPACK_RPM_COMPONENT_INSTALL"))
{
{
if (IsOn("CPACK_RPM_COMPONENT_INSTALL")) {
return true;
}
else
{
} else {
return false;
}
}
}
std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
const std::string& componentName)
{
{
if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
return componentName;
}
@ -276,14 +247,11 @@ std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
}
// We have to find the name of the COMPONENT GROUP
// the current COMPONENT belongs to.
std::string groupVar = "CPACK_COMPONENT_" +
cmSystemTools::UpperCase(componentName) + "_GROUP";
if (NULL != GetOption(groupVar))
{
std::string groupVar =
"CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
if (NULL != GetOption(groupVar)) {
return std::string(GetOption(groupVar));
}
else
{
} else {
return componentName;
}
}
}

37
Source/CPack/cmCPackSTGZGenerator.cxx
View File

@ -37,10 +37,9 @@ int cmCPackSTGZGenerator::InitializeInternal()
this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
std::string inFile = this->FindTemplate("CPack.STGZ_Header.sh.in");
if ( inFile.empty() )
{
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find template file: "
<< inFile << std::endl);
if (inFile.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find template file: " << inFile << std::endl);
return 0;
}
this->SetOptionIfNotSet("CPACK_STGZ_HEADER_FILE", inFile.c_str());
@ -52,8 +51,7 @@ int cmCPackSTGZGenerator::InitializeInternal()
int cmCPackSTGZGenerator::PackageFiles()
{
bool retval = true;
if ( !this->Superclass::PackageFiles() )
{
if (!this->Superclass::PackageFiles()) {
return 0;
}
@ -61,11 +59,10 @@ int cmCPackSTGZGenerator::PackageFiles()
* have generated several packages (component packaging)
* so we must iterate over generated packages.
*/
for (std::vector<std::string>::iterator it=packageFileNames.begin();
it != packageFileNames.end(); ++it)
{
for (std::vector<std::string>::iterator it = packageFileNames.begin();
it != packageFileNames.end(); ++it) {
retval &= cmSystemTools::SetPermissions((*it).c_str(),
#if defined( _MSC_VER ) || defined( __MINGW32__ )
#if defined(_MSC_VER) || defined(__MINGW32__)
S_IREAD | S_IWRITE | S_IEXEC
#else
S_IRUSR | S_IWUSR | S_IXUSR |
@ -87,8 +84,7 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
std::string line;
cmsys::ifstream ilfs(inLicFile.c_str());
std::string licenseText;
while ( cmSystemTools::GetLineFromStream(ilfs, line) )
{
while (cmSystemTools::GetLineFromStream(ilfs, line)) {
licenseText += line + "\n";
}
this->SetOptionIfNotSet("CPACK_RESOURCE_FILE_LICENSE_CONTENT",
@ -100,8 +96,7 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
std::string inFile = this->GetOption("CPACK_STGZ_HEADER_FILE");
cmsys::ifstream ifs(inFile.c_str());
std::string packageHeaderText;
while ( cmSystemTools::GetLineFromStream(ifs, line) )
{
while (cmSystemTools::GetLineFromStream(ifs, line)) {
packageHeaderText += line + "\n";
}
@ -111,17 +106,15 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
// Count the lines
const char* ptr = res.c_str();
while ( *ptr )
{
if ( *ptr == '\n' )
{
counter ++;
while (*ptr) {
if (*ptr == '\n') {
counter++;
}
++ptr;
}
counter ++;
cmCPackLogger(cmCPackLog::LOG_DEBUG,
"Number of lines: " << counter << std::endl);
counter++;
cmCPackLogger(cmCPackLog::LOG_DEBUG, "Number of lines: " << counter
<< std::endl);
char buffer[1024];
sprintf(buffer, "%d", counter);
cmSystemTools::ReplaceString(res, headerLengthTag, buffer);

4
Source/CPack/cmCPackTGZGenerator.cxx
View File

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

1
Source/CPack/cmCPackTGZGenerator.h
View File

@ -28,6 +28,7 @@ public:
*/
cmCPackTGZGenerator();
virtual ~cmCPackTGZGenerator();
protected:
virtual const char* GetOutputExtension() { return ".tar.gz"; }
};

3
Source/CPack/cmCPackTXZGenerator.cxx
View File

@ -13,8 +13,7 @@
#include "cmCPackTXZGenerator.h"
cmCPackTXZGenerator::cmCPackTXZGenerator()
:cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ,
"paxr")
: cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ, "paxr")
{
}

1
Source/CPack/cmCPackTXZGenerator.h
View File

@ -28,6 +28,7 @@ public:
*/
cmCPackTXZGenerator();
virtual ~cmCPackTXZGenerator();
protected:
virtual const char* GetOutputExtension() { return ".tar.xz"; }
};

4
Source/CPack/cmCPackTarBZip2Generator.cxx
View File

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

1
Source/CPack/cmCPackTarBZip2Generator.h
View File

@ -27,6 +27,7 @@ public:
*/
cmCPackTarBZip2Generator();
virtual ~cmCPackTarBZip2Generator();
protected:
virtual const char* GetOutputExtension() { return ".tar.bz2"; }
};

4
Source/CPack/cmCPackTarCompressGenerator.cxx
View File

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

4
Source/CPack/cmCPackZIPGenerator.cxx
View File

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

268
Source/CPack/cpack.cxx
View File

@ -26,33 +26,28 @@
#include <cmsys/Encoding.hxx>
#include <cmsys/SystemTools.hxx>
static const char * cmDocumentationName[][2] =
{
{0,
" cpack - Packaging driver provided by CMake."},
{0,0}
static const char* cmDocumentationName[][2] = {
{ 0, " cpack - Packaging driver provided by CMake." },
{ 0, 0 }
};
static const char * cmDocumentationUsage[][2] =
{
{0,
" cpack -G <generator> [options]"},
{0,0}
static const char* cmDocumentationUsage[][2] = {
{ 0, " cpack -G <generator> [options]" },
{ 0, 0 }
};
static const char * cmDocumentationOptions[][2] =
{
{"-G <generator>", "Use the specified generator to generate package."},
{"-C <Configuration>", "Specify the project configuration"},
{"-D <var>=<value>", "Set a CPack variable."},
{"--config <config file>", "Specify the config file."},
{"--verbose,-V","enable verbose output"},
{"--debug","enable debug output (for CPack developers)"},
{"-P <package name>","override/define CPACK_PACKAGE_NAME"},
{"-R <package version>","override/define CPACK_PACKAGE_VERSION"},
{"-B <package directory>","override/define CPACK_PACKAGE_DIRECTORY"},
{"--vendor <vendor name>","override/define CPACK_PACKAGE_VENDOR"},
{0,0}
static const char* cmDocumentationOptions[][2] = {
{ "-G <generator>", "Use the specified generator to generate package." },
{ "-C <Configuration>", "Specify the project configuration" },
{ "-D <var>=<value>", "Set a CPack variable." },
{ "--config <config file>", "Specify the config file." },
{ "--verbose,-V", "enable verbose output" },
{ "--debug", "enable debug output (for CPack developers)" },
{ "-P <package name>", "override/define CPACK_PACKAGE_NAME" },
{ "-R <package version>", "override/define CPACK_PACKAGE_VERSION" },
{ "-B <package directory>", "override/define CPACK_PACKAGE_DIRECTORY" },
{ "--vendor <vendor name>", "override/define CPACK_PACKAGE_VENDOR" },
{ 0, 0 }
};
int cpackUnknownArgument(const char*, void*)
@ -64,7 +59,7 @@ struct cpackDefinitions
{
typedef std::map<std::string, std::string> MapType;
MapType Map;
cmCPackLog *Log;
cmCPackLog* Log;
};
int cpackDefinitionArgument(const char* argument, const char* cValue,
@ -74,8 +69,7 @@ int cpackDefinitionArgument(const char* argument, const char* cValue,
cpackDefinitions* def = static_cast<cpackDefinitions*>(call_data);
std::string value = cValue;
size_t pos = value.find_first_of("=");
if ( pos == std::string::npos )
{
if (pos == std::string::npos) {
cmCPack_Log(def->Log, cmCPackLog::LOG_ERROR,
"Please specify CPack definitions as: KEY=VALUE" << std::endl);
return 0;
@ -88,9 +82,8 @@ int cpackDefinitionArgument(const char* argument, const char* cValue,
return 1;
}
// this is CPack.
int main (int argc, char const* const* argv)
int main(int argc, char const* const* argv)
{
cmsys::Encoding::CommandLineArguments args =
cmsys::Encoding::CommandLineArguments::Main(argc, argv);
@ -107,10 +100,10 @@ int main (int argc, char const* const* argv)
cmSystemTools::EnableMSVCDebugHook();
if (cmSystemTools::GetCurrentWorkingDirectory().empty())
{
if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Current working directory cannot be established." << std::endl);
"Current working directory cannot be established."
<< std::endl);
return 1;
}
@ -155,33 +148,30 @@ int main (int argc, char const* const* argv)
"CPack configuration file");
arg.AddArgument("-C", argT::SPACE_ARGUMENT, &cpackBuildConfig,
"CPack build configuration");
arg.AddArgument("-G", argT::SPACE_ARGUMENT,
&generator, "CPack generator");
arg.AddArgument("-P", argT::SPACE_ARGUMENT,
&cpackProjectName, "CPack project name");
arg.AddArgument("-R", argT::SPACE_ARGUMENT,
&cpackProjectVersion, "CPack project version");
arg.AddArgument("-B", argT::SPACE_ARGUMENT,
&cpackProjectDirectory, "CPack project directory");
arg.AddArgument("--patch", argT::SPACE_ARGUMENT,
&cpackProjectPatch, "CPack project patch");
arg.AddArgument("--vendor", argT::SPACE_ARGUMENT,
&cpackProjectVendor, "CPack project vendor");
arg.AddCallback("-D", argT::SPACE_ARGUMENT,
cpackDefinitionArgument, &definitions, "CPack Definitions");
arg.AddArgument("-G", argT::SPACE_ARGUMENT, &generator, "CPack generator");
arg.AddArgument("-P", argT::SPACE_ARGUMENT, &cpackProjectName,
"CPack project name");
arg.AddArgument("-R", argT::SPACE_ARGUMENT, &cpackProjectVersion,
"CPack project version");
arg.AddArgument("-B", argT::SPACE_ARGUMENT, &cpackProjectDirectory,
"CPack project directory");
arg.AddArgument("--patch", argT::SPACE_ARGUMENT, &cpackProjectPatch,
"CPack project patch");
arg.AddArgument("--vendor", argT::SPACE_ARGUMENT, &cpackProjectVendor,
"CPack project vendor");
arg.AddCallback("-D", argT::SPACE_ARGUMENT, cpackDefinitionArgument,
&definitions, "CPack Definitions");
arg.SetUnknownArgumentCallback(cpackUnknownArgument);
// Parse command line
int parsed = arg.Parse();
// Setup logging
if ( verbose )
{
if (verbose) {
log.SetVerbose(verbose);
cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Verbose" << std::endl);
}
if ( debug )
{
if (debug) {
log.SetDebug(debug);
cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Debug" << std::endl);
}
@ -202,8 +192,7 @@ int main (int argc, char const* const* argv)
#endif
bool cpackConfigFileSpecified = true;
if ( cpackConfigFile.empty() )
{
if (cpackConfigFile.empty()) {
cpackConfigFile = cmSystemTools::GetCurrentWorkingDirectory();
cpackConfigFile += "/CPackConfig.cmake";
cpackConfigFileSpecified = false;
@ -220,26 +209,21 @@ int main (int argc, char const* const* argv)
* should launch cpack using "cpackConfigFile" if it exists
* in the current directory.
*/
if((doc.CheckOptions(argc, argv,"-G")) && !(argc==1))
{
if ((doc.CheckOptions(argc, argv, "-G")) && !(argc == 1)) {
help = true;
}
else
{
} else {
help = false;
}
// This part is used for cpack documentation lookup as well.
cminst.AddCMakePaths();
if ( parsed && !help )
{
if (parsed && !help) {
// find out which system cpack is running on, so it can setup the search
// paths, so FIND_XXX() commands can be used in scripts
std::string systemFile =
globalMF->GetModulesFile("CMakeDetermineSystem.cmake");
if (!globalMF->ReadListFile(systemFile.c_str()))
{
if (!globalMF->ReadListFile(systemFile.c_str())) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Error reading CMakeDetermineSystem.cmake" << std::endl);
return 1;
@ -247,115 +231,91 @@ int main (int argc, char const* const* argv)
systemFile =
globalMF->GetModulesFile("CMakeSystemSpecificInformation.cmake");
if (!globalMF->ReadListFile(systemFile.c_str()))
{
if (!globalMF->ReadListFile(systemFile.c_str())) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Error reading CMakeSystemSpecificInformation.cmake" << std::endl);
"Error reading CMakeSystemSpecificInformation.cmake"
<< std::endl);
return 1;
}
if ( !cpackBuildConfig.empty() )
{
if (!cpackBuildConfig.empty()) {
globalMF->AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
}
if ( cmSystemTools::FileExists(cpackConfigFile.c_str()) )
{
cpackConfigFile =
cmSystemTools::CollapseFullPath(cpackConfigFile);
if (cmSystemTools::FileExists(cpackConfigFile.c_str())) {
cpackConfigFile = cmSystemTools::CollapseFullPath(cpackConfigFile);
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
"Read CPack configuration file: " << cpackConfigFile
<< std::endl);
if ( !globalMF->ReadListFile(cpackConfigFile.c_str()) )
{
if (!globalMF->ReadListFile(cpackConfigFile.c_str())) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Problem reading CPack config file: \""
<< cpackConfigFile << "\"" << std::endl);
return 1;
}
}
else if ( cpackConfigFileSpecified )
{
} else if (cpackConfigFileSpecified) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Cannot find CPack config file: \"" <<
cpackConfigFile << "\"" << std::endl);
"Cannot find CPack config file: \"" << cpackConfigFile
<< "\"" << std::endl);
return 1;
}
if ( !generator.empty() )
{
if (!generator.empty()) {
globalMF->AddDefinition("CPACK_GENERATOR", generator.c_str());
}
if ( !cpackProjectName.empty() )
{
if (!cpackProjectName.empty()) {
globalMF->AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName.c_str());
}
if ( !cpackProjectVersion.empty() )
{
if (!cpackProjectVersion.empty()) {
globalMF->AddDefinition("CPACK_PACKAGE_VERSION",
cpackProjectVersion.c_str());
}
if ( !cpackProjectVendor.empty() )
{
if (!cpackProjectVendor.empty()) {
globalMF->AddDefinition("CPACK_PACKAGE_VENDOR",
cpackProjectVendor.c_str());
}
// if this is not empty it has been set on the command line
// go for it. Command line override values set in config file.
if ( !cpackProjectDirectory.empty() )
{
if (!cpackProjectDirectory.empty()) {
globalMF->AddDefinition("CPACK_PACKAGE_DIRECTORY",
cpackProjectDirectory.c_str());
}
// The value has not been set on the command line
else
{
else {
// get a default value (current working directory)
cpackProjectDirectory = cmsys::SystemTools::GetCurrentWorkingDirectory();
// use default value iff no value has been provided by the config file
if (!globalMF->IsSet("CPACK_PACKAGE_DIRECTORY"))
{
if (!globalMF->IsSet("CPACK_PACKAGE_DIRECTORY")) {
globalMF->AddDefinition("CPACK_PACKAGE_DIRECTORY",
cpackProjectDirectory.c_str());
}
}
cpackDefinitions::MapType::iterator cdit;
for ( cdit = definitions.Map.begin();
cdit != definitions.Map.end();
++cdit )
{
for (cdit = definitions.Map.begin(); cdit != definitions.Map.end();
++cdit) {
globalMF->AddDefinition(cdit->first, cdit->second.c_str());
}
const char* cpackModulesPath =
globalMF->GetDefinition("CPACK_MODULE_PATH");
if ( cpackModulesPath )
{
if (cpackModulesPath) {
globalMF->AddDefinition("CMAKE_MODULE_PATH", cpackModulesPath);
}
const char* genList = globalMF->GetDefinition("CPACK_GENERATOR");
if ( !genList )
{
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"CPack generator not specified" << std::endl);
}
else
{
if (!genList) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR, "CPack generator not specified"
<< std::endl);
} else {
std::vector<std::string> generatorsVector;
cmSystemTools::ExpandListArgument(genList,
generatorsVector);
cmSystemTools::ExpandListArgument(genList, generatorsVector);
std::vector<std::string>::iterator it;
for ( it = generatorsVector.begin();
it != generatorsVector.end();
++it )
{
for (it = generatorsVector.begin(); it != generatorsVector.end(); ++it) {
const char* gen = it->c_str();
cmMakefile::ScopePushPop raii(globalMF.get());
cmMakefile* mf = globalMF.get();
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
"Specified generator: " << gen << std::endl);
if ( parsed && !mf->GetDefinition("CPACK_PACKAGE_NAME") )
{
if (parsed && !mf->GetDefinition("CPACK_PACKAGE_NAME")) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"CPack project name not specified" << std::endl);
parsed = 0;
@ -364,38 +324,37 @@ int main (int argc, char const* const* argv)
!(mf->GetDefinition("CPACK_PACKAGE_VERSION") ||
(mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR") &&
mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR") &&
mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH"))))
{
mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH")))) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"CPack project version not specified" << std::endl
"CPack project version not specified"
<< std::endl
<< "Specify CPACK_PACKAGE_VERSION, or "
"CPACK_PACKAGE_VERSION_MAJOR, "
"CPACK_PACKAGE_VERSION_MINOR, and CPACK_PACKAGE_VERSION_PATCH."
"CPACK_PACKAGE_VERSION_MINOR, and "
"CPACK_PACKAGE_VERSION_PATCH."
<< std::endl);
parsed = 0;
}
if ( parsed )
{
if (parsed) {
cpackGenerator = generators.NewGenerator(gen);
if ( !cpackGenerator )
{
if (!cpackGenerator) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Cannot initialize CPack generator: "
<< gen << std::endl);
"Cannot initialize CPack generator: " << gen
<< std::endl);
parsed = 0;
}
if ( parsed && !cpackGenerator->Initialize(gen, mf) )
{
if (parsed && !cpackGenerator->Initialize(gen, mf)) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Cannot initialize the generator " << gen << std::endl);
"Cannot initialize the generator " << gen
<< std::endl);
parsed = 0;
}
if ( !mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
if (!mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
!mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
!mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS") )
{
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
!mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS")) {
cmCPack_Log(
&log, cmCPackLog::LOG_ERROR,
"Please specify build tree of the project that uses CMake "
"using CPACK_INSTALL_CMAKE_PROJECTS, specify "
"CPACK_INSTALL_COMMANDS, or specify "
@ -403,36 +362,33 @@ int main (int argc, char const* const* argv)
<< std::endl);
parsed = 0;
}
if ( parsed )
{
if (parsed) {
const char* projName = mf->GetDefinition("CPACK_PACKAGE_NAME");
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE, "Use generator: "
<< cpackGenerator->GetNameOfClass() << std::endl);
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE, "For project: "
<< projName << std::endl);
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
"For project: " << projName << std::endl);
const char* projVersion =
mf->GetDefinition("CPACK_PACKAGE_VERSION");
if ( !projVersion )
{
const char* projVersionMajor
= mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
const char* projVersionMinor
= mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
const char* projVersionPatch
= mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
if (!projVersion) {
const char* projVersionMajor =
mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
const char* projVersionMinor =
mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
const char* projVersionPatch =
mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
std::ostringstream ostr;
ostr << projVersionMajor << "." << projVersionMinor << "."
<< projVersionPatch;
mf->AddDefinition("CPACK_PACKAGE_VERSION",
ostr.str().c_str());
mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str().c_str());
}
int res = cpackGenerator->DoPackage();
if ( !res )
{
if (!res) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Error when generating package: " << projName << std::endl);
"Error when generating package: " << projName
<< std::endl);
return 1;
}
}
@ -445,35 +401,31 @@ int main (int argc, char const* const* argv)
* instance in order to create appropriate structure
* in order to satisfy the appropriate --help-xxx request
*/
if ( help )
{
if (help) {
// Construct and print requested documentation.
doc.SetName("cpack");
doc.SetSection("Name",cmDocumentationName);
doc.SetSection("Usage",cmDocumentationUsage);
doc.PrependSection("Options",cmDocumentationOptions);
doc.SetSection("Name", cmDocumentationName);
doc.SetSection("Usage", cmDocumentationUsage);
doc.PrependSection("Options", cmDocumentationOptions);
std::vector<cmDocumentationEntry> v;
cmCPackGeneratorFactory::DescriptionsMap::const_iterator generatorIt;
for( generatorIt = generators.GetGeneratorsList().begin();
generatorIt != generators.GetGeneratorsList().end();
++ generatorIt )
{
for (generatorIt = generators.GetGeneratorsList().begin();
generatorIt != generators.GetGeneratorsList().end(); ++generatorIt) {
cmDocumentationEntry e;
e.Name = generatorIt->first.c_str();
e.Brief = generatorIt->second.c_str();
v.push_back(e);
}
doc.SetSection("Generators",v);
doc.SetSection("Generators", v);
#undef cout
return doc.PrintRequestedDocumentation(std::cout)? 0:1;
return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
#define cout no_cout_use_cmCPack_Log
}
if (cmSystemTools::GetErrorOccuredFlag())
{
if (cmSystemTools::GetErrorOccuredFlag()) {
return 1;
}

276
Source/CTest/cmCTestBZR.cxx
View File

@ -19,63 +19,58 @@
#include <cm_expat.h>
extern "C"
int cmBZRXMLParserUnknownEncodingHandler(void*,
const XML_Char *name,
XML_Encoding *info)
extern "C" int cmBZRXMLParserUnknownEncodingHandler(void*,
const XML_Char* name,
XML_Encoding* info)
{
static const int latin1[]=
{
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
static const int latin1[] = {
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011,
0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A,
0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020, 0x0021, 0x0022, 0x0023,
0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C,
0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E,
0x003F, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061, 0x0062,
0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B,
0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D,
0x007E, 0x007F, 0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020,
0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x02DC,
0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178, 0x00A0, 0x00A1,
0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA,
0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0, 0x00B1, 0x00B2, 0x00B3,
0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC,
0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5,
0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE,
0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00E0,
0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9,
0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2,
0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB,
0x00FC, 0x00FD, 0x00FE, 0x00FF
};
// The BZR xml output plugin can use some encodings that are not
// recognized by expat. This will lead to an error, e.g. "Error
// parsing bzr log xml: unknown encoding", the following is a
// workaround for these unknown encodings.
if(name == std::string("ascii") || name == std::string("cp1252") ||
name == std::string("ANSI_X3.4-1968"))
{
for(unsigned int i=0;i<256;++i) info->map[i] = latin1[i];
if (name == std::string("ascii") || name == std::string("cp1252") ||
name == std::string("ANSI_X3.4-1968")) {
for (unsigned int i = 0; i < 256; ++i)
info->map[i] = latin1[i];
return 1;
}
return 0;
}
cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
cmCTestGlobalVC(ct, log)
cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log)
: cmCTestGlobalVC(ct, log)
{
this->PriorRev = this->Unknown;
// Even though it is specified in the documentation, with bzr 1.13
@ -88,16 +83,18 @@ cmCTestBZR::~cmCTestBZR()
{
}
class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
class cmCTestBZR::InfoParser : public cmCTestVC::LineParser
{
public:
InfoParser(cmCTestBZR* bzr, const char* prefix):
BZR(bzr), CheckOutFound(false)
InfoParser(cmCTestBZR* bzr, const char* prefix)
: BZR(bzr)
, CheckOutFound(false)
{
this->SetLog(&bzr->Log, prefix);
this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
}
private:
cmCTestBZR* BZR;
bool CheckOutFound;
@ -105,35 +102,32 @@ private:
cmsys::RegularExpression RegexParent;
virtual bool ProcessLine()
{
if(this->RegexCheckOut.find(this->Line))
{
if (this->RegexCheckOut.find(this->Line)) {
this->BZR->URL = this->RegexCheckOut.match(1);
CheckOutFound = true;
}
else if(!CheckOutFound && this->RegexParent.find(this->Line))
{
} else if (!CheckOutFound && this->RegexParent.find(this->Line)) {
this->BZR->URL = this->RegexParent.match(1);
}
return true;
}
};
class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
class cmCTestBZR::RevnoParser : public cmCTestVC::LineParser
{
public:
RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev):
Rev(rev)
RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev)
: Rev(rev)
{
this->SetLog(&bzr->Log, prefix);
this->RegexRevno.compile("^([0-9]+)$");
}
private:
std::string& Rev;
cmsys::RegularExpression RegexRevno;
virtual bool ProcessLine()
{
if(this->RegexRevno.find(this->Line))
{
if (this->RegexRevno.find(this->Line)) {
this->Rev = this->RegexRevno.match(1);
}
return true;
@ -144,13 +138,13 @@ std::string cmCTestBZR::LoadInfo()
{
// Run "bzr info" to get the repository info from the work tree.
const char* bzr = this->CommandLineTool.c_str();
const char* bzr_info[] = {bzr, "info", 0};
const char* bzr_info[] = { bzr, "info", 0 };
InfoParser iout(this, "info-out> ");
OutputLogger ierr(this->Log, "info-err> ");
this->RunChild(bzr_info, &iout, &ierr);
// Run "bzr revno" to get the repository revision number from the work tree.
const char* bzr_revno[] = {bzr, "revno", 0};
const char* bzr_revno[] = { bzr, "revno", 0 };
std::string rev;
RevnoParser rout(this, "revno-out> ", rev);
OutputLogger rerr(this->Log, "revno-err> ");
@ -177,26 +171,29 @@ void cmCTestBZR::NoteNewRevision()
this->Log << "URL = " << this->URL << "\n";
}
class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
class cmCTestBZR::LogParser : public cmCTestVC::OutputLogger,
private cmXMLParser
{
public:
LogParser(cmCTestBZR* bzr, const char* prefix):
OutputLogger(bzr->Log, prefix), BZR(bzr),
EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
{ this->InitializeParser(); }
LogParser(cmCTestBZR* bzr, const char* prefix)
: OutputLogger(bzr->Log, prefix)
, BZR(bzr)
, EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
{
this->InitializeParser();
}
~LogParser() { this->CleanupParser(); }
virtual int InitializeParser()
{
int res = cmXMLParser::InitializeParser();
if (res)
{
if (res) {
XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
cmBZRXMLParserUnknownEncodingHandler, 0);
}
return res;
}
private:
cmCTestBZR* BZR;
@ -219,33 +216,23 @@ private:
virtual void StartElement(const std::string& name, const char**)
{
this->CData.clear();
if(name == "log")
{
if (name == "log") {
this->Rev = Revision();
this->Changes.clear();
}
// affected-files can contain blocks of
// modified, unknown, renamed, kind-changed, removed, conflicts, added
else if(name == "modified"
|| name == "renamed"
|| name == "kind-changed")
{
else if (name == "modified" || name == "renamed" ||
name == "kind-changed") {
this->CurChange = Change();
this->CurChange.Action = 'M';
}
else if(name == "added")
{
} else if (name == "added") {
this->CurChange = Change();
this->CurChange = 'A';
}
else if(name == "removed")
{
} else if (name == "removed") {
this->CurChange = Change();
this->CurChange = 'D';
}
else if(name == "unknown"
|| name == "conflicts")
{
} else if (name == "unknown" || name == "conflicts") {
// Should not happen here
this->CurChange = Change();
}
@ -253,48 +240,34 @@ private:
virtual void CharacterDataHandler(const char* data, int length)
{
this->CData.insert(this->CData.end(), data, data+length);
this->CData.insert(this->CData.end(), data, data + length);
}
virtual void EndElement(const std::string& name)
{
if(name == "log")
{
if (name == "log") {
this->BZR->DoRevision(this->Rev, this->Changes);
}
else if(!this->CData.empty() &&
(name == "file" || name == "directory"))
{
} else if (!this->CData.empty() &&
(name == "file" || name == "directory")) {
this->CurChange.Path.assign(&this->CData[0], this->CData.size());
cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
this->Changes.push_back(this->CurChange);
}
else if(!this->CData.empty() && name == "symlink")
{
} else if (!this->CData.empty() && name == "symlink") {
// symlinks have an arobase at the end in the log
this->CurChange.Path.assign(&this->CData[0], this->CData.size()-1);
this->CurChange.Path.assign(&this->CData[0], this->CData.size() - 1);
cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
this->Changes.push_back(this->CurChange);
}
else if(!this->CData.empty() && name == "committer")
{
} else if (!this->CData.empty() && name == "committer") {
this->Rev.Author.assign(&this->CData[0], this->CData.size());
if(this->EmailRegex.find(this->Rev.Author))
{
if (this->EmailRegex.find(this->Rev.Author)) {
this->Rev.Author = this->EmailRegex.match(1);
this->Rev.EMail = this->EmailRegex.match(2);
}
}
else if(!this->CData.empty() && name == "timestamp")
{
} else if (!this->CData.empty() && name == "timestamp") {
this->Rev.Date.assign(&this->CData[0], this->CData.size());
}
else if(!this->CData.empty() && name == "message")
{
} else if (!this->CData.empty() && name == "message") {
this->Rev.Log.assign(&this->CData[0], this->CData.size());
}
else if(!this->CData.empty() && name == "revno")
{
} else if (!this->CData.empty() && name == "revno") {
this->Rev.Rev.assign(&this->CData[0], this->CData.size());
}
this->CData.clear();
@ -306,14 +279,16 @@ private:
}
};
class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
class cmCTestBZR::UpdateParser : public cmCTestVC::LineParser
{
public:
UpdateParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
UpdateParser(cmCTestBZR* bzr, const char* prefix)
: BZR(bzr)
{
this->SetLog(&bzr->Log, prefix);
this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
}
private:
cmCTestBZR* BZR;
cmsys::RegularExpression RegexUpdate;
@ -323,21 +298,16 @@ private:
bool last_is_new_line = (*first == '\r' || *first == '\n');
const char* const last = first + length;
for(const char* c = first; c != last; ++c)
{
if(*c == '\r' || *c == '\n')
{
if(!last_is_new_line)
{
for (const char* c = first; c != last; ++c) {
if (*c == '\r' || *c == '\n') {
if (!last_is_new_line) {
// Log this line.
if(this->Log && this->Prefix)
{
if (this->Log && this->Prefix) {
*this->Log << this->Prefix << this->Line << "\n";
}
// Hand this line to the subclass implementation.
if(!this->ProcessLine())
{
if (!this->ProcessLine()) {
this->Line = "";
return false;
}
@ -345,9 +315,7 @@ private:
this->Line = "";
last_is_new_line = true;
}
}
else
{
} else {
// Append this character to the line under construction.
this->Line.append(1, *c);
last_is_new_line = false;
@ -358,32 +326,29 @@ private:
bool ProcessLine()
{
if(this->RegexUpdate.find(this->Line))
{
if (this->RegexUpdate.find(this->Line)) {
this->DoPath(this->RegexUpdate.match(1)[0],
this->RegexUpdate.match(2)[0],
this->RegexUpdate.match(3)[0],
this->RegexUpdate.match(4));
this->RegexUpdate.match(3)[0], this->RegexUpdate.match(4));
}
return true;
}
void DoPath(char c0, char c1, char c2, std::string path)
{
if(path.empty()) return;
if (path.empty())
return;
cmSystemTools::ConvertToUnixSlashes(path);
const std::string dir = cmSystemTools::GetFilenamePath(path);
const std::string name = cmSystemTools::GetFilenameName(path);
if ( c0=='C' )
{
if (c0 == 'C') {
this->BZR->Dirs[dir][name].Status = PathConflicting;
return;
}
if ( c1=='M' || c1=='K' || c1=='N' || c1=='D' || c2 =='*' )
{
if (c1 == 'M' || c1 == 'K' || c1 == 'N' || c1 == 'D' || c2 == '*') {
this->BZR->Dirs[dir][name].Status = PathUpdated;
return;
}
@ -394,8 +359,7 @@ bool cmCTestBZR::UpdateImpl()
{
// Get user-specified update options.
std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
if(opts.empty())
{
if (opts.empty()) {
opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
}
std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
@ -407,9 +371,8 @@ bool cmCTestBZR::UpdateImpl()
bzr_update.push_back(this->CommandLineTool.c_str());
bzr_update.push_back("pull");
for(std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai)
{
for (std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai) {
bzr_update.push_back(ai->c_str());
}
@ -427,25 +390,24 @@ void cmCTestBZR::LoadRevisions()
{
cmCTestLog(this->CTest, HANDLER_OUTPUT,
" Gathering version information (one . per revision):\n"
" " << std::flush);
" "
<< std::flush);
// We are interested in every revision included in the update.
this->Revisions.clear();
std::string revs;
if(atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str()))
{
if (atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str())) {
// DoRevision takes care of discarding the information about OldRevision
revs = this->OldRevision + ".." + this->NewRevision;
}
else
{
} else {
return;
}
// Run "bzr log" to get all global revisions of interest.
const char* bzr = this->CommandLineTool.c_str();
const char* bzr_log[] = {bzr, "log", "-v", "-r", revs.c_str(), "--xml",
this->URL.c_str(), 0};
const char* bzr_log[] = {
bzr, "log", "-v", "-r", revs.c_str(), "--xml", this->URL.c_str(), 0
};
{
LogParser out(this, "log-out> ");
OutputLogger err(this->Log, "log-err> ");
@ -454,44 +416,42 @@ void cmCTestBZR::LoadRevisions()
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
class cmCTestBZR::StatusParser : public cmCTestVC::LineParser
{
public:
StatusParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
StatusParser(cmCTestBZR* bzr, const char* prefix)
: BZR(bzr)
{
this->SetLog(&bzr->Log, prefix);
this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
}
private:
cmCTestBZR* BZR;
cmsys::RegularExpression RegexStatus;
bool ProcessLine()
{
if(this->RegexStatus.find(this->Line))
{
if (this->RegexStatus.find(this->Line)) {
this->DoPath(this->RegexStatus.match(1)[0],
this->RegexStatus.match(2)[0],
this->RegexStatus.match(3)[0],
this->RegexStatus.match(4));
this->RegexStatus.match(3)[0], this->RegexStatus.match(4));
}
return true;
}
void DoPath(char c0, char c1, char c2, std::string path)
{
if(path.empty()) return;
if (path.empty())
return;
cmSystemTools::ConvertToUnixSlashes(path);
if ( c0=='C' )
{
if (c0 == 'C') {
this->BZR->DoModification(PathConflicting, path);
return;
}
if ( c0 == '+' || c0 == 'R' || c0 == 'P'
|| c1=='M' || c1=='K' || c1=='N' || c1=='D'
|| c2 =='*' )
{
if (c0 == '+' || c0 == 'R' || c0 == 'P' || c1 == 'M' || c1 == 'K' ||
c1 == 'N' || c1 == 'D' || c2 == '*') {
this->BZR->DoModification(PathModified, path);
return;
}
@ -502,7 +462,7 @@ void cmCTestBZR::LoadModifications()
{
// Run "bzr status" which reports local modifications.
const char* bzr = this->CommandLineTool.c_str();
const char* bzr_status[] = {bzr, "status", "-SV", 0};
const char* bzr_status[] = { bzr, "status", "-SV", 0 };
StatusParser out(this, "status-out> ");
OutputLogger err(this->Log, "status-err> ");
this->RunChild(bzr_status, &out, &err);

2
Source/CTest/cmCTestBZR.h
View File

@ -18,7 +18,7 @@
* \brief Interaction with bzr command-line tool
*
*/
class cmCTestBZR: public cmCTestGlobalVC
class cmCTestBZR : public cmCTestGlobalVC
{
public:
/** Construct with a CTest instance and update log stream. */

46
Source/CTest/cmCTestBatchTestHandler.cxx
View File

@ -30,14 +30,13 @@ void cmCTestBatchTestHandler::RunTests()
void cmCTestBatchTestHandler::WriteBatchScript()
{
this->Script = this->CTest->GetBinaryDir()
+ "/Testing/CTestBatch.txt";
this->Script = this->CTest->GetBinaryDir() + "/Testing/CTestBatch.txt";
cmsys::ofstream fout;
fout.open(this->Script.c_str());
fout << "#!/bin/sh\n";
for(TestMap::iterator i = this->Tests.begin(); i != this->Tests.end(); ++i)
{
for (TestMap::iterator i = this->Tests.begin(); i != this->Tests.end();
++i) {
this->WriteSrunArgs(i->first, fout);
this->WriteTestCommand(i->first, fout);
fout << "\n";
@ -52,10 +51,10 @@ void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
this->Properties[test];
fout << "srun ";
//fout << "--jobid=" << test << " ";
// fout << "--jobid=" << test << " ";
fout << "-J=" << properties->Name << " ";
//Write dependency information
// Write dependency information
/*if(!this->Tests[test].empty())
{
fout << "-P=afterany";
@ -66,12 +65,10 @@ void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
}
fout << " ";
}*/
if(properties->RunSerial)
{
if (properties->RunSerial) {
fout << "--exclusive ";
}
if(properties->Processors > 1)
{
if (properties->Processors > 1) {
fout << "-n" << properties->Processors << " ";
}
}
@ -85,36 +82,32 @@ void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout)
command = this->TestHandler->FindTheExecutable(args[1].c_str());
command = cmSystemTools::ConvertToOutputPath(command.c_str());
//Prepends memcheck args to our command string if this is a memcheck
// Prepends memcheck args to our command string if this is a memcheck
this->TestHandler->GenerateTestCommand(processArgs, test);
processArgs.push_back(command);
for(std::vector<std::string>::iterator arg = processArgs.begin();
arg != processArgs.end(); ++arg)
{
for (std::vector<std::string>::iterator arg = processArgs.begin();
arg != processArgs.end(); ++arg) {
fout << *arg << " ";
}
std::vector<std::string>::iterator i = args.begin();
++i; //the test name
++i; //the executable (command)
if(args.size() > 2)
{
++i; // the test name
++i; // the executable (command)
if (args.size() > 2) {
fout << "'";
}
while(i != args.end())
{
fout << "\"" << *i << "\""; //args to the test executable
while (i != args.end()) {
fout << "\"" << *i << "\""; // args to the test executable
++i;
if(i == args.end() && args.size() > 2)
{
if (i == args.end() && args.size() > 2) {
fout << "'";
}
fout << " ";
}
//TODO ZACH build TestResult.FullCommandLine
//this->TestResult.FullCommandLine = this->TestCommand;
// TODO ZACH build TestResult.FullCommandLine
// this->TestResult.FullCommandLine = this->TestCommand;
}
void cmCTestBatchTestHandler::SubmitBatchScript()
@ -123,8 +116,7 @@ void cmCTestBatchTestHandler::SubmitBatchScript()
std::vector<std::string> args;
args.push_back(this->Script);
args.push_back("-o");
args.push_back(this->CTest->GetBinaryDir()
+ "/Testing/CTestBatch.txt");
args.push_back(this->CTest->GetBinaryDir() + "/Testing/CTestBatch.txt");
sbatch.SetCommand("sbatch");
sbatch.SetCommandArguments(args);

1
Source/CTest/cmCTestBatchTestHandler.h
View File

@ -30,6 +30,7 @@ class cmCTestBatchTestHandler : public cmCTestMultiProcessHandler
public:
~cmCTestBatchTestHandler();
virtual void RunTests();
protected:
void WriteBatchScript();
void WriteSrunArgs(int test, cmsys::ofstream& fout);

288
Source/CTest/cmCTestBuildAndTestHandler.cxx
View File

@ -48,86 +48,70 @@ int cmCTestBuildAndTestHandler::ProcessHandler()
}
int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
std::ostringstream &out, std::string &cmakeOutString, std::string &cwd,
cmake *cm)
std::ostringstream& out,
std::string& cmakeOutString,
std::string& cwd, cmake* cm)
{
unsigned int k;
std::vector<std::string> args;
args.push_back(cmSystemTools::GetCMakeCommand());
args.push_back(this->SourceDir);
if(!this->BuildGenerator.empty())
{
if (!this->BuildGenerator.empty()) {
std::string generator = "-G";
generator += this->BuildGenerator;
args.push_back(generator);
}
if(!this->BuildGeneratorPlatform.empty())
{
if (!this->BuildGeneratorPlatform.empty()) {
std::string platform = "-A";
platform += this->BuildGeneratorPlatform;
args.push_back(platform);
}
if(!this->BuildGeneratorToolset.empty())
{
if (!this->BuildGeneratorToolset.empty()) {
std::string toolset = "-T";
toolset += this->BuildGeneratorToolset;
args.push_back(toolset);
}
const char* config = 0;
if (!this->CTest->GetConfigType().empty())
{
if (!this->CTest->GetConfigType().empty()) {
config = this->CTest->GetConfigType().c_str();
}
#ifdef CMAKE_INTDIR
if(!config)
{
if (!config) {
config = CMAKE_INTDIR;
}
#endif
if ( config )
{
std::string btype
= "-DCMAKE_BUILD_TYPE:STRING=" + std::string(config);
if (config) {
std::string btype = "-DCMAKE_BUILD_TYPE:STRING=" + std::string(config);
args.push_back(btype);
}
for(k=0; k < this->BuildOptions.size(); ++k)
{
for (k = 0; k < this->BuildOptions.size(); ++k) {
args.push_back(this->BuildOptions[k]);
}
if (cm->Run(args) != 0)
{
if (cm->Run(args) != 0) {
out << "Error: cmake execution failed\n";
out << cmakeOutString << "\n";
// return to the original directory
cmSystemTools::ChangeDirectory(cwd);
if(outstring)
{
if (outstring) {
*outstring = out.str();
}
else
{
} else {
cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
}
return 1;
}
// do another config?
if(this->BuildTwoConfig)
{
if (cm->Run(args) != 0)
{
if (this->BuildTwoConfig) {
if (cm->Run(args) != 0) {
out << "Error: cmake execution failed\n";
out << cmakeOutString << "\n";
// return to the original directory
cmSystemTools::ChangeDirectory(cwd);
if(outstring)
{
if (outstring) {
*outstring = out.str();
}
else
{
} else {
cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
}
return 1;
@ -146,7 +130,7 @@ void CMakeMessageCallback(const char* m, const char*, bool&, void* s)
*out += "\n";
}
void CMakeProgressCallback(const char*msg, float , void * s)
void CMakeProgressCallback(const char* msg, float, void* s)
{
std::string* out = (std::string*)s;
*out += msg;
@ -162,8 +146,10 @@ void CMakeOutputCallback(const char* m, size_t len, void* s)
class cmCTestBuildAndTestCaptureRAII
{
cmake& CM;
public:
cmCTestBuildAndTestCaptureRAII(cmake& cm, std::string& s): CM(cm)
cmCTestBuildAndTestCaptureRAII(cmake& cm, std::string& s)
: CM(cm)
{
cmSystemTools::SetMessageCallback(CMakeMessageCallback, &s);
cmSystemTools::SetStdoutCallback(CMakeOutputCallback, &s);
@ -182,12 +168,9 @@ public:
int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
{
// if the generator and make program are not specified then it is an error
if (this->BuildGenerator.empty())
{
if(outstring)
{
*outstring =
"--build-and-test requires that the generator "
if (this->BuildGenerator.empty()) {
if (outstring) {
*outstring = "--build-and-test requires that the generator "
"be provided using the --build-generator "
"command line option. ";
}
@ -202,26 +185,20 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
static_cast<void>(captureRAII);
std::ostringstream out;
if ( this->CTest->GetConfigType().empty() &&
!this->ConfigSample.empty())
{
if (this->CTest->GetConfigType().empty() && !this->ConfigSample.empty()) {
// use the config sample to set the ConfigType
std::string fullPath;
std::string resultingConfig;
std::vector<std::string> extraPaths;
std::vector<std::string> failed;
fullPath =
cmCTestTestHandler::FindExecutable(this->CTest,
this->ConfigSample.c_str(),
resultingConfig,
extraPaths,
fullPath = cmCTestTestHandler::FindExecutable(
this->CTest, this->ConfigSample.c_str(), resultingConfig, extraPaths,
failed);
if (!fullPath.empty() && !resultingConfig.empty())
{
if (!fullPath.empty() && !resultingConfig.empty()) {
this->CTest->SetConfigType(resultingConfig.c_str());
}
out << "Using config sample with results: "
<< fullPath << " and " << resultingConfig << std::endl;
out << "Using config sample with results: " << fullPath << " and "
<< resultingConfig << std::endl;
}
// we need to honor the timeout specified, the timeout include cmake, build
@ -230,51 +207,40 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
// make sure the binary dir is there
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
out << "Internal cmake changing into directory: "
<< this->BinaryDir << std::endl;
if (!cmSystemTools::FileIsDirectory(this->BinaryDir))
{
out << "Internal cmake changing into directory: " << this->BinaryDir
<< std::endl;
if (!cmSystemTools::FileIsDirectory(this->BinaryDir)) {
cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
}
cmSystemTools::ChangeDirectory(this->BinaryDir);
if(this->BuildNoCMake)
{
if (this->BuildNoCMake) {
// Make the generator available for the Build call below.
cm.SetGlobalGenerator(cm.CreateGlobalGenerator(
this->BuildGenerator));
cm.SetGlobalGenerator(cm.CreateGlobalGenerator(this->BuildGenerator));
cm.SetGeneratorPlatform(this->BuildGeneratorPlatform);
cm.SetGeneratorToolset(this->BuildGeneratorToolset);
// Load the cache to make CMAKE_MAKE_PROGRAM available.
cm.LoadCache(this->BinaryDir);
}
else
{
} else {
// do the cmake step, no timeout here since it is not a sub process
if (this->RunCMake(outstring,out,cmakeOutString,cwd,&cm))
{
if (this->RunCMake(outstring, out, cmakeOutString, cwd, &cm)) {
return 1;
}
}
// do the build
std::vector<std::string>::iterator tarIt;
if (this->BuildTargets.empty())
{
if (this->BuildTargets.empty()) {
this->BuildTargets.push_back("");
}
for ( tarIt = this->BuildTargets.begin();
tarIt != this->BuildTargets.end(); ++ tarIt )
{
for (tarIt = this->BuildTargets.begin(); tarIt != this->BuildTargets.end();
++tarIt) {
double remainingTime = 0;
if (this->Timeout > 0)
{
if (this->Timeout > 0) {
remainingTime = this->Timeout - cmSystemTools::GetTime() + clock_start;
if (remainingTime <= 0)
{
if(outstring)
{
if (remainingTime <= 0) {
if (outstring) {
*outstring = "--build-and-test timeout exceeded. ";
}
return 1;
@ -282,46 +248,36 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
}
std::string output;
const char* config = 0;
if (!this->CTest->GetConfigType().empty())
{
if (!this->CTest->GetConfigType().empty()) {
config = this->CTest->GetConfigType().c_str();
}
#ifdef CMAKE_INTDIR
if(!config)
{
if (!config) {
config = CMAKE_INTDIR;
}
#endif
if(!config)
{
if (!config) {
config = "Debug";
}
int retVal = cm.GetGlobalGenerator()->Build(
this->SourceDir, this->BinaryDir,
this->BuildProject, *tarIt,
output, this->BuildMakeProgram,
config,
!this->BuildNoClean,
false, false, remainingTime);
this->SourceDir, this->BinaryDir, this->BuildProject, *tarIt, output,
this->BuildMakeProgram, config, !this->BuildNoClean, false, false,
remainingTime);
out << output;
// if the build failed then return
if (retVal)
{
if(outstring)
{
if (retVal) {
if (outstring) {
*outstring = out.str();
}
return 1;
}
}
if(outstring)
{
if (outstring) {
*outstring = out.str();
}
// if no test was specified then we are done
if (this->TestCommand.empty())
{
if (this->TestCommand.empty()) {
return 0;
}
@ -331,8 +287,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
std::string resultingConfig;
std::vector<std::string> extraPaths;
// if this->ExecutableDirectory is set try that as well
if (!this->ExecutableDirectory.empty())
{
if (!this->ExecutableDirectory.empty()) {
std::string tempPath = this->ExecutableDirectory;
tempPath += "/";
tempPath += this->TestCommand;
@ -340,28 +295,20 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
}
std::vector<std::string> failed;
fullPath =
cmCTestTestHandler::FindExecutable(this->CTest,
this->TestCommand.c_str(),
resultingConfig,
extraPaths,
failed);
cmCTestTestHandler::FindExecutable(this->CTest, this->TestCommand.c_str(),
resultingConfig, extraPaths, failed);
if(!cmSystemTools::FileExists(fullPath.c_str()))
{
if (!cmSystemTools::FileExists(fullPath.c_str())) {
out << "Could not find path to executable, perhaps it was not built: "
<< this->TestCommand << "\n";
out << "tried to find it in these places:\n";
out << fullPath.c_str() << "\n";
for(unsigned int i=0; i < failed.size(); ++i)
{
for (unsigned int i = 0; i < failed.size(); ++i) {
out << failed[i] << "\n";
}
if(outstring)
{
if (outstring) {
*outstring = out.str();
}
else
{
} else {
cmCTestLog(this->CTest, ERROR_MESSAGE, out.str());
}
// return to the original directory
@ -371,57 +318,47 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
std::vector<const char*> testCommand;
testCommand.push_back(fullPath.c_str());
for(size_t k=0; k < this->TestCommandArgs.size(); ++k)
{
for (size_t k = 0; k < this->TestCommandArgs.size(); ++k) {
testCommand.push_back(this->TestCommandArgs[k].c_str());
}
testCommand.push_back(0);
std::string outs;
int retval = 0;
// run the test from the this->BuildRunDir if set
if(!this->BuildRunDir.empty())
{
if (!this->BuildRunDir.empty()) {
out << "Run test in directory: " << this->BuildRunDir << "\n";
cmSystemTools::ChangeDirectory(this->BuildRunDir);
}
out << "Running test command: \"" << fullPath << "\"";
for(size_t k=0; k < this->TestCommandArgs.size(); ++k)
{
for (size_t k = 0; k < this->TestCommandArgs.size(); ++k) {
out << " \"" << this->TestCommandArgs[k] << "\"";
}
out << "\n";
// how much time is remaining
double remainingTime = 0;
if (this->Timeout > 0)
{
if (this->Timeout > 0) {
remainingTime = this->Timeout - cmSystemTools::GetTime() + clock_start;
if (remainingTime <= 0)
{
if(outstring)
{
if (remainingTime <= 0) {
if (outstring) {
*outstring = "--build-and-test timeout exceeded. ";
}
return 1;
}
}
int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, 0,
remainingTime, 0);
int runTestRes =
this->CTest->RunTest(testCommand, &outs, &retval, 0, remainingTime, 0);
if(runTestRes != cmsysProcess_State_Exited || retval != 0)
{
if (runTestRes != cmsysProcess_State_Exited || retval != 0) {
out << "Test command failed: " << testCommand[0] << "\n";
retval = 1;
}
out << outs << "\n";
if(outstring)
{
if (outstring) {
*outstring = out.str();
}
else
{
} else {
cmCTestLog(this->CTest, OUTPUT, out.str() << std::endl);
}
return retval;
@ -432,114 +369,89 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
const std::vector<std::string>& allArgs)
{
// --build-and-test options
if(currentArg.find("--build-and-test",0) == 0 && idx < allArgs.size() - 1)
{
if(idx+2 < allArgs.size())
{
if (currentArg.find("--build-and-test", 0) == 0 &&
idx < allArgs.size() - 1) {
if (idx + 2 < allArgs.size()) {
idx++;
this->SourceDir = allArgs[idx];
idx++;
this->BinaryDir = allArgs[idx];
// dir must exist before CollapseFullPath is called
cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
this->BinaryDir
= cmSystemTools::CollapseFullPath(this->BinaryDir);
this->SourceDir
= cmSystemTools::CollapseFullPath(this->SourceDir);
}
else
{
this->BinaryDir = cmSystemTools::CollapseFullPath(this->BinaryDir);
this->SourceDir = cmSystemTools::CollapseFullPath(this->SourceDir);
} else {
cmCTestLog(this->CTest, ERROR_MESSAGE,
"--build-and-test must have source and binary dir" << std::endl);
"--build-and-test must have source and binary dir"
<< std::endl);
return 0;
}
}
if(currentArg.find("--build-target",0) == 0 && idx < allArgs.size() - 1)
{
if (currentArg.find("--build-target", 0) == 0 && idx < allArgs.size() - 1) {
idx++;
this->BuildTargets.push_back(allArgs[idx]);
}
if(currentArg.find("--build-nocmake",0) == 0)
{
if (currentArg.find("--build-nocmake", 0) == 0) {
this->BuildNoCMake = true;
}
if(currentArg.find("--build-run-dir",0) == 0 && idx < allArgs.size() - 1)
{
if (currentArg.find("--build-run-dir", 0) == 0 && idx < allArgs.size() - 1) {
idx++;
this->BuildRunDir = allArgs[idx];
}
if(currentArg.find("--build-two-config",0) == 0)
{
if (currentArg.find("--build-two-config", 0) == 0) {
this->BuildTwoConfig = true;
}
if(currentArg.find("--build-exe-dir",0) == 0 && idx < allArgs.size() - 1)
{
if (currentArg.find("--build-exe-dir", 0) == 0 && idx < allArgs.size() - 1) {
idx++;
this->ExecutableDirectory = allArgs[idx];
}
if(currentArg.find("--test-timeout",0) == 0 && idx < allArgs.size() - 1)
{
if (currentArg.find("--test-timeout", 0) == 0 && idx < allArgs.size() - 1) {
idx++;
this->Timeout = atof(allArgs[idx].c_str());
}
if(currentArg == "--build-generator" && idx < allArgs.size() - 1)
{
if (currentArg == "--build-generator" && idx < allArgs.size() - 1) {
idx++;
this->BuildGenerator = allArgs[idx];
}
if(currentArg == "--build-generator-platform" &&
idx < allArgs.size() - 1)
{
if (currentArg == "--build-generator-platform" && idx < allArgs.size() - 1) {
idx++;
this->BuildGeneratorPlatform = allArgs[idx];
}
if(currentArg == "--build-generator-toolset" &&
idx < allArgs.size() - 1)
{
if (currentArg == "--build-generator-toolset" && idx < allArgs.size() - 1) {
idx++;
this->BuildGeneratorToolset = allArgs[idx];
}
if(currentArg.find("--build-project",0) == 0 && idx < allArgs.size() - 1)
{
if (currentArg.find("--build-project", 0) == 0 && idx < allArgs.size() - 1) {
idx++;
this->BuildProject = allArgs[idx];
}
if(currentArg.find("--build-makeprogram",0) == 0 &&
idx < allArgs.size() - 1)
{
if (currentArg.find("--build-makeprogram", 0) == 0 &&
idx < allArgs.size() - 1) {
idx++;
this->BuildMakeProgram = allArgs[idx];
}
if(currentArg.find("--build-config-sample",0) == 0 &&
idx < allArgs.size() - 1)
{
if (currentArg.find("--build-config-sample", 0) == 0 &&
idx < allArgs.size() - 1) {
idx++;
this->ConfigSample = allArgs[idx];
}
if(currentArg.find("--build-noclean",0) == 0)
{
if (currentArg.find("--build-noclean", 0) == 0) {
this->BuildNoClean = true;
}
if(currentArg.find("--build-options",0) == 0)
{
while(idx+1 < allArgs.size() &&
allArgs[idx+1] != "--build-target" &&
allArgs[idx+1] != "--test-command")
{
if (currentArg.find("--build-options", 0) == 0) {
while (idx + 1 < allArgs.size() && allArgs[idx + 1] != "--build-target" &&
allArgs[idx + 1] != "--test-command") {
++idx;
this->BuildOptions.push_back(allArgs[idx]);
}
}
if(currentArg.find("--test-command",0) == 0 && idx < allArgs.size() - 1)
{
if (currentArg.find("--test-command", 0) == 0 && idx < allArgs.size() - 1) {
++idx;
this->TestCommand = allArgs[idx];
while(idx+1 < allArgs.size())
{
while (idx + 1 < allArgs.size()) {
++idx;
this->TestCommandArgs.push_back(allArgs[idx]);
}
}
return 1;
}

7
Source/CTest/cmCTestBuildAndTestHandler.h
View File

@ -13,7 +13,6 @@
#ifndef cmCTestBuildAndTestHandler_h
#define cmCTestBuildAndTestHandler_h
#include "cmCTestGenericHandler.h"
#include "cmListFileCache.h"
@ -50,9 +49,8 @@ public:
protected:
///! Run CMake and build a test and then run it as a single test.
int RunCMakeAndTest(std::string* output);
int RunCMake(std::string* outstring, std::ostringstream &out,
std::string &cmakeOutString,
std::string &cwd, cmake *cm);
int RunCMake(std::string* outstring, std::ostringstream& out,
std::string& cmakeOutString, std::string& cwd, cmake* cm);
std::string Output;
@ -77,4 +75,3 @@ protected:
};
#endif

109
Source/CTest/cmCTestBuildCommand.cxx
View File

@ -17,7 +17,6 @@
#include "cmGlobalGenerator.h"
#include "cmake.h"
cmCTestBuildCommand::cmCTestBuildCommand()
{
this->GlobalGenerator = 0;
@ -33,8 +32,7 @@ cmCTestBuildCommand::cmCTestBuildCommand()
cmCTestBuildCommand::~cmCTestBuildCommand()
{
if ( this->GlobalGenerator )
{
if (this->GlobalGenerator) {
delete this->GlobalGenerator;
this->GlobalGenerator = 0;
}
@ -42,28 +40,23 @@ cmCTestBuildCommand::~cmCTestBuildCommand()
cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
{
cmCTestGenericHandler* handler
= this->CTest->GetInitializedHandler("build");
if ( !handler )
{
cmCTestGenericHandler* handler = this->CTest->GetInitializedHandler("build");
if (!handler) {
this->SetError("internal CTest error. Cannot instantiate build handler");
return 0;
}
this->Handler = (cmCTestBuildHandler*)handler;
const char* ctestBuildCommand
= this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
if ( ctestBuildCommand && *ctestBuildCommand )
{
const char* ctestBuildCommand =
this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
if (ctestBuildCommand && *ctestBuildCommand) {
this->CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand,
this->Quiet);
}
else
{
const char* cmakeGeneratorName
= this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
const char* cmakeProjectName
= (this->Values[ctb_PROJECT_NAME] && *this->Values[ctb_PROJECT_NAME])
} else {
const char* cmakeGeneratorName =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
const char* cmakeProjectName =
(this->Values[ctb_PROJECT_NAME] && *this->Values[ctb_PROJECT_NAME])
? this->Values[ctb_PROJECT_NAME]
: this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
@ -72,46 +65,40 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
// CTEST_CONFIGURATION_TYPE script variable, or ctest -C command
// line argument... in that order.
//
const char* ctestBuildConfiguration
= this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
const char* cmakeBuildConfiguration
= (this->Values[ctb_CONFIGURATION] && *this->Values[ctb_CONFIGURATION])
const char* ctestBuildConfiguration =
this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
const char* cmakeBuildConfiguration =
(this->Values[ctb_CONFIGURATION] && *this->Values[ctb_CONFIGURATION])
? this->Values[ctb_CONFIGURATION]
: ((ctestBuildConfiguration && *ctestBuildConfiguration)
? ctestBuildConfiguration
: this->CTest->GetConfigType().c_str());
const char* cmakeBuildAdditionalFlags
= (this->Values[ctb_FLAGS] && *this->Values[ctb_FLAGS])
const char* cmakeBuildAdditionalFlags =
(this->Values[ctb_FLAGS] && *this->Values[ctb_FLAGS])
? this->Values[ctb_FLAGS]
: this->Makefile->GetDefinition("CTEST_BUILD_FLAGS");
const char* cmakeBuildTarget
= (this->Values[ctb_TARGET] && *this->Values[ctb_TARGET])
const char* cmakeBuildTarget =
(this->Values[ctb_TARGET] && *this->Values[ctb_TARGET])
? this->Values[ctb_TARGET]
: this->Makefile->GetDefinition("CTEST_BUILD_TARGET");
if ( cmakeGeneratorName && *cmakeGeneratorName &&
cmakeProjectName && *cmakeProjectName )
{
if ( !cmakeBuildConfiguration )
{
if (cmakeGeneratorName && *cmakeGeneratorName && cmakeProjectName &&
*cmakeProjectName) {
if (!cmakeBuildConfiguration) {
cmakeBuildConfiguration = "Release";
}
if ( this->GlobalGenerator )
{
if ( this->GlobalGenerator->GetName() != cmakeGeneratorName )
{
if (this->GlobalGenerator) {
if (this->GlobalGenerator->GetName() != cmakeGeneratorName) {
delete this->GlobalGenerator;
this->GlobalGenerator = 0;
}
}
if ( !this->GlobalGenerator )
{
if (!this->GlobalGenerator) {
this->GlobalGenerator =
this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
cmakeGeneratorName);
if(!this->GlobalGenerator)
{
if (!this->GlobalGenerator) {
std::string e = "could not create generator named \"";
e += cmakeGeneratorName;
e += "\"";
@ -120,33 +107,29 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
return 0;
}
}
if(strlen(cmakeBuildConfiguration) == 0)
{
if (strlen(cmakeBuildConfiguration) == 0) {
const char* config = 0;
#ifdef CMAKE_INTDIR
config = CMAKE_INTDIR;
#endif
if(!config)
{
if (!config) {
config = "Debug";
}
cmakeBuildConfiguration = config;
}
std::string dir = this->CTest->GetCTestConfiguration("BuildDirectory");
std::string buildCommand
= this->GlobalGenerator->
GenerateCMakeBuildCommand(cmakeBuildTarget ? cmakeBuildTarget : "",
cmakeBuildConfiguration,
std::string buildCommand =
this->GlobalGenerator->GenerateCMakeBuildCommand(
cmakeBuildTarget ? cmakeBuildTarget : "", cmakeBuildConfiguration,
cmakeBuildAdditionalFlags ? cmakeBuildAdditionalFlags : "",
this->Makefile->IgnoreErrorsCMP0061());
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"SetMakeCommand:" << buildCommand << "\n", this->Quiet);
"SetMakeCommand:" << buildCommand << "\n",
this->Quiet);
this->CTest->SetCTestConfiguration("MakeCommand", buildCommand.c_str(),
this->Quiet);
}
else
{
} else {
std::ostringstream ostr;
/* clang-format off */
ostr << "has no project to build. If this is a "
@ -166,9 +149,8 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
}
}
if(const char* useLaunchers =
this->Makefile->GetDefinition("CTEST_USE_LAUNCHERS"))
{
if (const char* useLaunchers =
this->Makefile->GetDefinition("CTEST_USE_LAUNCHERS")) {
this->CTest->SetCTestConfiguration("UseLaunchers", useLaunchers,
this->Quiet);
}
@ -177,25 +159,22 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
return handler;
}
bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus &status)
cmExecutionStatus& status)
{
bool ret = cmCTestHandlerCommand::InitialPass(args, status);
if ( this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS])
{
if (this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS]) {
std::ostringstream str;
str << this->Handler->GetTotalErrors();
this->Makefile->AddDefinition(
this->Values[ctb_NUMBER_ERRORS], str.str().c_str());
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS],
str.str().c_str());
}
if ( this->Values[ctb_NUMBER_WARNINGS]
&& *this->Values[ctb_NUMBER_WARNINGS])
{
if (this->Values[ctb_NUMBER_WARNINGS] &&
*this->Values[ctb_NUMBER_WARNINGS]) {
std::ostringstream str;
str << this->Handler->GetTotalWarnings();
this->Makefile->AddDefinition(
this->Values[ctb_NUMBER_WARNINGS], str.str().c_str());
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS],
str.str().c_str());
}
return ret;
}

9
Source/CTest/cmCTestBuildCommand.h
View File

@ -25,7 +25,6 @@ class cmCTestBuildHandler;
class cmCTestBuildCommand : public cmCTestHandlerCommand
{
public:
cmCTestBuildCommand();
~cmCTestBuildCommand();
@ -43,10 +42,10 @@ public:
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual std::string GetName() const { return "ctest_build";}
virtual std::string GetName() const { return "ctest_build"; }
virtual bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus &status);
cmExecutionStatus& status);
cmTypeMacro(cmCTestBuildCommand, cmCTestHandlerCommand);
@ -54,7 +53,8 @@ public:
protected:
cmCTestBuildHandler* Handler;
enum {
enum
{
ctb_BUILD = ct_LAST,
ctb_NUMBER_ERRORS,
ctb_NUMBER_WARNINGS,
@ -68,5 +68,4 @@ protected:
cmCTestGenericHandler* InitializeHandler();
};
#endif

669
Source/CTest/cmCTestBuildHandler.cxx
View File

File diff suppressed because it is too large Load Diff

17
Source/CTest/cmCTestBuildHandler.h
View File

@ -40,26 +40,26 @@ public:
cmCTestBuildHandler();
void PopulateCustomVectors(cmMakefile *mf);
void PopulateCustomVectors(cmMakefile* mf);
/**
* Initialize handler
*/
virtual void Initialize();
int GetTotalErrors() { return this->TotalErrors;}
int GetTotalWarnings() { return this->TotalWarnings;}
int GetTotalErrors() { return this->TotalErrors; }
int GetTotalWarnings() { return this->TotalWarnings; }
private:
std::string GetMakeCommand();
//! Run command specialized for make and configure. Returns process status
// and retVal is return value or exception.
int RunMakeCommand(const char* command,
int* retVal, const char* dir, int timeout,
std::ostream& ofs);
int RunMakeCommand(const char* command, int* retVal, const char* dir,
int timeout, std::ostream& ofs);
enum {
enum
{
b_REGULAR_LINE,
b_WARNING_LINE,
b_ERROR_LINE
@ -115,7 +115,8 @@ private:
typedef std::deque<char> t_BuildProcessingQueueType;
void ProcessBuffer(const char* data, int length, size_t& tick,
size_t tick_len, std::ostream& ofs, t_BuildProcessingQueueType* queue);
size_t tick_len, std::ostream& ofs,
t_BuildProcessingQueueType* queue);
int ProcessSingleLine(const char* data);
t_BuildProcessingQueueType BuildProcessingQueue;

142
Source/CTest/cmCTestCVS.cxx
View File

@ -18,7 +18,8 @@
#include <cmsys/FStream.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)
{
}
@ -26,10 +27,11 @@ cmCTestCVS::~cmCTestCVS()
{
}
class cmCTestCVS::UpdateParser: public cmCTestVC::LineParser
class cmCTestCVS::UpdateParser : public cmCTestVC::LineParser
{
public:
UpdateParser(cmCTestCVS* cvs, const char* prefix): CVS(cvs)
UpdateParser(cmCTestCVS* cvs, const char* prefix)
: CVS(cvs)
{
this->SetLog(&cvs->Log, prefix);
// See "man cvs", section "update output".
@ -42,6 +44,7 @@ public:
"cvs[^ ]* update: "
"warning: `?([^']*)'? is not \\(any longer\\) pertinent");
}
private:
cmCTestCVS* CVS;
cmsys::RegularExpression RegexFileUpdated;
@ -52,24 +55,15 @@ private:
virtual bool ProcessLine()
{
if(this->RegexFileUpdated.find(this->Line))
{
if (this->RegexFileUpdated.find(this->Line)) {
this->DoFile(PathUpdated, this->RegexFileUpdated.match(2));
}
else if(this->RegexFileModified.find(this->Line))
{
} else if (this->RegexFileModified.find(this->Line)) {
this->DoFile(PathModified, this->RegexFileModified.match(2));
}
else if(this->RegexFileConflicting.find(this->Line))
{
} else if (this->RegexFileConflicting.find(this->Line)) {
this->DoFile(PathConflicting, this->RegexFileConflicting.match(2));
}
else if(this->RegexFileRemoved1.find(this->Line))
{
} else if (this->RegexFileRemoved1.find(this->Line)) {
this->DoFile(PathUpdated, this->RegexFileRemoved1.match(1));
}
else if(this->RegexFileRemoved2.find(this->Line))
{
} else if (this->RegexFileRemoved2.find(this->Line)) {
this->DoFile(PathUpdated, this->RegexFileRemoved2.match(1));
}
return true;
@ -87,19 +81,16 @@ bool cmCTestCVS::UpdateImpl()
{
// Get user-specified update options.
std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
if(opts.empty())
{
if (opts.empty()) {
opts = this->CTest->GetCTestConfiguration("CVSUpdateOptions");
if(opts.empty())
{
if (opts.empty()) {
opts = "-dP";
}
}
std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
// Specify the start time for nightly testing.
if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
{
if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
args.push_back("-D" + this->GetNightlyTime() + " UTC");
}
@ -108,9 +99,8 @@ bool cmCTestCVS::UpdateImpl()
cvs_update.push_back(this->CommandLineTool.c_str());
cvs_update.push_back("-z3");
cvs_update.push_back("update");
for(std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai)
{
for (std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai) {
cvs_update.push_back(ai->c_str());
}
cvs_update.push_back(0);
@ -120,71 +110,65 @@ bool cmCTestCVS::UpdateImpl()
return this->RunUpdateCommand(&cvs_update[0], &out, &err);
}
class cmCTestCVS::LogParser: public cmCTestVC::LineParser
class cmCTestCVS::LogParser : public cmCTestVC::LineParser
{
public:
typedef cmCTestCVS::Revision Revision;
LogParser(cmCTestCVS* cvs, const char* prefix, std::vector<Revision>& revs):
CVS(cvs), Revisions(revs), Section(SectionHeader)
LogParser(cmCTestCVS* cvs, const char* prefix, std::vector<Revision>& revs)
: CVS(cvs)
, Revisions(revs)
, Section(SectionHeader)
{
this->SetLog(&cvs->Log, prefix),
this->RegexRevision.compile("^revision +([^ ]*) *$");
this->RegexBranches.compile("^branches: .*$");
this->RegexPerson.compile("^date: +([^;]+); +author: +([^;]+);");
}
private:
cmCTestCVS* CVS;
std::vector<Revision>& Revisions;
cmsys::RegularExpression RegexRevision;
cmsys::RegularExpression RegexBranches;
cmsys::RegularExpression RegexPerson;
enum SectionType { SectionHeader, SectionRevisions, SectionEnd };
enum SectionType
{
SectionHeader,
SectionRevisions,
SectionEnd
};
SectionType Section;
Revision Rev;
virtual bool ProcessLine()
{
if(this->Line == ("======================================="
"======================================"))
{
if (this->Line == ("======================================="
"======================================")) {
// This line ends the revision list.
if(this->Section == SectionRevisions)
{
if (this->Section == SectionRevisions) {
this->FinishRevision();
}
this->Section = SectionEnd;
}
else if(this->Line == "----------------------------")
{
} else if (this->Line == "----------------------------") {
// This line divides revisions from the header and each other.
if(this->Section == SectionHeader)
{
if (this->Section == SectionHeader) {
this->Section = SectionRevisions;
}
else if(this->Section == SectionRevisions)
{
} else if (this->Section == SectionRevisions) {
this->FinishRevision();
}
}
else if(this->Section == SectionRevisions)
{
if(!this->Rev.Log.empty())
{
} else if (this->Section == SectionRevisions) {
if (!this->Rev.Log.empty()) {
// Continue the existing log.
this->Rev.Log += this->Line;
this->Rev.Log += "\n";
}
else if(this->Rev.Rev.empty() && this->RegexRevision.find(this->Line))
{
} else if (this->Rev.Rev.empty() &&
this->RegexRevision.find(this->Line)) {
this->Rev.Rev = this->RegexRevision.match(1);
}
else if(this->Rev.Date.empty() && this->RegexPerson.find(this->Line))
{
} else if (this->Rev.Date.empty() &&
this->RegexPerson.find(this->Line)) {
this->Rev.Date = this->RegexPerson.match(1);
this->Rev.Author = this->RegexPerson.match(2);
}
else if(!this->RegexBranches.find(this->Line))
{
} else if (!this->RegexBranches.find(this->Line)) {
// Start the log.
this->Rev.Log += this->Line;
this->Rev.Log += "\n";
@ -195,8 +179,7 @@ private:
void FinishRevision()
{
if(!this->Rev.Rev.empty())
{
if (!this->Rev.Rev.empty()) {
// Record this revision.
/* clang-format off */
this->CVS->Log << "Found revision " << this->Rev.Rev << "\n"
@ -206,8 +189,7 @@ private:
this->Revisions.push_back(this->Rev);
// We only need two revisions.
if(this->Revisions.size() >= 2)
{
if (this->Revisions.size() >= 2) {
this->Section = SectionEnd;
}
}
@ -219,8 +201,7 @@ std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir)
{
// Compute the tag file location for this directory.
std::string tagFile = this->SourceDirectory;
if(!dir.empty())
{
if (!dir.empty()) {
tagFile += "/";
tagFile += dir;
}
@ -229,42 +210,36 @@ std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir)
// Lookup the branch in the tag file, if any.
std::string tagLine;
cmsys::ifstream tagStream(tagFile.c_str());
if(tagStream && cmSystemTools::GetLineFromStream(tagStream, tagLine) &&
tagLine.size() > 1 && tagLine[0] == 'T')
{
if (tagStream && cmSystemTools::GetLineFromStream(tagStream, tagLine) &&
tagLine.size() > 1 && tagLine[0] == 'T') {
// Use the branch specified in the tag file.
std::string flag = "-r";
flag += tagLine.substr(1);
return flag;
}
else
{
} else {
// Use the default branch.
return "-b";
}
}
void cmCTestCVS::LoadRevisions(std::string const& file,
const char* branchFlag,
void cmCTestCVS::LoadRevisions(std::string const& file, const char* branchFlag,
std::vector<Revision>& revisions)
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
// Run "cvs log" to get revisions of this file on this branch.
const char* cvs = this->CommandLineTool.c_str();
const char* cvs_log[] =
{cvs, "log", "-N", branchFlag, file.c_str(), 0};
const char* cvs_log[] = { cvs, "log", "-N", branchFlag, file.c_str(), 0 };
LogParser out(this, "log-out> ", revisions);
OutputLogger err(this->Log, "log-err> ");
this->RunChild(cvs_log, &out, &err);
}
void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml,
std::string const& path,
void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml, std::string const& path,
Directory const& dir)
{
const char* slash = path.empty()? "":"/";
const char* slash = path.empty() ? "" : "/";
xml.StartElement("Directory");
xml.Element("Name", path);
@ -273,14 +248,12 @@ void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml,
// Load revisions and write an entry for each file in this directory.
std::vector<Revision> revisions;
for(Directory::const_iterator fi = dir.begin(); fi != dir.end(); ++fi)
{
for (Directory::const_iterator fi = dir.begin(); fi != dir.end(); ++fi) {
std::string full = path + slash + fi->first;
// Load two real or unknown revisions.
revisions.clear();
if(fi->second != PathUpdated)
{
if (fi->second != PathUpdated) {
// For local modifications the current rev is unknown and the
// prior rev is the latest from cvs.
revisions.push_back(this->Unknown);
@ -299,11 +272,12 @@ bool cmCTestCVS::WriteXMLUpdates(cmXMLWriter& xml)
{
cmCTestLog(this->CTest, HANDLER_OUTPUT,
" Gathering version information (one . per updated file):\n"
" " << std::flush);
" "
<< std::flush);
for(std::map<std::string, Directory>::const_iterator
di = this->Dirs.begin(); di != this->Dirs.end(); ++di)
{
for (std::map<std::string, Directory>::const_iterator di =
this->Dirs.begin();
di != this->Dirs.end(); ++di) {
this->WriteXMLDirectory(xml, di->first, di->second);
}

6
Source/CTest/cmCTestCVS.h
View File

@ -18,7 +18,7 @@
* \brief Interaction with cvs command-line tool
*
*/
class cmCTestCVS: public cmCTestVC
class cmCTestCVS : public cmCTestVC
{
public:
/** Construct with a CTest instance and update log stream. */
@ -32,7 +32,9 @@ private:
virtual bool WriteXMLUpdates(cmXMLWriter& xml);
// Update status for files in each directory.
class Directory: public std::map<std::string, PathStatus> {};
class Directory : public std::map<std::string, PathStatus>
{
};
std::map<std::string, Directory> Dirs;
std::string ComputeBranchFlag(std::string const& dir);

12
Source/CTest/cmCTestCommand.h
View File

@ -27,14 +27,16 @@ class cmCTestScriptHandler;
class cmCTestCommand : public cmCommand
{
public:
cmCTestCommand()
{
this->CTest = 0;
this->CTestScriptHandler = 0;
}
cmCTestCommand() {this->CTest = 0; this->CTestScriptHandler = 0;}
cmCTest *CTest;
cmCTestScriptHandler *CTestScriptHandler;
cmCTest* CTest;
cmCTestScriptHandler* CTestScriptHandler;
cmTypeMacro(cmCTestCommand, cmCommand);
};
#endif

81
Source/CTest/cmCTestConfigureCommand.cxx
View File

@ -26,49 +26,42 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
{
std::vector<std::string> options;
if (this->Values[ctc_OPTIONS])
{
if (this->Values[ctc_OPTIONS]) {
cmSystemTools::ExpandListArgument(this->Values[ctc_OPTIONS], options);
}
if ( this->CTest->GetCTestConfiguration("BuildDirectory").empty() )
{
this->SetError("Build directory not specified. Either use BUILD "
if (this->CTest->GetCTestConfiguration("BuildDirectory").empty()) {
this->SetError(
"Build directory not specified. Either use BUILD "
"argument to CTEST_CONFIGURE command or set CTEST_BINARY_DIRECTORY "
"variable");
return 0;
}
const char* ctestConfigureCommand
= this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
const char* ctestConfigureCommand =
this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
if ( ctestConfigureCommand && *ctestConfigureCommand )
{
if (ctestConfigureCommand && *ctestConfigureCommand) {
this->CTest->SetCTestConfiguration("ConfigureCommand",
ctestConfigureCommand, this->Quiet);
}
else
{
const char* cmakeGeneratorName
= this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
if ( cmakeGeneratorName && *cmakeGeneratorName )
{
const std::string& source_dir
= this->CTest->GetCTestConfiguration("SourceDirectory");
if ( source_dir.empty() )
{
this->SetError("Source directory not specified. Either use SOURCE "
} else {
const char* cmakeGeneratorName =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
if (cmakeGeneratorName && *cmakeGeneratorName) {
const std::string& source_dir =
this->CTest->GetCTestConfiguration("SourceDirectory");
if (source_dir.empty()) {
this->SetError(
"Source directory not specified. Either use SOURCE "
"argument to CTEST_CONFIGURE command or set CTEST_SOURCE_DIRECTORY "
"variable");
return 0;
}
const std::string cmakelists_file = source_dir + "/CMakeLists.txt";
if ( !cmSystemTools::FileExists(cmakelists_file.c_str()) )
{
if (!cmSystemTools::FileExists(cmakelists_file.c_str())) {
std::ostringstream e;
e << "CMakeLists.txt file does not exist ["
<< cmakelists_file << "]";
e << "CMakeLists.txt file does not exist [" << cmakelists_file << "]";
this->SetError(e.str());
return 0;
}
@ -76,11 +69,10 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
bool multiConfig = false;
bool cmakeBuildTypeInOptions = false;
cmGlobalGenerator *gg =
cmGlobalGenerator* gg =
this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
cmakeGeneratorName);
if(gg)
{
if (gg) {
multiConfig = gg->IsMultiConfig();
delete gg;
}
@ -91,8 +83,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
std::vector<std::string>::const_iterator it;
std::string option;
for (it= options.begin(); it!=options.end(); ++it)
{
for (it = options.begin(); it != options.end(); ++it) {
option = *it;
cmakeConfigureCommand += " \"";
@ -100,15 +91,13 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
cmakeConfigureCommand += "\"";
if ((0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE=")) ||
(0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING=")))
{
(0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING="))) {
cmakeBuildTypeInOptions = true;
}
}
if (!multiConfig && !cmakeBuildTypeInOptions &&
!this->CTest->GetConfigType().empty())
{
!this->CTest->GetConfigType().empty()) {
cmakeConfigureCommand += " \"-DCMAKE_BUILD_TYPE:STRING=";
cmakeConfigureCommand += this->CTest->GetConfigType();
cmakeConfigureCommand += "\"";
@ -120,8 +109,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
const char* cmakeGeneratorPlatform =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_PLATFORM");
if(cmakeGeneratorPlatform && *cmakeGeneratorPlatform)
{
if (cmakeGeneratorPlatform && *cmakeGeneratorPlatform) {
cmakeConfigureCommand += " \"-A";
cmakeConfigureCommand += cmakeGeneratorPlatform;
cmakeConfigureCommand += "\"";
@ -129,8 +117,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
const char* cmakeGeneratorToolset =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_TOOLSET");
if(cmakeGeneratorToolset && *cmakeGeneratorToolset)
{
if (cmakeGeneratorToolset && *cmakeGeneratorToolset) {
cmakeConfigureCommand += " \"-T";
cmakeConfigureCommand += cmakeGeneratorToolset;
cmakeConfigureCommand += "\"";
@ -140,22 +127,20 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
cmakeConfigureCommand += source_dir;
cmakeConfigureCommand += "\"";
this->CTest->SetCTestConfiguration("ConfigureCommand",
cmakeConfigureCommand.c_str(), this->Quiet);
}
else
{
this->SetError("Configure command is not specified. If this is a "
this->CTest->SetCTestConfiguration(
"ConfigureCommand", cmakeConfigureCommand.c_str(), this->Quiet);
} else {
this->SetError(
"Configure command is not specified. If this is a "
"\"built with CMake\" project, set CTEST_CMAKE_GENERATOR. If not, "
"set CTEST_CONFIGURE_COMMAND.");
return 0;
}
}
cmCTestGenericHandler* handler
= this->CTest->GetInitializedHandler("configure");
if ( !handler )
{
cmCTestGenericHandler* handler =
this->CTest->GetInitializedHandler("configure");
if (!handler) {
this->SetError(
"internal CTest error. Cannot instantiate configure handler");
return 0;

6
Source/CTest/cmCTestConfigureCommand.h
View File

@ -38,19 +38,19 @@ public:
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual std::string GetName() const { return "ctest_configure";}
virtual std::string GetName() const { return "ctest_configure"; }
cmTypeMacro(cmCTestConfigureCommand, cmCTestHandlerCommand);
protected:
cmCTestGenericHandler* InitializeHandler();
enum {
enum
{
ctc_FIRST = ct_LAST,
ctc_OPTIONS,
ctc_LAST
};
};
#endif

59
Source/CTest/cmCTestConfigureHandler.cxx
View File

@ -18,7 +18,6 @@
#include "cmake.h"
#include <cmsys/Process.h>
cmCTestConfigureHandler::cmCTestConfigureHandler()
{
}
@ -28,26 +27,24 @@ void cmCTestConfigureHandler::Initialize()
this->Superclass::Initialize();
}
//clearly it would be nice if this were broken up into a few smaller
//functions and commented...
// clearly it would be nice if this were broken up into a few smaller
// functions and commented...
int cmCTestConfigureHandler::ProcessHandler()
{
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
"Configure project" << std::endl, this->Quiet);
std::string cCommand
= this->CTest->GetCTestConfiguration("ConfigureCommand");
if (cCommand.empty())
{
std::string cCommand =
this->CTest->GetCTestConfiguration("ConfigureCommand");
if (cCommand.empty()) {
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Cannot find ConfigureCommand key in the DartConfiguration.tcl"
<< std::endl);
return -1;
}
std::string buildDirectory
= this->CTest->GetCTestConfiguration("BuildDirectory");
if (buildDirectory.empty())
{
std::string buildDirectory =
this->CTest->GetCTestConfiguration("BuildDirectory");
if (buildDirectory.empty()) {
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Cannot find BuildDirectory key in the DartConfiguration.tcl"
<< std::endl);
@ -58,34 +55,30 @@ int cmCTestConfigureHandler::ProcessHandler()
std::string output;
int retVal = 0;
int res = 0;
if ( !this->CTest->GetShowOnly() )
{
if (!this->CTest->GetShowOnly()) {
cmGeneratedFileStream os;
if(!this->StartResultingXML(cmCTest::PartConfigure, "Configure", os))
{
if (!this->StartResultingXML(cmCTest::PartConfigure, "Configure", os)) {
cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open configure file"
<< std::endl);
return 1;
}
std::string start_time = this->CTest->CurrentTime();
unsigned int start_time_time = static_cast<unsigned int>(
cmSystemTools::GetTime());
unsigned int start_time_time =
static_cast<unsigned int>(cmSystemTools::GetTime());
cmGeneratedFileStream ofs;
this->StartLogFile("Configure", ofs);
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Configure with command: " << cCommand << std::endl, this->Quiet);
res = this->CTest->RunMakeCommand(cCommand.c_str(), output,
&retVal, buildDirectory.c_str(),
0, ofs);
"Configure with command: " << cCommand << std::endl,
this->Quiet);
res = this->CTest->RunMakeCommand(cCommand.c_str(), output, &retVal,
buildDirectory.c_str(), 0, ofs);
if ( ofs )
{
if (ofs) {
ofs.close();
}
if ( os )
{
if (os) {
cmXMLWriter xml(os);
this->CTest->StartXML(xml, this->AppendXML);
xml.StartElement("Configure");
@ -98,19 +91,19 @@ int cmCTestConfigureHandler::ProcessHandler()
xml.Element("EndDateTime", this->CTest->CurrentTime());
xml.Element("EndConfigureTime",
static_cast<unsigned int>(cmSystemTools::GetTime()));
xml.Element("ElapsedMinutes", static_cast<int>(
(cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
xml.Element(
"ElapsedMinutes",
static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
10.0);
xml.EndElement(); // Configure
this->CTest->EndXML(xml);
}
}
else
{
} else {
cmCTestOptionalLog(this->CTest, DEBUG,
"Configure with command: " << cCommand << std::endl, this->Quiet);
"Configure with command: " << cCommand << std::endl,
this->Quiet);
}
if (! res || retVal )
{
if (!res || retVal) {
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Error(s) when configuring the project" << std::endl);
return -1;

21
Source/CTest/cmCTestCoverageCommand.cxx
View File

@ -21,21 +21,20 @@ cmCTestCoverageCommand::cmCTestCoverageCommand()
cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
{
this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
"CoverageCommand", "CTEST_COVERAGE_COMMAND", this->Quiet);
this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
"CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS", this->Quiet);
this->CTest->SetCTestConfigurationFromCMakeVariable(
this->Makefile, "CoverageCommand", "CTEST_COVERAGE_COMMAND", this->Quiet);
this->CTest->SetCTestConfigurationFromCMakeVariable(
this->Makefile, "CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS",
this->Quiet);
cmCTestCoverageHandler* handler = static_cast<cmCTestCoverageHandler*>(
this->CTest->GetInitializedHandler("coverage"));
if ( !handler )
{
if (!handler) {
this->SetError("internal CTest error. Cannot instantiate test handler");
return 0;
}
// If a LABELS option was given, select only files with the labels.
if(this->LabelsMentioned)
{
if (this->LabelsMentioned) {
handler->SetLabelFilter(this->Labels);
}
@ -46,8 +45,7 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
{
// Look for arguments specific to this command.
if(arg == "LABELS")
{
if (arg == "LABELS") {
this->ArgumentDoing = ArgumentDoingLabels;
this->LabelsMentioned = true;
return true;
@ -60,8 +58,7 @@ bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
bool cmCTestCoverageCommand::CheckArgumentValue(std::string const& arg)
{
// Handle states specific to this command.
if(this->ArgumentDoing == ArgumentDoingLabels)
{
if (this->ArgumentDoing == ArgumentDoingLabels) {
this->Labels.insert(arg);
return true;
}

5
Source/CTest/cmCTestCoverageCommand.h
View File

@ -22,7 +22,6 @@
class cmCTestCoverageCommand : public cmCTestHandlerCommand
{
public:
cmCTestCoverageCommand();
/**
@ -39,7 +38,7 @@ public:
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual std::string GetName() const { return "ctest_coverage";}
virtual std::string GetName() const { return "ctest_coverage"; }
cmTypeMacro(cmCTestCoverageCommand, cmCTestHandlerCommand);
@ -59,6 +58,4 @@ protected:
std::set<std::string> Labels;
};
#endif

1580
Source/CTest/cmCTestCoverageHandler.cxx
View File

File diff suppressed because it is too large Load Diff

30
Source/CTest/cmCTestCoverageHandler.h
View File

@ -54,7 +54,7 @@ public:
/**
* This method is called when reading CTest custom file
*/
void PopulateCustomVectors(cmMakefile *mf);
void PopulateCustomVectors(cmMakefile* mf);
/** Report coverage only for sources with these labels. */
void SetLabelFilter(std::set<std::string> const& labels);
@ -95,7 +95,7 @@ private:
//! Handle coverage for Jacoco
int HandleBlanketJSCoverage(cmCTestCoverageHandlerContainer* cont);
//! Handle coverage using Bullseye
//! Handle coverage using Bullseye
int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
int RunBullseyeSourceSummary(cmCTestCoverageHandlerContainer* cont);
int RunBullseyeCoverageBranch(cmCTestCoverageHandlerContainer* cont,
@ -103,22 +103,15 @@ private:
std::vector<std::string>& files,
std::vector<std::string>& filesFullPath);
int RunBullseyeCommand(
cmCTestCoverageHandlerContainer* cont,
const char* cmd,
const char* arg,
int RunBullseyeCommand(cmCTestCoverageHandlerContainer* cont,
const char* cmd, const char* arg,
std::string& outputFile);
bool ParseBullsEyeCovsrcLine(
std::string const& inputLine,
std::string& sourceFile,
int& functionsCalled,
int& totalFunctions,
int& percentFunction,
int& branchCovered,
int& totalBranches,
bool ParseBullsEyeCovsrcLine(std::string const& inputLine,
std::string& sourceFile, int& functionsCalled,
int& totalFunctions, int& percentFunction,
int& branchCovered, int& totalBranches,
int& percentBranch);
bool GetNextInt(std::string const& inputLine,
std::string::size_type& pos,
bool GetNextInt(std::string const& inputLine, std::string::size_type& pos,
int& value);
//! Handle Python coverage using Python's Trace.py
int HandleTracePyCoverage(cmCTestCoverageHandlerContainer* cont);
@ -134,9 +127,10 @@ private:
std::vector<cmsys::RegularExpression> CustomCoverageExcludeRegex;
std::vector<std::string> ExtraCoverageGlobs;
// Map from source file to label ids.
class LabelSet: public std::set<int> {};
class LabelSet : public std::set<int>
{
};
typedef std::map<std::string, LabelSet> LabelMapType;
LabelMapType SourceLabels;
LabelMapType TargetDirs;

137
Source/CTest/cmCTestCurl.cxx
View File

@ -42,45 +42,36 @@ std::string cmCTestCurl::Escape(std::string const& source)
return ret;
}
namespace
{
static size_t
curlWriteMemoryCallback(void *ptr, size_t size, size_t nmemb,
void *data)
namespace {
static size_t curlWriteMemoryCallback(void* ptr, size_t size, size_t nmemb,
void* data)
{
int realsize = (int)(size * nmemb);
std::vector<char> *vec
= static_cast<std::vector<char>* >(data);
std::vector<char>* vec = static_cast<std::vector<char>*>(data);
const char* chPtr = static_cast<char*>(ptr);
vec->insert(vec->end(), chPtr, chPtr + realsize);
return realsize;
}
static size_t
curlDebugCallback(CURL *, curl_infotype, char *chPtr,
size_t size, void *data)
static size_t curlDebugCallback(CURL*, curl_infotype, char* chPtr, size_t size,
void* data)
{
std::vector<char> *vec
= static_cast<std::vector<char>* >(data);
std::vector<char>* vec = static_cast<std::vector<char>*>(data);
vec->insert(vec->end(), chPtr, chPtr + size);
return size;
}
}
void cmCTestCurl::SetCurlOptions(std::vector<std::string> const& args)
{
for( std::vector<std::string>::const_iterator i = args.begin();
i != args.end(); ++i)
{
if(*i == "CURLOPT_SSL_VERIFYPEER_OFF")
{
for (std::vector<std::string>::const_iterator i = args.begin();
i != args.end(); ++i) {
if (*i == "CURLOPT_SSL_VERIFYPEER_OFF") {
this->VerifyPeerOff = true;
}
if(*i == "CURLOPT_SSL_VERIFYHOST_OFF")
{
if (*i == "CURLOPT_SSL_VERIFYHOST_OFF") {
this->VerifyHostOff = true;
}
}
@ -88,30 +79,24 @@ void cmCTestCurl::SetCurlOptions(std::vector<std::string> const& args)
bool cmCTestCurl::InitCurl()
{
if(!this->Curl)
{
if (!this->Curl) {
return false;
}
if(this->VerifyPeerOff)
{
if (this->VerifyPeerOff) {
curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYPEER, 0);
}
if(this->VerifyHostOff)
{
if (this->VerifyHostOff) {
curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYHOST, 0);
}
if(this->HTTPProxy.size())
{
if (this->HTTPProxy.size()) {
curl_easy_setopt(this->Curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
curl_easy_setopt(this->Curl, CURLOPT_PROXYTYPE, this->HTTPProxyType);
if (this->HTTPProxyAuth.size() > 0)
{
if (this->HTTPProxyAuth.size() > 0) {
curl_easy_setopt(this->Curl, CURLOPT_PROXYUSERPWD,
this->HTTPProxyAuth.c_str());
}
}
if(this->UseHttp10)
{
if (this->UseHttp10) {
curl_easy_setopt(this->Curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
}
// enable HTTP ERROR parsing
@ -119,23 +104,19 @@ bool cmCTestCurl::InitCurl()
return true;
}
bool cmCTestCurl::UploadFile(std::string const& local_file,
std::string const& url,
std::string const& fields,
std::string const& url, std::string const& fields,
std::string& response)
{
response = "";
if(!this->InitCurl())
{
if (!this->InitCurl()) {
cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
return false;
}
/* enable uploading */
curl_easy_setopt(this->Curl, CURLOPT_UPLOAD, 1);
// if there is little to no activity for too long stop submitting
if(this->TimeOutSeconds)
{
if (this->TimeOutSeconds) {
::curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_LIMIT, 1);
::curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_TIME,
this->TimeOutSeconds);
@ -145,8 +126,7 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
::curl_easy_setopt(this->Curl, CURLOPT_VERBOSE, 1);
FILE* ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
if(!ftpfile)
{
if (!ftpfile) {
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Could not open file for upload: " << local_file << "\n");
return false;
@ -164,16 +144,15 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
static_cast<long>(filelen));
::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
curlWriteMemoryCallback);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION,
curlDebugCallback);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
// Be sure to set Content-Type to satisfy fussy modsecurity rules
struct curl_slist *headers = ::curl_slist_append(NULL,
"Content-Type: text/xml");
struct curl_slist* headers =
::curl_slist_append(NULL, "Content-Type: text/xml");
::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers);
std::vector<char> responseData;
std::vector<char> debugData;
::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void *)&responseData);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void *)&debugData);
::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void*)&responseData);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void*)&debugData);
::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
// Now run off and do what you've been told!
::curl_easy_perform(this->Curl);
@ -181,37 +160,32 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, NULL);
::curl_slist_free_all(headers);
if ( responseData.size() > 0 )
{
if (responseData.size() > 0) {
response = std::string(responseData.begin(), responseData.end());
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Curl response: [" << response << "]\n");
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Curl response: ["
<< response << "]\n");
}
std::string curlDebug;
if ( debugData.size() > 0 )
{
if (debugData.size() > 0) {
curlDebug = std::string(debugData.begin(), debugData.end());
cmCTestLog(this->CTest, DEBUG, "Curl debug: [" << curlDebug << "]\n");
}
if(response.size() == 0)
{
cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n" <<
curlDebug);
if (response.size() == 0) {
cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n"
<< curlDebug);
return false;
}
return true;
}
bool cmCTestCurl::HttpRequest(std::string const& url,
std::string const& fields,
std::string& response)
std::string const& fields, std::string& response)
{
response = "";
cmCTestLog(this->CTest, DEBUG, "HttpRequest\n"
<< "url: " << url << "\n"
<< "fields " << fields << "\n");
if(!this->InitCurl())
{
if (!this->InitCurl()) {
cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
return false;
}
@ -219,26 +193,23 @@ bool cmCTestCurl::HttpRequest(std::string const& url,
curl_easy_setopt(this->Curl, CURLOPT_POSTFIELDS, fields.c_str());
::curl_easy_setopt(this->Curl, CURLOPT_URL, url.c_str());
::curl_easy_setopt(this->Curl, CURLOPT_FOLLOWLOCATION, 1);
//set response options
// set response options
::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
curlWriteMemoryCallback);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION,
curlDebugCallback);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
std::vector<char> responseData;
std::vector<char> debugData;
::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void *)&responseData);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void *)&debugData);
::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void*)&responseData);
::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void*)&debugData);
::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
CURLcode res = ::curl_easy_perform(this->Curl);
if ( responseData.size() > 0 )
{
if (responseData.size() > 0) {
response = std::string(responseData.begin(), responseData.end());
cmCTestLog(this->CTest, DEBUG, "Curl response: [" << response << "]\n");
}
if ( debugData.size() > 0 )
{
if (debugData.size() > 0) {
std::string curlDebug = std::string(debugData.begin(), debugData.end());
cmCTestLog(this->CTest, DEBUG, "Curl debug: [" << curlDebug << "]\n");
}
@ -248,39 +219,29 @@ bool cmCTestCurl::HttpRequest(std::string const& url,
void cmCTestCurl::SetProxyType()
{
if ( cmSystemTools::GetEnv("HTTP_PROXY") )
{
if (cmSystemTools::GetEnv("HTTP_PROXY")) {
this->HTTPProxy = cmSystemTools::GetEnv("HTTP_PROXY");
if ( cmSystemTools::GetEnv("HTTP_PROXY_PORT") )
{
if (cmSystemTools::GetEnv("HTTP_PROXY_PORT")) {
this->HTTPProxy += ":";
this->HTTPProxy += cmSystemTools::GetEnv("HTTP_PROXY_PORT");
}
if ( cmSystemTools::GetEnv("HTTP_PROXY_TYPE") )
{
if (cmSystemTools::GetEnv("HTTP_PROXY_TYPE")) {
// this is the default
this->HTTPProxyType = CURLPROXY_HTTP;
std::string type = cmSystemTools::GetEnv("HTTP_PROXY_TYPE");
// HTTP/SOCKS4/SOCKS5
if ( type == "HTTP" )
{
if (type == "HTTP") {
this->HTTPProxyType = CURLPROXY_HTTP;
}
else if ( type == "SOCKS4" )
{
} else if (type == "SOCKS4") {
this->HTTPProxyType = CURLPROXY_SOCKS4;
}
else if ( type == "SOCKS5" )
{
} else if (type == "SOCKS5") {
this->HTTPProxyType = CURLPROXY_SOCKS5;
}
}
if ( cmSystemTools::GetEnv("HTTP_PROXY_USER") )
{
if (cmSystemTools::GetEnv("HTTP_PROXY_USER")) {
this->HTTPProxyAuth = cmSystemTools::GetEnv("HTTP_PROXY_USER");
}
if ( cmSystemTools::GetEnv("HTTP_PROXY_PASSWD") )
{
if (cmSystemTools::GetEnv("HTTP_PROXY_PASSWD")) {
this->HTTPProxyAuth += ":";
this->HTTPProxyAuth += cmSystemTools::GetEnv("HTTP_PROXY_PASSWD");
}

15
Source/CTest/cmCTestCurl.h
View File

@ -23,22 +23,21 @@ class cmCTestCurl
public:
cmCTestCurl(cmCTest*);
~cmCTestCurl();
bool UploadFile(std::string const& url,
std::string const& file,
std::string const& fields,
std::string& response);
bool HttpRequest(std::string const& url,
std::string const& fields,
bool UploadFile(std::string const& url, std::string const& file,
std::string const& fields, std::string& response);
bool HttpRequest(std::string const& url, std::string const& fields,
std::string& response);
// currently only supports CURLOPT_SSL_VERIFYPEER_OFF
// and CURLOPT_SSL_VERIFYHOST_OFF
void SetCurlOptions(std::vector<std::string> const& args);
void SetUseHttp10On() { this->UseHttp10 = true;}
void SetTimeOutSeconds(int s) { this->TimeOutSeconds = s;}
void SetUseHttp10On() { this->UseHttp10 = true; }
void SetTimeOutSeconds(int s) { this->TimeOutSeconds = s; }
std::string Escape(std::string const& source);
protected:
void SetProxyType();
bool InitCurl();
private:
cmCTest* CTest;
CURL* Curl;

12
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
View File

@ -13,17 +13,15 @@
#include "cmCTestScriptHandler.h"
bool cmCTestEmptyBinaryDirectoryCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
bool cmCTestEmptyBinaryDirectoryCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus&)
{
if(args.size() != 1 )
{
if (args.size() != 1) {
this->SetError("called with incorrect number of arguments");
return false;
}
if ( !cmCTestScriptHandler::EmptyBinaryDirectory(args[0].c_str()) )
{
if (!cmCTestScriptHandler::EmptyBinaryDirectory(args[0].c_str())) {
std::ostringstream ostr;
ostr << "problem removing the binary directory: " << args[0];
this->SetError(ostr.str());
@ -32,5 +30,3 @@ bool cmCTestEmptyBinaryDirectoryCommand
return true;
}

14
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
View File

@ -23,7 +23,6 @@
class cmCTestEmptyBinaryDirectoryCommand : public cmCTestCommand
{
public:
cmCTestEmptyBinaryDirectoryCommand() {}
/**
@ -31,8 +30,8 @@ public:
*/
virtual cmCommand* Clone()
{
cmCTestEmptyBinaryDirectoryCommand* ni
= new cmCTestEmptyBinaryDirectoryCommand;
cmCTestEmptyBinaryDirectoryCommand* ni =
new cmCTestEmptyBinaryDirectoryCommand;
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
return ni;
@ -43,16 +42,17 @@ public:
* the CMakeLists.txt file.
*/
virtual bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus &status);
cmExecutionStatus& status);
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual std::string GetName() const { return "ctest_empty_binary_directory";}
virtual std::string GetName() const
{
return "ctest_empty_binary_directory";
}
cmTypeMacro(cmCTestEmptyBinaryDirectoryCommand, cmCTestCommand);
};
#endif

326
Source/CTest/cmCTestGIT.cxx
View File

@ -27,11 +27,11 @@ static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major,
unsigned int minor, unsigned int fix)
{
// 1.6.5.0 maps to 10605000
return fix + minor*1000 + major*100000 + epic*10000000;
return fix + minor * 1000 + major * 100000 + epic * 10000000;
}
cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log):
cmCTestGlobalVC(ct, log)
cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log)
: cmCTestGlobalVC(ct, log)
{
this->PriorRev = this->Unknown;
this->CurrentGitVersion = 0;
@ -41,14 +41,15 @@ cmCTestGIT::~cmCTestGIT()
{
}
class cmCTestGIT::OneLineParser: public cmCTestVC::LineParser
class cmCTestGIT::OneLineParser : public cmCTestVC::LineParser
{
public:
OneLineParser(cmCTestGIT* git, const char* prefix,
std::string& l): Line1(l)
OneLineParser(cmCTestGIT* git, const char* prefix, std::string& l)
: Line1(l)
{
this->SetLog(&git->Log, prefix);
}
private:
std::string& Line1;
virtual bool ProcessLine()
@ -63,7 +64,7 @@ std::string cmCTestGIT::GetWorkingRevision()
{
// Run plumbing "git rev-list" to get work tree revision.
const char* git = this->CommandLineTool.c_str();
const char* git_rev_list[] = {git, "rev-list", "-n", "1", "HEAD", "--", 0};
const char* git_rev_list[] = { git, "rev-list", "-n", "1", "HEAD", "--", 0 };
std::string rev;
OneLineParser out(this, "rl-out> ", rev);
OutputLogger err(this->Log, "rl-err> ");
@ -92,39 +93,34 @@ std::string cmCTestGIT::FindGitDir()
// Run "git rev-parse --git-dir" to locate the real .git directory.
const char* git = this->CommandLineTool.c_str();
char const* git_rev_parse[] = {git, "rev-parse", "--git-dir", 0};
char const* git_rev_parse[] = { git, "rev-parse", "--git-dir", 0 };
std::string git_dir_line;
OneLineParser rev_parse_out(this, "rev-parse-out> ", git_dir_line);
OutputLogger rev_parse_err(this->Log, "rev-parse-err> ");
if(this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err))
{
if (this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err)) {
git_dir = git_dir_line;
}
if(git_dir.empty())
{
if (git_dir.empty()) {
git_dir = ".git";
}
// Git reports a relative path only when the .git directory is in
// the current directory.
if(git_dir[0] == '.')
{
if (git_dir[0] == '.') {
git_dir = this->SourceDirectory + "/" + git_dir;
}
#if defined(_WIN32) && !defined(__CYGWIN__)
else if(git_dir[0] == '/')
{
else if (git_dir[0] == '/') {
// Cygwin Git reports a full path that Cygwin understands, but we
// are a Windows application. Run "cygpath" to get Windows path.
std::string cygpath_exe = cmSystemTools::GetFilenamePath(git);
cygpath_exe += "/cygpath.exe";
if(cmSystemTools::FileExists(cygpath_exe.c_str()))
{
char const* cygpath[] = {cygpath_exe.c_str(), "-w", git_dir.c_str(), 0};
if (cmSystemTools::FileExists(cygpath_exe.c_str())) {
char const* cygpath[] = { cygpath_exe.c_str(), "-w", git_dir.c_str(),
0 };
OneLineParser cygpath_out(this, "cygpath-out> ", git_dir_line);
OutputLogger cygpath_err(this->Log, "cygpath-err> ");
if(this->RunChild(cygpath, &cygpath_out, &cygpath_err))
{
if (this->RunChild(cygpath, &cygpath_out, &cygpath_err)) {
git_dir = git_dir_line;
}
}
@ -139,13 +135,12 @@ std::string cmCTestGIT::FindTopDir()
// Run "git rev-parse --show-cdup" to locate the top of the tree.
const char* git = this->CommandLineTool.c_str();
char const* git_rev_parse[] = {git, "rev-parse", "--show-cdup", 0};
char const* git_rev_parse[] = { git, "rev-parse", "--show-cdup", 0 };
std::string cdup;
OneLineParser rev_parse_out(this, "rev-parse-out> ", cdup);
OutputLogger rev_parse_err(this->Log, "rev-parse-err> ");
if(this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err) &&
!cdup.empty())
{
if (this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err) &&
!cdup.empty()) {
top_dir += "/";
top_dir += cdup;
top_dir = cmSystemTools::CollapseFullPath(top_dir);
@ -164,14 +159,12 @@ bool cmCTestGIT::UpdateByFetchAndReset()
// Add user-specified update options.
std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
if(opts.empty())
{
if (opts.empty()) {
opts = this->CTest->GetCTestConfiguration("GITUpdateOptions");
}
std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
for(std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai)
{
for (std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai) {
git_fetch.push_back(ai->c_str());
}
@ -181,8 +174,7 @@ bool cmCTestGIT::UpdateByFetchAndReset()
// Fetch upstream refs.
OutputLogger fetch_out(this->Log, "fetch-out> ");
OutputLogger fetch_err(this->Log, "fetch-err> ");
if(!this->RunUpdateCommand(&git_fetch[0], &fetch_out, &fetch_err))
{
if (!this->RunUpdateCommand(&git_fetch[0], &fetch_out, &fetch_err)) {
return false;
}
@ -191,33 +183,28 @@ bool cmCTestGIT::UpdateByFetchAndReset()
{
std::string fetch_head = this->FindGitDir() + "/FETCH_HEAD";
cmsys::ifstream fin(fetch_head.c_str(), std::ios::in | std::ios::binary);
if(!fin)
{
if (!fin) {
this->Log << "Unable to open " << fetch_head << "\n";
return false;
}
std::string line;
while(sha1.empty() && cmSystemTools::GetLineFromStream(fin, line))
{
while (sha1.empty() && cmSystemTools::GetLineFromStream(fin, line)) {
this->Log << "FETCH_HEAD> " << line << "\n";
if(line.find("\tnot-for-merge\t") == line.npos)
{
if (line.find("\tnot-for-merge\t") == line.npos) {
std::string::size_type pos = line.find('\t');
if(pos != line.npos)
{
if (pos != line.npos) {
sha1 = line.substr(0, pos);
}
}
}
if(sha1.empty())
{
if (sha1.empty()) {
this->Log << "FETCH_HEAD has no upstream branch candidate!\n";
return false;
}
}
// Reset the local branch to point at that tracked from upstream.
char const* git_reset[] = {git, "reset", "--hard", sha1.c_str(), 0};
char const* git_reset[] = { git, "reset", "--hard", sha1.c_str(), 0 };
OutputLogger reset_out(this->Log, "reset-out> ");
OutputLogger reset_err(this->Log, "reset-err> ");
return this->RunChild(&git_reset[0], &reset_out, &reset_err);
@ -228,9 +215,8 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom)
std::vector<std::string> git_custom_command;
cmSystemTools::ExpandListArgument(custom, git_custom_command, true);
std::vector<char const*> git_custom;
for(std::vector<std::string>::const_iterator
i = git_custom_command.begin(); i != git_custom_command.end(); ++i)
{
for (std::vector<std::string>::const_iterator i = git_custom_command.begin();
i != git_custom_command.end(); ++i) {
git_custom.push_back(i->c_str());
}
git_custom.push_back(0);
@ -243,8 +229,7 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom)
bool cmCTestGIT::UpdateInternal()
{
std::string custom = this->CTest->GetCTestConfiguration("GITUpdateCustom");
if(!custom.empty())
{
if (!custom.empty()) {
return this->UpdateByCustom(custom);
}
return this->UpdateByFetchAndReset();
@ -252,8 +237,7 @@ bool cmCTestGIT::UpdateInternal()
bool cmCTestGIT::UpdateImpl()
{
if(!this->UpdateInternal())
{
if (!this->UpdateInternal()) {
return false;
}
@ -263,23 +247,19 @@ bool cmCTestGIT::UpdateImpl()
const char* sync_recursive = "--recursive";
// Git < 1.6.5 did not support submodule --recursive
if(this->GetGitVersion() < cmCTestGITVersion(1,6,5,0))
{
if (this->GetGitVersion() < cmCTestGITVersion(1, 6, 5, 0)) {
recursive = 0;
// No need to require >= 1.6.5 if there are no submodules.
if(cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str()))
{
if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) {
this->Log << "Git < 1.6.5 cannot update submodules recursively\n";
}
}
// Git < 1.8.1 did not support sync --recursive
if(this->GetGitVersion() < cmCTestGITVersion(1,8,1,0))
{
if (this->GetGitVersion() < cmCTestGITVersion(1, 8, 1, 0)) {
sync_recursive = 0;
// No need to require >= 1.8.1 if there are no submodules.
if(cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str()))
{
if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) {
this->Log << "Git < 1.8.1 cannot synchronize submodules recursively\n";
}
}
@ -291,47 +271,42 @@ bool cmCTestGIT::UpdateImpl()
std::string init_submodules =
this->CTest->GetCTestConfiguration("GITInitSubmodules");
if (cmSystemTools::IsOn(init_submodules.c_str()))
{
char const* git_submodule_init[] = {git, "submodule", "init", 0};
if (cmSystemTools::IsOn(init_submodules.c_str())) {
char const* git_submodule_init[] = { git, "submodule", "init", 0 };
ret = this->RunChild(git_submodule_init, &submodule_out, &submodule_err,
top_dir.c_str());
if (!ret)
{
if (!ret) {
return false;
}
}
char const* git_submodule_sync[] = {git, "submodule", "sync",
sync_recursive, 0};
char const* git_submodule_sync[] = { git, "submodule", "sync",
sync_recursive, 0 };
ret = this->RunChild(git_submodule_sync, &submodule_out, &submodule_err,
top_dir.c_str());
if (!ret)
{
if (!ret) {
return false;
}
char const* git_submodule[] = {git, "submodule", "update", recursive, 0};
char const* git_submodule[] = { git, "submodule", "update", recursive, 0 };
return this->RunChild(git_submodule, &submodule_out, &submodule_err,
top_dir.c_str());
}
unsigned int cmCTestGIT::GetGitVersion()
{
if(!this->CurrentGitVersion)
{
if (!this->CurrentGitVersion) {
const char* git = this->CommandLineTool.c_str();
char const* git_version[] = {git, "--version", 0};
char const* git_version[] = { git, "--version", 0 };
std::string version;
OneLineParser version_out(this, "version-out> ", version);
OutputLogger version_err(this->Log, "version-err> ");
unsigned int v[4] = {0,0,0,0};
if(this->RunChild(git_version, &version_out, &version_err) &&
sscanf(version.c_str(), "git version %u.%u.%u.%u",
&v[0], &v[1], &v[2], &v[3]) >= 3)
{
unsigned int v[4] = { 0, 0, 0, 0 };
if (this->RunChild(git_version, &version_out, &version_err) &&
sscanf(version.c_str(), "git version %u.%u.%u.%u", &v[0], &v[1], &v[2],
&v[3]) >= 3) {
this->CurrentGitVersion = cmCTestGITVersion(v[0], v[1], v[2], v[3]);
}
}
@ -348,21 +323,29 @@ unsigned int cmCTestGIT::GetGitVersion()
line appears only for lines with status 'C' or 'R'. See 'git help
diff-tree' for details.
*/
class cmCTestGIT::DiffParser: public cmCTestVC::LineParser
class cmCTestGIT::DiffParser : public cmCTestVC::LineParser
{
public:
DiffParser(cmCTestGIT* git, const char* prefix):
LineParser('\0', false), GIT(git), DiffField(DiffFieldNone)
DiffParser(cmCTestGIT* git, const char* prefix)
: LineParser('\0', false)
, GIT(git)
, DiffField(DiffFieldNone)
{
this->SetLog(&git->Log, prefix);
}
typedef cmCTestGIT::Change Change;
std::vector<Change> Changes;
protected:
cmCTestGIT* GIT;
enum DiffFieldType { DiffFieldNone, DiffFieldChange,
DiffFieldSrc, DiffFieldDst };
enum DiffFieldType
{
DiffFieldNone,
DiffFieldChange,
DiffFieldSrc,
DiffFieldDst
};
DiffFieldType DiffField;
Change CurChange;
@ -374,20 +357,17 @@ protected:
virtual bool ProcessLine()
{
if(this->Line[0] == ':')
{
if (this->Line[0] == ':') {
this->DiffField = DiffFieldChange;
this->CurChange = Change();
}
if(this->DiffField == DiffFieldChange)
{
if (this->DiffField == DiffFieldChange) {
// :src-mode dst-mode src-sha1 dst-sha1 status
if(this->Line[0] != ':')
{
if (this->Line[0] != ':') {
this->DiffField = DiffFieldNone;
return true;
}
const char* src_mode_first = this->Line.c_str()+1;
const char* src_mode_first = this->Line.c_str() + 1;
const char* src_mode_last = this->ConsumeField(src_mode_first);
const char* dst_mode_first = this->ConsumeSpace(src_mode_last);
const char* dst_mode_last = this->ConsumeField(dst_mode_first);
@ -397,27 +377,19 @@ protected:
const char* dst_sha1_last = this->ConsumeField(dst_sha1_first);
const char* status_first = this->ConsumeSpace(dst_sha1_last);
const char* status_last = this->ConsumeField(status_first);
if(status_first != status_last)
{
if (status_first != status_last) {
this->CurChange.Action = *status_first;
this->DiffField = DiffFieldSrc;
}
else
{
} else {
this->DiffField = DiffFieldNone;
}
}
else if(this->DiffField == DiffFieldSrc)
{
} else if (this->DiffField == DiffFieldSrc) {
// src-path
if(this->CurChange.Action == 'C')
{
if (this->CurChange.Action == 'C') {
// Convert copy to addition of destination.
this->CurChange.Action = 'A';
this->DiffField = DiffFieldDst;
}
else if(this->CurChange.Action == 'R')
{
} else if (this->CurChange.Action == 'R') {
// Convert rename to deletion of source and addition of destination.
this->CurChange.Action = 'D';
this->CurChange.Path = this->Line;
@ -425,16 +397,12 @@ protected:
this->CurChange = Change('A');
this->DiffField = DiffFieldDst;
}
else
{
} else {
this->CurChange.Path = this->Line;
this->Changes.push_back(this->CurChange);
this->DiffField = this->DiffFieldNone;
}
}
else if(this->DiffField == DiffFieldDst)
{
} else if (this->DiffField == DiffFieldDst) {
// dst-path
this->CurChange.Path = this->Line;
this->Changes.push_back(this->CurChange);
@ -445,12 +413,16 @@ protected:
const char* ConsumeSpace(const char* c)
{
while(*c && isspace(*c)) { ++c; }
while (*c && isspace(*c)) {
++c;
}
return c;
}
const char* ConsumeField(const char* c)
{
while(*c && !isspace(*c)) { ++c; }
while (*c && !isspace(*c)) {
++c;
}
return c;
}
};
@ -474,18 +446,25 @@ protected:
The header may have more fields. See 'git help diff-tree'.
*/
class cmCTestGIT::CommitParser: public cmCTestGIT::DiffParser
class cmCTestGIT::CommitParser : public cmCTestGIT::DiffParser
{
public:
CommitParser(cmCTestGIT* git, const char* prefix):
DiffParser(git, prefix), Section(SectionHeader)
CommitParser(cmCTestGIT* git, const char* prefix)
: DiffParser(git, prefix)
, Section(SectionHeader)
{
this->Separator = SectionSep[this->Section];
}
private:
typedef cmCTestGIT::Revision Revision;
enum SectionType { SectionHeader, SectionBody, SectionDiff, SectionCount };
enum SectionType
{
SectionHeader,
SectionBody,
SectionDiff,
SectionCount
};
static char const SectionSep[SectionCount];
SectionType Section;
Revision Rev;
@ -496,25 +475,39 @@ private:
std::string EMail;
unsigned long Time;
long TimeZone;
Person(): Name(), EMail(), Time(0), TimeZone(0) {}
Person()
: Name()
, EMail()
, Time(0)
, TimeZone(0)
{
}
};
void ParsePerson(const char* str, Person& person)
{
// Person Name <person@domain.com> 1234567890 +0000
const char* c = str;
while(*c && isspace(*c)) { ++c; }
while (*c && isspace(*c)) {
++c;
}
const char* name_first = c;
while(*c && *c != '<') { ++c; }
while (*c && *c != '<') {
++c;
}
const char* name_last = c;
while(name_last != name_first && isspace(*(name_last-1))) { --name_last; }
person.Name.assign(name_first, name_last-name_first);
while (name_last != name_first && isspace(*(name_last - 1))) {
--name_last;
}
person.Name.assign(name_first, name_last - name_first);
const char* email_first = *c? ++c : c;
while(*c && *c != '>') { ++c; }
const char* email_last = *c? c++ : c;
person.EMail.assign(email_first, email_last-email_first);
const char* email_first = *c ? ++c : c;
while (*c && *c != '>') {
++c;
}
const char* email_last = *c ? c++ : c;
person.EMail.assign(email_first, email_last - email_first);
person.Time = strtoul(c, (char**)&c, 10);
person.TimeZone = strtol(c, (char**)&c, 10);
@ -522,23 +515,25 @@ private:
virtual bool ProcessLine()
{
if(this->Line.empty())
{
if(this->Section == SectionBody && this->LineEnd == '\0')
{
if (this->Line.empty()) {
if (this->Section == SectionBody && this->LineEnd == '\0') {
// Skip SectionDiff
this->NextSection();
}
this->NextSection();
}
else
{
switch(this->Section)
{
case SectionHeader: this->DoHeaderLine(); break;
case SectionBody: this->DoBodyLine(); break;
case SectionDiff: this->DiffParser::ProcessLine(); break;
case SectionCount: break; // never happens
} else {
switch (this->Section) {
case SectionHeader:
this->DoHeaderLine();
break;
case SectionBody:
this->DoBodyLine();
break;
case SectionDiff:
this->DiffParser::ProcessLine();
break;
case SectionCount:
break; // never happens
}
}
return true;
@ -546,10 +541,9 @@ private:
void NextSection()
{
this->Section = SectionType((this->Section+1) % SectionCount);
this->Section = SectionType((this->Section + 1) % SectionCount);
this->Separator = SectionSep[this->Section];
if(this->Section == SectionHeader)
{
if (this->Section == SectionHeader) {
this->GIT->DoRevision(this->Rev, this->Changes);
this->Rev = Revision();
this->DiffReset();
@ -559,22 +553,17 @@ private:
void DoHeaderLine()
{
// Look for header fields that we need.
if(cmHasLiteralPrefix(this->Line.c_str(), "commit "))
{
this->Rev.Rev = this->Line.c_str()+7;
}
else if(cmHasLiteralPrefix(this->Line.c_str(), "author "))
{
if (cmHasLiteralPrefix(this->Line.c_str(), "commit ")) {
this->Rev.Rev = this->Line.c_str() + 7;
} else if (cmHasLiteralPrefix(this->Line.c_str(), "author ")) {
Person author;
this->ParsePerson(this->Line.c_str()+7, author);
this->ParsePerson(this->Line.c_str() + 7, author);
this->Rev.Author = author.Name;
this->Rev.EMail = author.EMail;
this->Rev.Date = this->FormatDateTime(author);
}
else if(cmHasLiteralPrefix(this->Line.c_str(), "committer "))
{
} else if (cmHasLiteralPrefix(this->Line.c_str(), "committer ")) {
Person committer;
this->ParsePerson(this->Line.c_str()+10, committer);
this->ParsePerson(this->Line.c_str() + 10, committer);
this->Rev.Committer = committer.Name;
this->Rev.CommitterEMail = committer.EMail;
this->Rev.CommitDate = this->FormatDateTime(committer);
@ -584,8 +573,7 @@ private:
void DoBodyLine()
{
// Commit log lines are indented by 4 spaces.
if(this->Line.size() >= 4)
{
if (this->Line.size() >= 4) {
this->Rev.Log += this->Line.substr(4);
}
this->Rev.Log += "\n";
@ -598,19 +586,15 @@ private:
time_t seconds = static_cast<time_t>(person.Time);
struct tm* t = gmtime(&seconds);
char dt[1024];
sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d",
t->tm_year+1900, t->tm_mon+1, t->tm_mday,
t->tm_hour, t->tm_min, t->tm_sec);
sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900,
t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
std::string out = dt;
// Add the time-zone field "+zone" or "-zone".
char tz[32];
if(person.TimeZone >= 0)
{
if (person.TimeZone >= 0) {
sprintf(tz, " +%04ld", person.TimeZone);
}
else
{
} else {
sprintf(tz, " -%04ld", -person.TimeZone);
}
out += tz;
@ -618,19 +602,20 @@ private:
}
};
char const cmCTestGIT::CommitParser::SectionSep[SectionCount] =
{'\n', '\n', '\0'};
char const cmCTestGIT::CommitParser::SectionSep[SectionCount] = { '\n', '\n',
'\0' };
void cmCTestGIT::LoadRevisions()
{
// Use 'git rev-list ... | git diff-tree ...' to get revisions.
std::string range = this->OldRevision + ".." + this->NewRevision;
const char* git = this->CommandLineTool.c_str();
const char* git_rev_list[] =
{git, "rev-list", "--reverse", range.c_str(), "--", 0};
const char* git_diff_tree[] =
{git, "diff-tree", "--stdin", "--always", "-z", "-r", "--pretty=raw",
"--encoding=utf-8", 0};
const char* git_rev_list[] = { git, "rev-list", "--reverse",
range.c_str(), "--", 0 };
const char* git_diff_tree[] = {
git, "diff-tree", "--stdin", "--always", "-z",
"-r", "--pretty=raw", "--encoding=utf-8", 0
};
this->Log << this->ComputeCommandLine(git_rev_list) << " | "
<< this->ComputeCommandLine(git_diff_tree) << "\n";
@ -654,20 +639,19 @@ void cmCTestGIT::LoadModifications()
const char* git = this->CommandLineTool.c_str();
// Use 'git update-index' to refresh the index w.r.t. the work tree.
const char* git_update_index[] = {git, "update-index", "--refresh", 0};
const char* git_update_index[] = { git, "update-index", "--refresh", 0 };
OutputLogger ui_out(this->Log, "ui-out> ");
OutputLogger ui_err(this->Log, "ui-err> ");
this->RunChild(git_update_index, &ui_out, &ui_err);
// Use 'git diff-index' to get modified files.
const char* git_diff_index[] = {git, "diff-index", "-z", "HEAD", "--", 0};
const char* git_diff_index[] = { git, "diff-index", "-z", "HEAD", "--", 0 };
DiffParser out(this, "di-out> ");
OutputLogger err(this->Log, "di-err> ");
this->RunChild(git_diff_index, &out, &err);
for(std::vector<Change>::const_iterator ci = out.Changes.begin();
ci != out.Changes.end(); ++ci)
{
for (std::vector<Change>::const_iterator ci = out.Changes.begin();
ci != out.Changes.end(); ++ci) {
this->DoModification(PathModified, ci->Path);
}
}

3
Source/CTest/cmCTestGIT.h
View File

@ -18,7 +18,7 @@
* \brief Interaction with git command-line tool
*
*/
class cmCTestGIT: public cmCTestGlobalVC
class cmCTestGIT : public cmCTestGlobalVC
{
public:
/** Construct with a CTest instance and update log stream. */
@ -46,7 +46,6 @@ private:
// "public" needed by older Sun compilers
public:
// Parsing helper classes.
class OneLineParser;
class DiffParser;

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