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;

24
Modules/CMakeCompilerABI.h
View File

@ -1,34 +1,32 @@
/* 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'
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'
/* 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)

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

20
Modules/CheckFunctionExists.c
View File

@ -3,24 +3,26 @@
#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;
}
#else /* CHECK_FUNCTION_EXISTS */
#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 */

16
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 */
#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;
}

7
Modules/TestForSSTREAM.cxx
View File

@ -1,11 +1,10 @@
#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;

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

@ -39,22 +39,22 @@ cmCPackIFWGenerator::~cmCPackIFWGenerator()
{
}
bool cmCPackIFWGenerator::IsVersionLess(const char *version)
bool cmCPackIFWGenerator::IsVersionLess(const char* version)
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
FrameworkVersion.data(), version);
FrameworkVersion.data(), version);
}
bool cmCPackIFWGenerator::IsVersionGreater(const char *version)
bool cmCPackIFWGenerator::IsVersionGreater(const char* version)
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
FrameworkVersion.data(), version);
FrameworkVersion.data(), version);
}
bool cmCPackIFWGenerator::IsVersionEqual(const char *version)
bool cmCPackIFWGenerator::IsVersionEqual(const char* version)
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
FrameworkVersion.data(), version);
FrameworkVersion.data(), version);
}
int cmCPackIFWGenerator::PackageFiles()
@ -72,168 +72,141 @@ 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
<< output << std::endl;
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
<< ifwCmd << std::endl
<< "Please check " << ifwTmpFile << " for errors"
<< std::endl);
<< ifwCmd << std::endl
<< "Please check " << ifwTmpFile << " for errors"
<< 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
{
std::string ifwCmd = BinCreator;
ifwCmd += " -c " + this->toplevel + "/config/config.xml";
ifwCmd += " -p " + this->toplevel + "/packages";
std::string ifwCmd = BinCreator;
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)
{
ifwCmd += " -p " + *it;
if (!PkgsDirsVector.empty()) {
for (std::vector<std::string>::iterator it = PkgsDirsVector.begin();
it != PkgsDirsVector.end(); ++it) {
ifwCmd += " -p " + *it;
}
}
if (OnlineOnly)
{
ifwCmd += " --online-only";
}
else if (!DownloadedPackages.empty() && !Installer.Repositories.empty())
{
ifwCmd += " -e ";
std::set<cmCPackIFWPackage*>::iterator it
= DownloadedPackages.begin();
ifwCmd += (*it)->Name;
++it;
while(it != DownloadedPackages.end())
{
ifwCmd += "," + (*it)->Name;
if (OnlineOnly) {
ifwCmd += " --online-only";
} else if (!DownloadedPackages.empty() &&
!Installer.Repositories.empty()) {
ifwCmd += " -e ";
std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
ifwCmd += (*it)->Name;
++it;
while (it != DownloadedPackages.end()) {
ifwCmd += "," + (*it)->Name;
++it;
}
}
else if (!DependentPackages.empty())
{
ifwCmd += " -i ";
// Binary
std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
while(bit != BinaryPackages.end())
{
ifwCmd += (*bit)->Name + ",";
++bit;
} else if (!DependentPackages.empty()) {
ifwCmd += " -i ";
// Binary
std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
while (bit != BinaryPackages.end()) {
ifwCmd += (*bit)->Name + ",";
++bit;
}
// Depend
DependenceMap::iterator it = DependentPackages.begin();
ifwCmd += it->second.Name;
++it;
while(it != DependentPackages.end())
{
ifwCmd += "," + it->second.Name;
// Depend
DependenceMap::iterator it = DependentPackages.begin();
ifwCmd += it->second.Name;
++it;
while (it != DependentPackages.end()) {
ifwCmd += "," + it->second.Name;
++it;
}
}
// TODO: set correct name for multipackages
if (!this->packageFileNames.empty())
{
ifwCmd += " " + packageFileNames[0];
// TODO: set correct name for multipackages
if (!this->packageFileNames.empty()) {
ifwCmd += " " + packageFileNames[0];
} else {
ifwCmd += " installer";
}
else
{
ifwCmd += " installer";
}
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 )
{
cmGeneratedFileStream ofs(ifwTmpFile.c_str());
ofs << "# Run command: " << ifwCmd << std::endl
<< "# Output:" << std::endl
<< output << std::endl;
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
<< ifwCmd << std::endl
<< "Please check " << ifwTmpFile << " for errors"
<< std::endl);
return 0;
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) {
cmGeneratedFileStream ofs(ifwTmpFile.c_str());
ofs << "# Run command: " << ifwCmd << std::endl
<< "# Output:" << std::endl
<< output << std::endl;
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
<< ifwCmd << std::endl
<< "Please check " << ifwTmpFile << " for errors"
<< std::endl);
return 0;
}
}
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";
}
}
this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
}
const char *cmCPackIFWGenerator::GetOutputExtension()
const char* cmCPackIFWGenerator::GetOutputExtension()
{
return ExecutableSuffix.c_str();
}
@ -246,56 +219,43 @@ 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"
<< std::endl);
<< std::endl);
return 0;
}
}
// 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";
}
}
// Variables that Change Behavior
@ -304,158 +264,130 @@ 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;
}
}
if (!Installer.Repositories.empty() && RepoGen.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find QtIFW repository generator \"repogen\": "
"likely it is not installed, or not in your PATH"
<< std::endl);
return 0;
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Cannot find QtIFW repository generator \"repogen\": "
"likely it is not installed, or not in your PATH"
<< std::endl);
return 0;
}
// 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/";
const std::string suffix = "/data";
if (componentPackageMethod == ONE_PACKAGE) {
return std::string(prefix + GetRootPackageName() + suffix);
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 << "\""
<< std::endl);
}
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,123 +417,106 @@ 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)
{
name = package->Name + "." + name;
}
}
if (dot) {
name = package->Name + "." + name;
}
}
return name;
}
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)
{
dot = false;
}
if(dot)
{
name = package->Name + "." + name;
}
}
bool dot = !ResolveDuplicateNames;
if (dot && name.substr(0, package->Name.size()) == package->Name) {
dot = false;
}
if (dot) {
name = package->Name + "." + name;
}
}
return name;
}
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"))
{
<< "for QtIFW ";
if (IsVersionLess("2.0")) {
comment << "less 2.0";
}
else
{
} else {
comment << FrameworkVersion;
}
}
comment << " tools at " << cmTimestamp().CurrentTime("", true);
xout.Comment(comment.str().c_str());
}

22
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,9 +90,8 @@ protected:
*
* @return Pointer to component
*/
virtual cmCPackComponent* GetComponent(
const std::string& projectName,
const std::string& componentName);
virtual cmCPackComponent* GetComponent(const std::string& projectName,
const std::string& componentName);
/**
* @brief Get group of component
@ -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);

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

@ -20,310 +20,239 @@
#include <cmXMLWriter.h>
#ifdef cmCPackLogger
# undef cmCPackLogger
#undef cmCPackLogger
#endif
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
if(Generator) { \
Generator->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} \
} while ( 0 )
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
if (Generator) { \
Generator->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} \
} 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)
+ "_";
// Url
if (const char* url = GetOption(prefix + "URL"))
{
Repo.Url = url;
}
else
{
Repo.Url = "";
}
// Enabled
if (IsOn(prefix + "DISABLED"))
{
Repo.Enabled = "0";
}
else
{
Repo.Enabled = "";
}
// Username
if (const char* username = GetOption(prefix + "USERNAME"))
{
Repo.Username = username;
}
else
{
Repo.Username = "";
}
// Password
if (const char* password = GetOption(prefix + "PASSWORD"))
{
Repo.Password = password;
}
else
{
Repo.Password = "";
}
// DisplayName
if (const char* displayName = GetOption(prefix + "DISPLAY_NAME"))
{
Repo.DisplayName = displayName;
}
else
{
Repo.DisplayName = "";
}
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")) {
Repo.Url = url;
} else {
Repo.Url = "";
}
// Enabled
if (IsOn(prefix + "DISABLED")) {
Repo.Enabled = "0";
} else {
Repo.Enabled = "";
}
// Username
if (const char* username = GetOption(prefix + "USERNAME")) {
Repo.Username = username;
} else {
Repo.Username = "";
}
// Password
if (const char* password = GetOption(prefix + "PASSWORD")) {
Repo.Password = password;
} else {
Repo.Password = "";
}
// DisplayName
if (const char* displayName = GetOption(prefix + "DISPLAY_NAME")) {
Repo.DisplayName = displayName;
} else {
Repo.DisplayName = "";
}
if(!Repo.Url.empty())
{
Repositories.push_back(Repo);
}
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;
}
}
}
void cmCPackIFWInstaller::GenerateInstallerFile()
{
// Lazy directory initialization
if(Directory.empty() && Generator)
{
if (Directory.empty() && Generator) {
Directory = Generator->toplevel;
}
}
// Output stream
cmGeneratedFileStream fout((Directory + "/config/config.xml").data());
@ -339,140 +268,118 @@ 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());
xout.Element("Logo", name);
}
}
// 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())
{
xout.Element("Username", rit->Username);
}
// Password
if(!rit->Password.empty())
{
xout.Element("Password", rit->Password);
}
// DisplayName
if(!rit->DisplayName.empty())
{
xout.Element("DisplayName", rit->DisplayName);
}
xout.EndElement();
}
xout.EndElement();
// Username
if (!rit->Username.empty()) {
xout.Element("Username", rit->Username);
}
// Password
if (!rit->Password.empty()) {
xout.Element("Password", rit->Password);
}
// DisplayName
if (!rit->DisplayName.empty()) {
xout.Element("DisplayName", rit->DisplayName);
}
xout.EndElement();
}
xout.EndElement();
}
// 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()) {
xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
}
else
{
if(!AllowNonAsciiCharacters.empty())
{
xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
}
if(!AllowSpaceInPath.empty())
{
xout.Element("AllowSpaceInPath", AllowSpaceInPath);
}
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());
xout.Element("ControlScript", name);
}
}
xout.EndElement();
xout.EndDocument();
@ -480,36 +387,32 @@ 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();
return;
}
}
// 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();

389
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) { \
Generator->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} \
} while ( 0 )
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
if (Generator) { \
Generator->Logger->Log(logType, __FILE__, __LINE__, \
cmCPackLog_msg.str().c_str()); \
} \
} while (0)
//---------------------------------------------------------- CompareStruct ---
cmCPackIFWPackage::CompareStruct::CompareStruct() :
Type(CompareNone)
cmCPackIFWPackage::CompareStruct::CompareStruct()
: Type(CompareNone)
{
}
@ -46,64 +46,47 @@ 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);
}
}
Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
}
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 += ">";
}
}
result += Compare.Value;
@ -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,51 +160,42 @@ 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";
}
}
ForcedInstallation = "true";
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,81 +204,65 @@ 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);
}
AlienDependencies.insert(&depRef);
}
}
}
// 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"
<< " should contain pairs of <display_name> and <file_path>."
<< std::endl);
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();
}
}
}
// Priority
if(const char* option = this->GetOption(prefix + "PRIORITY"))
{
if (const char* option = this->GetOption(prefix + "PRIORITY")) {
SortingPriority = option;
}
}
// Default
Default = component->IsDisabledByDefault ? "false" : "true";
@ -318,87 +276,74 @@ 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"
<< " should contain pairs of <display_name> and <file_path>."
<< std::endl);
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();
}
}
}
// 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");
group.IsExpandedByDefault = IsOn(prefix + "EXPANDED");
@ -406,14 +351,11 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
group.Name = groupName;
if(Generator)
{
if (Generator) {
Name = Generator->GetGroupPackageName(&group);
}
else
{
} else {
Name = group.Name;
}
}
return ConfigureFromGroup(&group);
}
@ -421,17 +363,13 @@ 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;
}
}
}
// Output stream
cmGeneratedFileStream fout((Directory + "/meta/package.xml").data());
@ -448,98 +386,83 @@ 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());
xout.Element("Script", name);
}
}
// 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;
}
xout.Element("Dependencies", dependencies.str());
}
xout.Element("Dependencies", dependencies.str());
}
// 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]);
xout.EndElement();
}
}
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);
}
}
xout.EndElement();
xout.EndDocument();
}
void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter &xout)
void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter& xout)
{
if(Generator) Generator->WriteGeneratedByToStrim(xout);
if (Generator)
Generator->WriteGeneratedByToStrim(xout);
}

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

@ -31,11 +31,11 @@ public:
enum CompareTypes
{
CompareNone = 0x0,
CompareEqual = 0x1,
CompareLess = 0x2,
CompareLessOrEqual = 0x3,
CompareGreater = 0x4,
CompareNone = 0x0,
CompareEqual = 0x1,
CompareLess = 0x2,
CompareLessOrEqual = 0x3,
CompareGreater = 0x4,
CompareGreaterOrEqual = 0x5
};
@ -50,17 +50,17 @@ 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;
}
}
};
public:
@ -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();

92
Source/CPack/OSXScriptLauncher.cxx
View File

@ -20,72 +20,65 @@
// For the PATH_MAX constant
#include <sys/syslimits.h>
#define DebugError(x) \
ofs << x << std::endl; \
#define DebugError(x) \
ofs << x << std::endl; \
std::cout << x << std::endl
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);
cmsysProcess* cp = cmsysProcess_New();
@ -98,49 +91,38 @@ 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] = ' ';
}
}
std::cout.write(data, length);
}
std::cout.write(data, length);
}
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;
}
}
cmsysProcess_Delete(cp);

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

File diff suppressed because it is too large Load Diff

83
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,32 +79,25 @@ 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,
std::string const& featureId,
cmWIXShortcuts const& shortcuts,
bool emitUninstallShortcut,
cmWIXFilesSourceWriter& fileDefinitions,
cmWIXFeaturesSourceWriter& featureDefinitions);
bool CreateShortcuts(std::string const& cpackComponentName,
std::string const& featureId,
cmWIXShortcuts const& shortcuts,
bool emitUninstallShortcut,
cmWIXFilesSourceWriter& fileDefinitions,
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;

76
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,23 +30,20 @@ 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;
}
}
std::string user_and_domain = entry.substr(0, pos);
std::string permission_string = entry.substr(pos + 1);
@ -56,46 +51,38 @@ 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;
}
}
std::vector<std::string> permissions =
cmSystemTools::tokenize(permission_string, ",");
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]));
}
cmSystemTools::TrimWhitespace(permissions[i]));
}
this->SourceWriter.EndElement("Permission");
}
void cmWIXAccessControlList::ReportError(
std::string const& entry,
std::string const& message)
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,23 +115,22 @@ 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());
}
}
this->SourceWriter.AddAttribute(name, "yes");
}

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

@ -21,10 +21,9 @@
class cmWIXAccessControlList
{
public:
cmWIXAccessControlList(
cmCPackLog *logger,
cmInstalledFile const& installedFile,
cmWIXSourceWriter &sourceWriter);
cmWIXAccessControlList(cmCPackLog* logger,
cmInstalledFile const& installedFile,
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

29
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,25 +59,20 @@ 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());
}
}
AddAttribute("Name", installRoot[i]);
}
@ -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");
}
}
}

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

@ -26,7 +26,7 @@ class cmWIXDirectoriesSourceWriter : public cmWIXSourceWriter
{
public:
cmWIXDirectoriesSourceWriter(cmCPackLog* logger,
std::string const& filename);
std::string const& filename);
void EmitStartMenuFolder(std::string const& startMenuFolder);
@ -35,8 +35,8 @@ public:
void EmitStartupFolder();
size_t BeginInstallationPrefixDirectory(
std::string const& programFilesFolderId,
std::string const& installRootString);
std::string const& programFilesFolderId,
std::string const& installRootString);
void EndInstallationPrefixDirectory(size_t size);
};

43
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");
@ -29,7 +27,7 @@ void cmWIXFeaturesSourceWriter::CreateCMakePackageRegistryEntry(
AddAttribute("Guid", "*");
std::string registryKey =
std::string("Software\\Kitware\\CMake\\Packages\\") + package;
std::string("Software\\Kitware\\CMake\\Packages\\") + package;
BeginElement("RegistryValue");
AddAttribute("Root", "HKLM");
@ -49,25 +47,24 @@ 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);
}
}
EndElement("Feature");
}
@ -81,15 +78,13 @@ 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");
}
}
EndElement("Feature");
}

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

@ -23,12 +23,10 @@
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,
std::string const& upgradeGuid);
void CreateCMakePackageRegistryEntry(std::string const& package,
std::string const& upgradeGuid);
void EmitFeatureForComponentGroup(const cmCPackComponentGroup& group);

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

@ -21,25 +21,22 @@
#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,
cmWIXShortcut const& shortcut,
std::string const& shortcutPrefix,
size_t shortcutIndex)
void cmWIXFilesSourceWriter::EmitShortcut(std::string const& id,
cmWIXShortcut const& shortcut,
std::string const& shortcutPrefix,
size_t shortcutIndex)
{
std::stringstream shortcutId;
shortcutId << shortcutPrefix << id;
if(shortcutIndex > 0)
{
shortcutId << "_" << shortcutIndex;
}
if (shortcutIndex > 0) {
shortcutId << "_" << shortcutIndex;
}
std::string fileId = std::string("CM_F") + id;
@ -61,15 +58,13 @@ 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())
{
valueName = cpackComponentName + "_";
}
if (!cpackComponentName.empty()) {
valueName = cpackComponentName + "_";
}
valueName += "installed";
valueName += suffix;
@ -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,11 +106,10 @@ std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
BeginElement("CreateFolder");
if(installedFile)
{
if (installedFile) {
cmWIXAccessControlList acl(Logger, *installedFile, *this);
acl.Apply();
}
}
EndElement("CreateFolder");
EndElement("Component");
@ -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,17 +133,14 @@ 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"))
{
AddAttribute("Permanent", "yes");
}
}
if (installedFile->GetPropertyAsBool("CPACK_PERMANENT")) {
AddAttribute("Permanent", "yes");
}
}
BeginElement("File");
AddAttribute("Id", fileId);
@ -163,16 +150,14 @@ 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();
}
}
patch.ApplyFragment(fileId, *this);
EndElement("File");

35
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,
std::string const& cpackComponentName,
std::string const& suffix);
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 const& guid,
cmInstalledFile const* installedFile);
std::string EmitComponentCreateFolder(std::string const& directoryId,
std::string const& guid,
cmInstalledFile const* installedFile);
std::string EmitComponentFile(
std::string const& directoryId,
std::string const& id,
std::string const& filePath,
cmWIXPatch &patch,
cmInstalledFile const* installedFile);
std::string EmitComponentFile(std::string const& directoryId,
std::string const& id,
std::string const& filePath, cmWIXPatch& patch,
cmInstalledFile const* installedFile);
};
#endif

86
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,36 +45,35 @@ 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())
{
case cmWIXPatchNode::ELEMENT:
ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer);
break;
case cmWIXPatchNode::TEXT:
writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text);
break;
switch (node->type()) {
case cmWIXPatchNode::ELEMENT:
ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer);
break;
case cmWIXPatchNode::TEXT:
writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text);
break;
}
}
}
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);
}
}
this->ApplyElementChildren(element, writer);
@ -86,26 +83,23 @@ 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 += ", ";
}
}
fragmentList += "'";
fragmentList += i->first;
fragmentList += "'";
}
}
if(!fragmentList.empty())
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Some XML patch fragments did not have matching IDs: " <<
fragmentList << std::endl);
return false;
}
if (!fragmentList.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR,
"Some XML patch fragments did not have matching IDs: "
<< fragmentList << std::endl);
return false;
}
return true;
}

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

@ -34,15 +34,14 @@ public:
private:
void ApplyElementChildren(const cmWIXPatchElement& element,
cmWIXSourceWriter& writer);
cmWIXSourceWriter& writer);
void ApplyElement(const cmWIXPatchElement& element,
cmWIXSourceWriter& writer);
cmWIXSourceWriter& writer);
cmCPackLog* Logger;
cmWIXPatchParser::fragment_map_t Fragments;
};
#endif

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

@ -28,149 +28,124 @@ 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")
{
State = INSIDE_FRAGMENT;
StartFragment(atts);
}
else
{
ReportValidationError("Expected 'CPackWixFragment' element");
}
} else if (State == BEGIN_FRAGMENTS) {
if (name == "CPackWiXFragment") {
State = INSIDE_FRAGMENT;
StartFragment(atts);
} 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;
parent.children.push_back(element);
cmWIXPatchElement* element = new cmWIXPatchElement;
parent.children.push_back(element);
element->name = name;
element->name = name;
for(size_t i = 0; atts[i]; i += 2)
{
std::string key = atts[i];
std::string value = atts[i+1];
for (size_t i = 0; atts[i]; i += 2) {
std::string key = atts[i];
std::string value = atts[i + 1];
element->attributes[key] = value;
}
ElementStack.push_back(element);
element->attributes[key] = value;
}
ElementStack.push_back(element);
}
}
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'");
}
}
}
}
void cmWIXPatchParser::EndElement(const std::string& name)
{
if(State == INSIDE_FRAGMENT)
{
if(name == "CPackWiXFragment")
{
State = BEGIN_FRAGMENTS;
ElementStack.clear();
}
else
{
ElementStack.pop_back();
}
if (State == INSIDE_FRAGMENT) {
if (name == "CPackWiXFragment") {
State = BEGIN_FRAGMENTS;
ElementStack.clear();
} else {
ElementStack.pop_back();
}
}
}
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);
}
}
}
}
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);

126
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,74 +37,50 @@ 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)
{
case '\\':
File << "\\\\";
break;
case '{':
File << "\\{";
break;
case '}':
File << "\\}";
break;
case '\n':
File << "\\par\r\n";
break;
case '\r':
continue;
default:
{
if(c <= 0x7F)
{
switch (c) {
case '\\':
File << "\\\\";
break;
case '{':
File << "\\{";
break;
case '}':
File << "\\}";
break;
case '\n':
File << "\\par\r\n";
break;
case '\r':
continue;
default: {
if (c <= 0x7F) {
File << c;
}
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)
);
i += 2;
}
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)
);
i += 3;
}
else
{
EmitInvalidCodepoint(c);
}
} 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));
i += 2;
} 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));
i += 3;
} else {
EmitInvalidCodepoint(c);
}
}
break;
}
} break;
}
}
}
void cmWIXRichTextFormatWriter::WriteHeader()
@ -190,33 +166,25 @@ 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);
}
}
}
void cmWIXRichTextFormatWriter::EmitUnicodeSurrogate(int c)
{
ControlWord("u");
if(c <= 32767)
{
if (c <= 32767) {
File << c;
}
else
{
} else {
File << (c - 65536);
}
}
File << "?";
}

78
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,25 +26,22 @@ 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;
}
}
shortcut_id_map_t const& id_map = i->second;
std::string shortcutPrefix;
std::string registrySuffix;
switch(type)
{
switch (type) {
case START_MENU:
shortcutPrefix = "CM_S";
break;
@ -58,68 +55,61 @@ bool cmWIXShortcuts::EmitShortcuts(
break;
default:
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,
std::string const& directoryId,
cmInstalledFile const& installedFile)
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,
std::string const& directoryId,
cmInstalledFile const& installedFile)
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;
insert(type, id, shortcut);
}
}
}

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

@ -45,26 +45,23 @@ public:
bool empty(Type type) const;
bool EmitShortcuts(
Type type,
std::string const& registryKey,
std::string const& cpackComponentName,
cmWIXFilesSourceWriter& fileDefinitions) const;
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,
std::string const& id,
std::string const& directoryId,
cmInstalledFile const& installedFile);
void CreateFromProperty(std::string const& propertyName, Type type,
std::string const& id,
std::string const& directoryId,
cmInstalledFile const& installedFile);
shortcut_type_map_t Shortcuts;
shortcut_id_map_t EmptyIdMap;

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

@ -17,46 +17,41 @@
#include <windows.h>
cmWIXSourceWriter::cmWIXSourceWriter(cmCPackLog* logger,
std::string const& filename,
bool isIncludeFile):
Logger(logger),
File(filename.c_str()),
State(DEFAULT),
SourceFilename(filename)
std::string const& filename,
bool isIncludeFile)
: Logger(logger)
, File(filename.c_str())
, State(DEFAULT)
, SourceFilename(filename)
{
WriteXMLDeclaration();
if(isIncludeFile)
{
if (isIncludeFile) {
BeginElement("Include");
}
else
{
} else {
BeginElement("Wix");
}
}
AddAttribute("xmlns", "http://schemas.microsoft.com/wix/2006/wi");
}
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;
}
}
EndElement(Elements.back());
}
void cmWIXSourceWriter::BeginElement(std::string const& name)
{
if(State == BEGIN)
{
if (State == BEGIN) {
File << ">";
}
}
File << "\n";
Indent(Elements.size());
@ -68,33 +63,27 @@ 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 << "/>";
}
}
Elements.pop_back();
State = DEFAULT;
@ -102,30 +91,27 @@ 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;
}
}
File << this->EscapeAttributeValue(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 << ">";
}
}
File << "\n";
Indent(Elements.size());
@ -134,21 +120,20 @@ 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);
}
}
}
std::string cmWIXSourceWriter::CMakeEncodingToUtf8(std::string const& value)
@ -156,43 +141,38 @@ 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()),
&utf16[0], static_cast<int>(utf16.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();
}
}
std::vector<char> utf8(utf8ByteCount);
WideCharToMultiByte(CP_UTF8, 0, &utf16[0], static_cast<int>(utf16.size()),
&utf8[0], static_cast<int>(utf8.size()), 0, 0);
&utf8[0], static_cast<int>(utf8.size()), 0, 0);
return std::string(&utf8[0], utf8.size());
#endif
}
void cmWIXSourceWriter::WriteXMLDeclaration()
{
File << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
@ -200,41 +180,37 @@ 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)
{
case '<':
result += "&lt;";
break;
case '>':
result += "&gt;";
break;
case '&':
result +="&amp;";
break;
case '"':
result += "&quot;";
break;
default:
result += c;
break;
}
switch (c) {
case '<':
result += "&lt;";
break;
case '>':
result += "&gt;";
break;
case '&':
result += "&amp;";
break;
case '"':
result += "&quot;";
break;
default:
result += c;
break;
}
}
return result;
}

17
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,19 +37,18 @@ 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);
protected:
cmCPackLog* Logger;
cmCPackLog* Logger;
private:
enum State

3
Source/CPack/cmCPack7zGenerator.cxx
View File

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

238
Source/CPack/cmCPackArchiveGenerator.cxx
View File

@ -25,7 +25,7 @@
#include <cmsys/SystemTools.hxx>
cmCPackArchiveGenerator::cmCPackArchiveGenerator(cmArchiveWrite::Compress t,
std::string const& format)
std::string const& format)
{
this->Compress = t;
this->ArchiveFormat = format;
@ -40,48 +40,41 @@ 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;
}
}
}
// Go back to previous dir
cmSystemTools::ChangeDirectory(dir);
return 1;
@ -92,26 +85,21 @@ 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)) \
{ \
cmCPackLogger(cmCPackLog::LOG_ERROR, \
"Problem to generate Header for archive < " \
<< filename \
<< ">." << std::endl); \
return 0; \
} \
cmArchiveWrite archive(gf,this->Compress, this->ArchiveFormat); \
if (!archive) \
{ \
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < " \
<< filename \
<< ">. ERROR =" \
<< archive.GetError() \
<< std::endl); \
return 0; \
#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); \
return 0; \
} \
cmArchiveWrite archive(gf, this->Compress, this->ArchiveFormat); \
if (!archive) { \
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < " \
<< filename << ">. ERROR =" << archive.GetError() \
<< std::endl); \
return 0; \
}
int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
@ -119,99 +107,86 @@ 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 += "/"+
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
compGIt->first,
true)
+ this->GetOutputExtension();
std::string packageFileName = std::string(toplevel);
packageFileName += "/" +
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
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
packageFileNames.push_back(packageFileName);
}
}
// 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 <"
<< compIt->second.Name
<< "> does not belong to any group, package it separately."
<< std::endl);
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);
}
}
}
}
// 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 += "/"+
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);
}
}
}
return 1;
}
@ -220,23 +195,22 @@ 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);
<< std::endl);
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.
return 1;
@ -244,50 +218,42 @@ 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;
}
}
}
cmSystemTools::ChangeDirectory(dir);
// The destructor of cmArchiveWrite will close and finish the write
return 1;
@ -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

188
Source/CPack/cmCPackBundleGenerator.cxx
View File

@ -28,29 +28,25 @@ 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);
"CPACK_BUNDLE_NAME must be set to use the Bundle generator."
<< std::endl);
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"
<< std::endl);
if (codesign_path.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate codesign command"
<< std::endl);
return 0;
}
this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
}
this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
}
return this->Superclass::InitializeInternal();
}
@ -69,42 +65,40 @@ 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."
<< std::endl);
? 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."
<< std::endl);
? 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."
<< std::endl);
? this->GetOption("CPACK_BUNDLE_ICON")
: "";
if (cpack_bundle_icon.empty()) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_ICON must be set."
<< std::endl);
return 0;
}
}
// 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,30 +106,33 @@ 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);
<< std::endl);
return 0;
}
}
// Install a user-provided bundle icon ...
std::ostringstream icon_source;
@ -144,52 +141,48 @@ 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);
<< std::endl);
return 0;
}
}
// 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."
<< std::endl);
<< std::endl);
return 0;
}
}
cmSystemTools::SetPermissions(command_target.str().c_str(), 0777);
}
}
return 1;
}
int cmCPackBundleGenerator::PackageFiles()
{
if(!this->ConstructBundle())
{
if (!this->ConstructBundle()) {
return 0;
}
}
if(!this->SignBundle(toplevel))
{
if (!this->SignBundle(toplevel)) {
return 0;
}
}
return this->CreateDMG(toplevel, packageFileNames[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,15 +234,14 @@ 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;
}
}
}
// sign main binary
std::ostringstream temp_sign_binary_cmd;
@ -259,43 +250,42 @@ 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;
}
}
// sign app bundle
std::ostringstream temp_codesign_cmd;
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"
<< std::endl);
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")
<< std::endl);
(this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")
? "with entitlement sandboxing"
: "without entitlement sandboxing")
<< std::endl);
}
return 1;

18
Source/CPack/cmCPackComponentGroup.cxx
View File

@ -18,28 +18,26 @@
#include <vector>
unsigned long cmCPackComponent::GetInstalledSize(
const std::string& installDir) const
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;
this->TotalSize += cmSystemTools::FileLength(path);
}
}
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;

25
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;
@ -54,14 +53,13 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
// create an extra scope to force the stream
// 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)
{
// remove the temp dir and replace with /usr
ofs << (*i).substr(tempdir.size()) << "\n";
cmGeneratedFileStream ofs(manifestFile.c_str());
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";
}
ofs << manifest << "\n";
ofs << manifest << "\n";
}
// add the manifest file to the list of all files
files.push_back(manifestFile);
@ -73,14 +71,13 @@ 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"
<< std::endl);
}
<< std::endl);
}
this->OutputExtension += patchNumber;
this->OutputExtension += ".tar.bz2";
return this->OutputExtension.c_str();

1
Source/CPack/cmCPackCygwinBinaryGenerator.h
View File

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

76
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,10 +55,9 @@ 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
// and the CPACK_CYGWIN_PATCH_FILE and CPACK_TOPLEVEL_DIRECTORY
// files
@ -76,47 +75,41 @@ 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(
this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
this->GetOption("CPACK_TOPLEVEL_DIRECTORY")))
{
}
if (!cmSystemTools::CopyFileAlways(
this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
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");
<< 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(
this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
this->GetOption("CPACK_TOPLEVEL_DIRECTORY")))
{
if (!cmSystemTools::CopyFileAlways(
this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
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");
<< 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");
<< " not specified, defaulting to 1\n");
patch = "1";
}
}
outerTarFile += patch;
outerTarFile += "-src.tar.bz2";
std::string tmpDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@ -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,10 +139,9 @@ 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,14 +156,12 @@ 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");
<< " not specified, defaulting to 1\n");
patch = "1";
}
}
this->OutputExtension += patch;
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();

787
Source/CPack/cmCPackDebGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

9
Source/CPack/cmCPackDebGenerator.h
View File

@ -31,18 +31,18 @@ public:
virtual ~cmCPackDebGenerator();
static bool CanGenerate()
{
{
#ifdef __APPLE__
// on MacOS enable CPackDeb iff dpkg is found
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;
#endif
}
}
protected:
virtual int InitializeInternal();
@ -65,12 +65,11 @@ protected:
virtual const char* GetOutputExtension() { return ".deb"; }
virtual bool SupportsComponentInstallation() const;
virtual std::string GetComponentInstallDirNameSuffix(
const std::string& componentName);
const std::string& componentName);
private:
int createDeb();
std::vector<std::string> packageFiles;
};
#endif

762
Source/CPack/cmCPackDragNDropGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

14
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);
@ -51,11 +50,10 @@ private:
bool singleLicense;
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 licenseLanguage, std::string licenseFile,
std::string* error);
bool BreakLongLine(const std::string& line, std::vector<std::string>& lines,
std::string* error);
void EscapeQuotesAndBackslashes(std::string& line);
};

1393
Source/CPack/cmCPackGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

54
Source/CPack/cmCPackGenerator.h
View File

@ -20,29 +20,29 @@
#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); \
static cmCPackGenerator* CreateGenerator() { return new klass; } \
#define cmCPackTypeMacro(klass, superclass) \
cmTypeMacro(klass, superclass); \
static cmCPackGenerator* CreateGenerator() { return new klass; } \
class cmCPackTypeMacro_UseTrailingSemicolon
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
this->Logger->Log(logType, __FILE__, __LINE__,\
cmCPackLog_msg.str().c_str());\
} while ( 0 )
#define cmCPackLogger(logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
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.
@ -157,7 +159,7 @@ protected:
* default is "componentName"
*/
virtual std::string GetComponentInstallDirNameSuffix(
const std::string& componentName);
const std::string& componentName);
/**
* CPack specific generator may mangle CPACK_PACKAGE_FILE_NAME
@ -169,9 +171,8 @@ protected:
* false otherwise
*/
virtual std::string GetComponentPackageFileName(
const std::string& initialPackageFileName,
const std::string& groupOrComponentName,
bool isGroupName);
const std::string& initialPackageFileName,
const std::string& groupOrComponentName, bool isGroupName);
/**
* Package the list of files and/or components which
@ -188,11 +189,10 @@ protected:
virtual std::string FindTemplate(const char* name);
virtual bool ConfigureFile(const char* inName, const char* outName,
bool copyOnly = false);
bool copyOnly = false);
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;
};

178
Source/CPack/cmCPackGeneratorFactory.cxx
View File

@ -24,134 +24,115 @@
#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())
{
cmCPackTGZGenerator::CreateGenerator);
}
if (cmCPackTXZGenerator::CanGenerate()) {
this->RegisterGenerator("TXZ", "Tar XZ compression",
cmCPackTXZGenerator::CreateGenerator);
}
if (cmCPackSTGZGenerator::CanGenerate())
{
cmCPackTXZGenerator::CreateGenerator);
}
if (cmCPackSTGZGenerator::CanGenerate()) {
this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
cmCPackSTGZGenerator::CreateGenerator);
}
if (cmCPackNSISGenerator::CanGenerate())
{
cmCPackSTGZGenerator::CreateGenerator);
}
if (cmCPackNSISGenerator::CanGenerate()) {
this->RegisterGenerator("NSIS", "Null Soft Installer",
cmCPackNSISGenerator::CreateGenerator);
cmCPackNSISGenerator::CreateGenerator);
this->RegisterGenerator("NSIS64", "Null Soft Installer (64-bit)",
cmCPackNSISGenerator::CreateGenerator64);
}
if (cmCPackIFWGenerator::CanGenerate())
{
cmCPackNSISGenerator::CreateGenerator64);
}
if (cmCPackIFWGenerator::CanGenerate()) {
this->RegisterGenerator("IFW", "Qt Installer Framework",
cmCPackIFWGenerator::CreateGenerator);
}
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())
{
cmCPackZIPGenerator::CreateGenerator);
}
if (cmCPack7zGenerator::CanGenerate()) {
this->RegisterGenerator("7Z", "7-Zip file format",
cmCPack7zGenerator::CreateGenerator);
}
cmCPack7zGenerator::CreateGenerator);
}
#ifdef _WIN32
if (cmCPackWIXGenerator::CanGenerate())
{
if (cmCPackWIXGenerator::CanGenerate()) {
this->RegisterGenerator("WIX", "MSI file format via WiX tools",
cmCPackWIXGenerator::CreateGenerator);
}
cmCPackWIXGenerator::CreateGenerator);
}
#endif
if (cmCPackTarBZip2Generator::CanGenerate())
{
if (cmCPackTarBZip2Generator::CanGenerate()) {
this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
cmCPackTarBZip2Generator::CreateGenerator);
}
if (cmCPackTarCompressGenerator::CanGenerate())
{
cmCPackTarBZip2Generator::CreateGenerator);
}
if (cmCPackTarCompressGenerator::CanGenerate()) {
this->RegisterGenerator("TZ", "Tar Compress compression",
cmCPackTarCompressGenerator::CreateGenerator);
}
cmCPackTarCompressGenerator::CreateGenerator);
}
#ifdef __APPLE__
if (cmCPackDragNDropGenerator::CanGenerate())
{
if (cmCPackDragNDropGenerator::CanGenerate()) {
this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
cmCPackDragNDropGenerator::CreateGenerator);
}
if (cmCPackBundleGenerator::CanGenerate())
{
cmCPackDragNDropGenerator::CreateGenerator);
}
if (cmCPackBundleGenerator::CanGenerate()) {
this->RegisterGenerator("Bundle", "Mac OSX bundle",
cmCPackBundleGenerator::CreateGenerator);
}
if (cmCPackPackageMakerGenerator::CanGenerate())
{
cmCPackBundleGenerator::CreateGenerator);
}
if (cmCPackPackageMakerGenerator::CanGenerate()) {
this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
cmCPackPackageMakerGenerator::CreateGenerator);
}
if (cmCPackOSXX11Generator::CanGenerate())
{
cmCPackPackageMakerGenerator::CreateGenerator);
}
if (cmCPackOSXX11Generator::CanGenerate()) {
this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
cmCPackOSXX11Generator::CreateGenerator);
}
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())
{
cmCPackDebGenerator::CreateGenerator);
}
if (cmCPackRPMGenerator::CanGenerate()) {
this->RegisterGenerator("RPM", "RPM packages",
cmCPackRPMGenerator::CreateGenerator);
}
cmCPackRPMGenerator::CreateGenerator);
}
#endif
}
@ -161,13 +142,12 @@ cmCPackGeneratorFactory::~cmCPackGeneratorFactory()
}
cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
const std::string& name)
const std::string& name)
{
cmCPackGenerator* gen = this->NewGeneratorInternal(name);
if ( !gen )
{
if (!gen) {
return 0;
}
}
this->Generators.push_back(gen);
gen->SetLogger(this->Logger);
return gen;
@ -176,25 +156,23 @@ 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);
"Cannot register generator" << std::endl);
return;
}
}
this->GeneratorCreators[name] = createGenerator;
this->GeneratorDescriptions[name] = generatorDescription;
}

8
Source/CPack/cmCPackGeneratorFactory.h
View File

@ -37,14 +37,16 @@ public:
typedef cmCPackGenerator* CreateGeneratorCall();
void RegisterGenerator(const std::string& name,
const char* generatorDescription,
CreateGeneratorCall* createGenerator);
const char* generatorDescription,
CreateGeneratorCall* createGenerator);
void SetLogger(cmCPackLog* logger) { this->Logger = logger; }
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);

180
Source/CPack/cmCPackLog.cxx
View File

@ -39,37 +39,33 @@ cmCPackLog::~cmCPackLog()
void cmCPackLog::SetLogOutputStream(std::ostream* os)
{
if ( this->LogOutputCleanup && this->LogOutput )
{
if (this->LogOutputCleanup && this->LogOutput) {
delete this->LogOutput;
}
}
this->LogOutputCleanup = false;
this->LogOutput = 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;
@ -77,144 +73,118 @@ void cmCPackLog::Log(int tag, const char* file, int line,
// Display file and line number if debug
bool useFileAndLine = this->Debug;
bool output = false;
bool debug = false;
bool output = false;
bool debug = false;
bool warning = false;
bool error = false;
bool error = false;
bool verbose = false;
// 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 += ","; }
tagString = "VERBOSE";
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 += ","; }
tagString = "WARNING";
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 += ","; }
tagString = "ERROR";
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 += ","; }
tagString = "DEBUG";
if (needTagString) {
if (!tagString.empty()) {
tagString += ",";
}
useFileAndLine = true;
tagString = "DEBUG";
}
if ( tag & LOG_VERBOSE && this->Verbose )
{
useFileAndLine = true;
}
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();
}
}
}

47
Source/CPack/cmCPackLog.h
View File

@ -15,24 +15,23 @@
#include "cmObject.h"
#define cmCPack_Log(ctSelf, logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
(ctSelf)->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str());\
} while ( 0 )
#define cmCPack_Log(ctSelf, logType, msg) \
do { \
std::ostringstream cmCPackLog_msg; \
cmCPackLog_msg << msg; \
(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,
@ -56,19 +56,19 @@ public:
//! Various signatures for logging.
void Log(const char* file, int line, const char* msg)
{
{
this->Log(LOG_OUTPUT, file, line, msg);
}
}
void Log(const char* file, int line, const char* msg, size_t length)
{
{
this->Log(LOG_OUTPUT, file, line, msg, length);
}
}
void Log(int tag, const char* file, int line, const char* msg)
{
{
this->Log(tag, file, line, msg, strlen(msg));
}
}
void Log(int tag, const char* file, int line, const char* msg,
size_t length);
size_t length);
//! Set Verbose
void VerboseOn() { this->SetVerbose(true); }
@ -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();

868
Source/CPack/cmCPackNSISGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

29
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,14 +40,13 @@ 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"; }
bool GetListOfSubdirectories(const char* dir,
std::vector<std::string>& dirs);
std::vector<std::string>& dirs);
enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
virtual bool SupportsAbsoluteDestination() const;
@ -54,28 +55,24 @@ 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::ostringstream& macrosOut);
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::ostringstream& macrosOut);
std::string CreateComponentGroupDescription(cmCPackComponentGroup* group,
std::ostringstream& macrosOut);
/// Translations any newlines found in the string into \\r\\n, so that the
/// resulting string can be used within NSIS.

199
Source/CPack/cmCPackOSXX11Generator.cxx
View File

@ -36,41 +36,38 @@ 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);
<< cpackPackageExecutables << "." << std::endl);
std::ostringstream str;
std::ostringstream deleteStr;
std::vector<std::string> cpackPackageExecutablesVector;
cmSystemTools::ExpandListArgument(cpackPackageExecutables,
cpackPackageExecutablesVector);
if ( cpackPackageExecutablesVector.size() % 2 != 0 )
{
cmCPackLogger(cmCPackLog::LOG_ERROR,
cpackPackageExecutablesVector);
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 )
{
std::string cpackExecutableName = *it;
++ it;
this->SetOptionIfNotSet("CPACK_EXECUTABLE_NAME",
cpackExecutableName.c_str());
}
}
std::vector<std::string>::iterator it;
for (it = cpackPackageExecutablesVector.begin();
it != cpackPackageExecutablesVector.end(); ++it) {
std::string cpackExecutableName = *it;
++it;
this->SetOptionIfNotSet("CPACK_EXECUTABLE_NAME",
cpackExecutableName.c_str());
}
}
// 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,48 +87,45 @@ 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."
<< std::endl);
<< iconFile
<< ". Please check CPACK_PACKAGE_ICON setting."
<< std::endl);
return 0;
}
}
std::string destFileName = resourcesDirectory + "/" + iconFileName;
this->ConfigureFile(iconFile, destFileName.c_str(), true);
this->SetOptionIfNotSet("CPACK_APPLE_GUI_ICON", iconFileName.c_str());
}
}
std::string applicationsLinkName = diskImageDirectory + "/Applications";
cmSystemTools::CreateSymlink("/Applications", applicationsLinkName.c_str());
if (
!this->CopyResourcePlistFile("VolumeIcon.icns",
diskImageDirectory.c_str(),
".VolumeIcon.icns", true ) ||
!this->CopyResourcePlistFile("DS_Store", diskImageDirectory.c_str(),
".DS_Store", true ) ||
!this->CopyResourcePlistFile("background.png",
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) ||
!this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
this->GetOption("CPACK_PACKAGE_FILE_NAME"), true)
)
{
if (!this->CopyResourcePlistFile("VolumeIcon.icns",
diskImageDirectory.c_str(),
".VolumeIcon.icns", true) ||
!this->CopyResourcePlistFile("DS_Store", diskImageDirectory.c_str(),
".DS_Store", true) ||
!this->CopyResourcePlistFile("background.png",
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) ||
!this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
this->GetOption("CPACK_PACKAGE_FILE_NAME"),
true)) {
cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
<< std::endl);
<< std::endl);
return 0;
}
}
// Two of the files need to have execute permission, so ensure they do:
std::string runTimeScript = dir;
@ -143,21 +137,21 @@ 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;
std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@ -165,56 +159,52 @@ 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: "
<< dmgCmd.str().c_str() << std::endl);
<< 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,
&retVal, 0, this->GeneratorVerbose, 0);
if ( res && !retVal )
{
while (numTries > 0) {
res =
cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output, &output,
&retVal, 0, this->GeneratorVerbose, 0);
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;
<< "# 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);
<< dmgCmd.str().c_str() << std::endl
<< "Please check " << tmpFile.c_str() << " for errors"
<< std::endl);
return 0;
}
}
return 1;
}
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);
<< std::endl);
return 0;
}
}
this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
pkgPath.c_str());
@ -265,32 +255,31 @@ 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();
}
}
std::string destFileName = dir;
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;
};

760
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

206
Source/CPack/cmCPackRPMGenerator.cxx
View File

@ -25,24 +25,23 @@ 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
* rpmbuild scream on unwanted space in filename issue
* 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);
}
packageFileNames.push_back(fileNames.substr(pos1, pos2-pos1));
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));
}
int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
@ -69,38 +67,33 @@ 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()
);
GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
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;
}
}
return retval;
}
@ -115,56 +108,48 @@ 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();
}
}
return retval;
}
int cmCPackRPMGenerator::PackageComponentsAllInOne(
const std::string& compInstDirName)
const std::string& compInstDirName)
{
int retval = 1;
/* Reset package file name list it will be populated during the
@ -175,98 +160,84 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
cmCPackLogger(cmCPackLog::LOG_VERBOSE,
"Packaging all groups in one package..."
"(CPACK_COMPONENTS_ALL_[GROUPS_]IN_ONE_PACKAGE is set)"
<< std::endl);
<< std::endl);
// 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());
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;
this->SetOption("CPACK_RPM_PACKAGE_COMPONENT_PART_PATH",
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;
}
}
return retval;
}
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"))
{
return true;
}
else
{
return false;
}
{
if (IsOn("CPACK_RPM_COMPONENT_INSTALL")) {
return true;
} else {
return false;
}
}
std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
const std::string& componentName)
{
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))
{
return std::string(GetOption(groupVar));
}
else
{
return componentName;
}
std::string groupVar =
"CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
if (NULL != GetOption(groupVar)) {
return std::string(GetOption(groupVar));
} else {
return componentName;
}
}

6
Source/CPack/cmCPackRPMGenerator.h
View File

@ -35,7 +35,7 @@ public:
virtual ~cmCPackRPMGenerator();
static bool CanGenerate()
{
{
#ifdef __APPLE__
// on MacOS enable CPackRPM iff rpmbuild is found
std::vector<std::string> locations;
@ -46,7 +46,7 @@ public:
// legacy behavior on other systems
return true;
#endif
}
}
protected:
virtual int InitializeInternal();
@ -69,7 +69,7 @@ protected:
virtual const char* GetOutputExtension() { return ".rpm"; }
virtual bool SupportsComponentInstallation() const;
virtual std::string GetComponentInstallDirNameSuffix(
const std::string& componentName);
const std::string& componentName);
void AddGeneratedPackageNames();
};

61
Source/CPack/cmCPackSTGZGenerator.cxx
View File

@ -37,12 +37,11 @@ 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());
this->SetOptionIfNotSet("CPACK_AT_SIGN", "@");
@ -51,28 +50,26 @@ int cmCPackSTGZGenerator::InitializeInternal()
int cmCPackSTGZGenerator::PackageFiles()
{
bool retval = true;
if ( !this->Superclass::PackageFiles() )
{
bool retval = true;
if (!this->Superclass::PackageFiles()) {
return 0;
}
}
/* TGZ generator (our Superclass) may
* 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__ )
S_IREAD | S_IWRITE | S_IEXEC
#if defined(_MSC_VER) || defined(__MINGW32__)
S_IREAD | S_IWRITE | S_IEXEC
#else
S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IWGRP | S_IXGRP |
S_IROTH | S_IWOTH | S_IXOTH
S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IWGRP | S_IXGRP |
S_IROTH | S_IWOTH | S_IXOTH
#endif
);
);
}
return retval;
}
@ -87,10 +84,9 @@ 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",
licenseText.c_str());
@ -100,10 +96,9 @@ 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";
}
}
// Configure in the values
std::string res;
@ -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 ++;
}
++ptr;
while (*ptr) {
if (*ptr == '\n') {
counter++;
}
counter ++;
cmCPackLogger(cmCPackLog::LOG_DEBUG,
"Number of lines: " << counter << std::endl);
++ptr;
}
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()
{
}

378
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,33 +59,31 @@ struct cpackDefinitions
{
typedef std::map<std::string, std::string> MapType;
MapType Map;
cmCPackLog *Log;
cmCPackLog* Log;
};
int cpackDefinitionArgument(const char* argument, const char* cValue,
void* call_data)
void* call_data)
{
(void)argument;
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);
"Please specify CPack definitions as: KEY=VALUE" << std::endl);
return 0;
}
}
std::string key = value.substr(0, pos);
value = value.c_str() + pos + 1;
def->Map[key] = value;
cmCPack_Log(def->Log, cmCPackLog::LOG_DEBUG, "Set CPack variable: "
<< key << " to \"" << value << "\"" << std::endl);
<< key << " to \"" << value << "\"" << std::endl);
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,12 +100,12 @@ 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;
}
}
std::string generator;
bool help = false;
@ -142,9 +135,9 @@ int main (int argc, char const* const* argv)
// Help arguments
arg.AddArgument("--help", argT::NO_ARGUMENT, &help, "CPack help");
arg.AddArgument("--help-full", argT::SPACE_ARGUMENT, &helpFull,
"CPack help");
"CPack help");
arg.AddArgument("--help-html", argT::SPACE_ARGUMENT, &helpHTML,
"CPack help");
"CPack help");
arg.AddArgument("--help-man", argT::SPACE_ARGUMENT, &helpMAN, "CPack help");
arg.AddArgument("--version", argT::NO_ARGUMENT, &helpVersion, "CPack help");
@ -152,42 +145,39 @@ int main (int argc, char const* const* argv)
arg.AddArgument("--verbose", argT::NO_ARGUMENT, &verbose, "-V");
arg.AddArgument("--debug", argT::NO_ARGUMENT, &debug, "-V");
arg.AddArgument("--config", argT::SPACE_ARGUMENT, &cpackConfigFile,
"CPack configuration file");
"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");
"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.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);
}
}
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
"Read CPack config file: " << cpackConfigFile << std::endl);
"Read CPack config file: " << cpackConfigFile << std::endl);
cmake cminst;
cminst.SetHomeDirectory("");
@ -196,18 +186,17 @@ int main (int argc, char const* const* argv)
cminst.GetState()->RemoveUnscriptableCommands();
cmGlobalGenerator cmgg(&cminst);
cmsys::auto_ptr<cmMakefile> globalMF(
new cmMakefile(&cmgg, cminst.GetCurrentSnapshot()));
new cmMakefile(&cmgg, cminst.GetCurrentSnapshot()));
#if defined(__CYGWIN__)
globalMF->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0");
#endif
bool cpackConfigFileSpecified = true;
if ( cpackConfigFile.empty() )
{
if (cpackConfigFile.empty()) {
cpackConfigFile = cmSystemTools::GetCurrentWorkingDirectory();
cpackConfigFile += "/CPackConfig.cmake";
cpackConfigFileSpecified = false;
}
}
cmCPackGeneratorFactory generators;
generators.SetLogger(&log);
@ -220,262 +209,225 @@ 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))
{
help = true;
}
else
{
help = false;
}
if ((doc.CheckOptions(argc, argv, "-G")) && !(argc == 1)) {
help = true;
} 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);
"Error reading CMakeDetermineSystem.cmake" << std::endl);
return 1;
}
}
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()) )
{
"Read CPack configuration file: " << cpackConfigFile
<< std::endl);
if (!globalMF->ReadListFile(cpackConfigFile.c_str())) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Problem reading CPack config file: \""
<< cpackConfigFile << "\"" << std::endl);
"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() )
{
cpackProjectVersion.c_str());
}
if (!cpackProjectVendor.empty()) {
globalMF->AddDefinition("CPACK_PACKAGE_VENDOR",
cpackProjectVendor.c_str());
}
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") )
{
"Specified generator: " << gen << std::endl);
if (parsed && !mf->GetDefinition("CPACK_PACKAGE_NAME")) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"CPack project name not specified" << std::endl);
"CPack project name not specified" << std::endl);
parsed = 0;
}
}
if (parsed &&
!(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
<< "Specify CPACK_PACKAGE_VERSION, or "
"CPACK_PACKAGE_VERSION_MAJOR, "
"CPACK_PACKAGE_VERSION_MINOR, and CPACK_PACKAGE_VERSION_PATCH."
<< 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."
<< 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") &&
!mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
!mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS") )
{
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
if (!mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
!mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
!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 "
"CPACK_INSTALLED_DIRECTORIES."
<< std::endl);
<< 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);
<< cpackGenerator->GetNameOfClass() << 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());
}
<< projVersionPatch;
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;
}
}
}
}
}
}
}
/* In this case we are building the documentation object
* 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;
}
}
return 0;
}

400
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,69 +83,68 @@ 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;
cmsys::RegularExpression RegexCheckOut;
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;
}
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;
}
return true;
}
};
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> ");
@ -164,7 +158,7 @@ void cmCTestBZR::NoteOldRevision()
this->OldRevision = this->LoadInfo();
this->Log << "Revision before update: " << this->OldRevision << "\n";
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Old revision of repository is: "
<< this->OldRevision << "\n");
<< this->OldRevision << "\n");
this->PriorRev.Rev = this->OldRevision;
}
@ -173,35 +167,38 @@ void cmCTestBZR::NoteNewRevision()
this->NewRevision = this->LoadInfo();
this->Log << "Revision after update: " << this->NewRevision << "\n";
cmCTestLog(this->CTest, HANDLER_OUTPUT, " New revision of repository is: "
<< this->NewRevision << "\n");
<< this->NewRevision << "\n");
this->Log << "URL = " << this->URL << "\n";
}
class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
private cmXMLParser
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)
{
XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
cmBZRXMLParserUnknownEncodingHandler, 0);
}
return res;
}
{
int res = cmXMLParser::InitializeParser();
if (res) {
XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
cmBZRXMLParserUnknownEncodingHandler, 0);
}
return res;
}
private:
cmCTestBZR* BZR;
typedef cmCTestBZR::Revision Revision;
typedef cmCTestBZR::Change Change;
typedef cmCTestBZR::Change Change;
Revision Rev;
std::vector<Change> Changes;
Change CurChange;
@ -210,194 +207,161 @@ private:
cmsys::RegularExpression EmailRegex;
virtual bool ProcessChunk(const char* data, int length)
{
{
this->OutputLogger::ProcessChunk(data, length);
this->ParseChunk(data, length);
return true;
}
}
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();
}
}
}
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();
}
this->CData.clear();
}
virtual void ReportError(int, int, const char* msg)
{
{
this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
}
}
};
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;
virtual bool ProcessChunk(const char* first, int length)
{
{
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;
}
}
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;
}
}
return true;
}
return true;
}
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));
}
return true;
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;
}
}
}
};
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());
// TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
@ -407,11 +371,10 @@ 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());
}
}
bzr_update.push_back(this->URL.c_str());
@ -427,82 +390,79 @@ 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> ");
this->RunChild(bzr_log, &out, &err);
LogParser out(this, "log-out> ");
OutputLogger err(this->Log, "log-err> ");
this->RunChild(bzr_log, &out, &err);
}
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));
}
return true;
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;
}
}
}
};
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. */

62
Source/CTest/cmCTestBatchTestHandler.cxx
View File

@ -30,18 +30,17 @@ 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";
}
}
fout.flush();
fout.close();
}
@ -49,13 +48,13 @@ void cmCTestBatchTestHandler::WriteBatchScript()
void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
{
cmCTestTestHandler::cmCTestTestProperties* properties =
this->Properties[test];
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,14 +65,12 @@ 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 << " ";
}
}
}
void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout)
@ -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;
fout << " ";
}
// 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);

422
Source/CTest/cmCTestBuildAndTestHandler.cxx
View File

@ -21,9 +21,9 @@
cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
{
this->BuildTwoConfig = false;
this->BuildNoClean = false;
this->BuildNoCMake = false;
this->BuildTwoConfig = false;
this->BuildNoClean = false;
this->BuildNoCMake = false;
this->Timeout = 0;
}
@ -48,91 +48,75 @@ 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;
}
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;
}
return 1;
}
}
out << "======== CMake output ======\n";
out << cmakeOutString;
out << "======== End CMake output ======\n";
@ -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,37 +146,36 @@ 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);
cmSystemTools::SetStderrCallback(CMakeOutputCallback, &s);
this->CM.SetProgressCallback(CMakeProgressCallback, &s);
}
}
~cmCTestBuildAndTestCaptureRAII()
{
{
this->CM.SetProgressCallback(0, 0);
cmSystemTools::SetStderrCallback(0, 0);
cmSystemTools::SetStdoutCallback(0, 0);
cmSystemTools::SetMessageCallback(0, 0);
}
}
};
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 "
"be provided using the --build-generator "
"command line option. ";
}
return 1;
if (this->BuildGenerator.empty()) {
if (outstring) {
*outstring = "--build-and-test requires that the generator "
"be provided using the --build-generator "
"command line option. ";
}
return 1;
}
cmake cm;
cm.SetHomeDirectory("");
@ -202,27 +185,21 @@ 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,
failed);
if (!fullPath.empty() && !resultingConfig.empty())
{
fullPath = cmCTestTestHandler::FindExecutable(
this->CTest, this->ConfigSample.c_str(), resultingConfig, extraPaths,
failed);
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
// and test time
@ -230,100 +207,79 @@ 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;
}
return 1;
}
}
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)
{
*outstring = out.str();
}
return 1;
if (retVal) {
if (outstring) {
*outstring = out.str();
}
return 1;
}
if(outstring)
{
*outstring = out.str();
}
}
if (outstring) {
*outstring = out.str();
}
// if no test was specified then we are done
if (this->TestCommand.empty())
{
if (this->TestCommand.empty()) {
return 0;
}
}
// now run the compiled test if we can find it
// store the final location in fullPath
@ -331,99 +287,80 @@ 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;
extraPaths.push_back(tempPath);
}
}
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";
<< 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)
{
*outstring = out.str();
}
else
{
}
if (outstring) {
*outstring = out.str();
} else {
cmCTestLog(this->CTest, ERROR_MESSAGE, out.str());
}
}
// return to the original directory
cmSystemTools::ChangeDirectory(cwd);
return 1;
}
}
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;
}
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;
}

39
Source/CTest/cmCTestBuildAndTestHandler.h
View File

@ -13,7 +13,6 @@
#ifndef cmCTestBuildAndTestHandler_h
#define cmCTestBuildAndTestHandler_h
#include "cmCTestGenericHandler.h"
#include "cmListFileCache.h"
@ -50,31 +49,29 @@ 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;
std::string Output;
std::string BuildGenerator;
std::string BuildGeneratorPlatform;
std::string BuildGeneratorToolset;
std::string BuildGenerator;
std::string BuildGeneratorPlatform;
std::string BuildGeneratorToolset;
std::vector<std::string> BuildOptions;
bool BuildTwoConfig;
std::string BuildMakeProgram;
std::string ConfigSample;
std::string SourceDir;
std::string BinaryDir;
std::string BuildProject;
std::string TestCommand;
bool BuildNoClean;
std::string BuildRunDir;
std::string ExecutableDirectory;
bool BuildTwoConfig;
std::string BuildMakeProgram;
std::string ConfigSample;
std::string SourceDir;
std::string BinaryDir;
std::string BuildProject;
std::string TestCommand;
bool BuildNoClean;
std::string BuildRunDir;
std::string ExecutableDirectory;
std::vector<std::string> TestCommandArgs;
std::vector<std::string> BuildTargets;
bool BuildNoCMake;
double Timeout;
bool BuildNoCMake;
double Timeout;
};
#endif

145
Source/CTest/cmCTestBuildCommand.cxx
View File

@ -17,7 +17,6 @@
#include "cmGlobalGenerator.h"
#include "cmake.h"
cmCTestBuildCommand::cmCTestBuildCommand()
{
this->GlobalGenerator = 0;
@ -33,37 +32,31 @@ cmCTestBuildCommand::cmCTestBuildCommand()
cmCTestBuildCommand::~cmCTestBuildCommand()
{
if ( this->GlobalGenerator )
{
if (this->GlobalGenerator) {
delete this->GlobalGenerator;
this->GlobalGenerator = 0;
}
}
}
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;
}
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])
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])
? this->Values[ctb_PROJECT_NAME]
: this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
@ -72,81 +65,71 @@ 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());
? 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 += "\"";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e);
cmSystemTools::SetFatalErrorOccured();
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;
}
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
{
this->Quiet);
} else {
std::ostringstream ostr;
/* clang-format off */
ostr << "has no project to build. If this is a "
@ -163,39 +146,35 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
/* clang-format on */
this->SetError(ostr.str());
return 0;
}
}
}
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);
}
this->Quiet);
}
handler->SetQuiet(this->Quiet);
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])
{
bool ret = cmCTestHandlerCommand::InitialPass(args, status);
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());
}
if ( this->Values[ctb_NUMBER_WARNINGS]
&& *this->Values[ctb_NUMBER_WARNINGS])
{
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS],
str.str().c_str());
}
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;
}

13
Source/CTest/cmCTestBuildCommand.h
View File

@ -25,7 +25,6 @@ class cmCTestBuildHandler;
class cmCTestBuildCommand : public cmCTestHandlerCommand
{
public:
cmCTestBuildCommand();
~cmCTestBuildCommand();
@ -33,20 +32,20 @@ public:
* This is a virtual constructor for the command.
*/
virtual cmCommand* Clone()
{
{
cmCTestBuildCommand* ni = new cmCTestBuildCommand;
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
return ni;
}
}
/**
* 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

941
Source/CTest/cmCTestBuildHandler.cxx
View File

File diff suppressed because it is too large Load Diff

75
Source/CTest/cmCTestBuildHandler.h
View File

@ -40,48 +40,48 @@ 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
};
class cmCTestCompileErrorWarningRex
{
{
public:
cmCTestCompileErrorWarningRex() {}
int FileIndex;
int LineIndex;
cmsys::RegularExpression RegularExpression;
};
};
struct cmCTestBuildErrorWarning
{
bool Error;
int LogLine;
bool Error;
int LogLine;
std::string Text;
std::string SourceFile;
std::string SourceFileTail;
int LineNumber;
int LineNumber;
std::string PreContext;
std::string PostContext;
};
@ -94,10 +94,10 @@ private:
bool IsLaunchedErrorFile(const char* fname);
bool IsLaunchedWarningFile(const char* fname);
std::string StartBuild;
std::string EndBuild;
double StartBuildTime;
double EndBuildTime;
std::string StartBuild;
std::string EndBuild;
double StartBuildTime;
double EndBuildTime;
std::vector<std::string> CustomErrorMatches;
std::vector<std::string> CustomErrorExceptions;
@ -115,34 +115,35 @@ 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;
t_BuildProcessingQueueType BuildProcessingErrorQueue;
size_t BuildOutputLogSize;
std::vector<char> CurrentProcessingLine;
t_BuildProcessingQueueType BuildProcessingQueue;
t_BuildProcessingQueueType BuildProcessingErrorQueue;
size_t BuildOutputLogSize;
std::vector<char> CurrentProcessingLine;
std::string SimplifySourceDir;
std::string SimplifyBuildDir;
size_t OutputLineCounter;
std::string SimplifySourceDir;
std::string SimplifyBuildDir;
size_t OutputLineCounter;
typedef std::vector<cmCTestBuildErrorWarning> t_ErrorsAndWarningsVector;
t_ErrorsAndWarningsVector ErrorsAndWarnings;
t_ErrorsAndWarningsVector::iterator LastErrorOrWarning;
size_t PostContextCount;
size_t MaxPreContext;
size_t MaxPostContext;
std::deque<std::string> PreContext;
t_ErrorsAndWarningsVector ErrorsAndWarnings;
t_ErrorsAndWarningsVector::iterator LastErrorOrWarning;
size_t PostContextCount;
size_t MaxPreContext;
size_t MaxPostContext;
std::deque<std::string> PreContext;
int TotalErrors;
int TotalWarnings;
char LastTickChar;
int TotalErrors;
int TotalWarnings;
char LastTickChar;
bool ErrorQuotaReached;
bool WarningQuotaReached;
bool ErrorQuotaReached;
bool WarningQuotaReached;
int MaxErrors;
int MaxWarnings;
int MaxErrors;
int MaxWarnings;
bool UseCTestLaunch;
std::string CTestLaunchDir;

192
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,11 +27,12 @@ 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".
this->RegexFileUpdated.compile("^([UP]) *(.*)");
@ -41,7 +43,8 @@ public:
this->RegexFileRemoved2.compile(
"cvs[^ ]* update: "
"warning: `?([^']*)'? is not \\(any longer\\) pertinent");
}
}
private:
cmCTestCVS* CVS;
cmsys::RegularExpression RegexFileUpdated;
@ -51,68 +54,55 @@ private:
cmsys::RegularExpression RegexFileRemoved2;
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;
}
return true;
}
void DoFile(PathStatus status, std::string const& file)
{
{
std::string dir = cmSystemTools::GetFilenamePath(file);
std::string name = cmSystemTools::GetFilenameName(file);
this->CVS->Dirs[dir][name] = status;
}
}
};
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");
}
}
// Run "cvs update" to update the work tree.
std::vector<char const*> cvs_update;
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);
UpdateParser out(this, "up-out> ");
@ -120,83 +110,76 @@ 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->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";
}
}
return this->Section != SectionEnd;
}
return this->Section != SectionEnd;
}
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,65 +189,57 @@ 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;
}
}
this->Rev = Revision();
}
this->Rev = Revision();
}
};
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;
}
}
tagFile += "/CVS/Tag";
// 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,25 +248,23 @@ 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);
}
}
this->LoadRevisions(full, branchFlag.c_str(), revisions);
revisions.resize(2, this->Unknown);
// Write the entry for this file with these revisions.
File f(fi->second, &revisions[0], &revisions[1]);
this->WriteXMLEntry(xml, path, fi->first, full, f);
}
}
xml.EndElement(); // Directory
}
@ -299,13 +272,14 @@ 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);
}
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);

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

105
Source/CTest/cmCTestConfigureCommand.cxx
View File

@ -26,64 +26,56 @@ 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 "
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 "
"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;
}
}
bool multiConfig = false;
bool cmakeBuildTypeInOptions = false;
cmGlobalGenerator *gg =
cmGlobalGenerator* gg =
this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
cmakeGeneratorName);
if(gg)
{
if (gg) {
multiConfig = gg->IsMultiConfig();
delete gg;
}
}
std::string cmakeConfigureCommand = "\"";
cmakeConfigureCommand += cmSystemTools::GetCMakeCommand();
@ -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,19 +91,17 @@ 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 += "\"";
}
}
cmakeConfigureCommand += " \"-G";
cmakeConfigureCommand += cmakeGeneratorName;
@ -120,46 +109,42 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
const char* cmakeGeneratorPlatform =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_PLATFORM");
if(cmakeGeneratorPlatform && *cmakeGeneratorPlatform)
{
if (cmakeGeneratorPlatform && *cmakeGeneratorPlatform) {
cmakeConfigureCommand += " \"-A";
cmakeConfigureCommand += cmakeGeneratorPlatform;
cmakeConfigureCommand += "\"";
}
}
const char* cmakeGeneratorToolset =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_TOOLSET");
if(cmakeGeneratorToolset && *cmakeGeneratorToolset)
{
if (cmakeGeneratorToolset && *cmakeGeneratorToolset) {
cmakeConfigureCommand += " \"-T";
cmakeConfigureCommand += cmakeGeneratorToolset;
cmakeConfigureCommand += "\"";
}
}
cmakeConfigureCommand += " \"";
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;
}
}
handler->SetQuiet(this->Quiet);
return handler;
}

10
Source/CTest/cmCTestConfigureCommand.h
View File

@ -28,29 +28,29 @@ public:
* This is a virtual constructor for the command.
*/
virtual cmCommand* Clone()
{
{
cmCTestConfigureCommand* ni = new cmCTestConfigureCommand;
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
return ni;
}
}
/**
* 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

87
Source/CTest/cmCTestConfigureHandler.cxx
View File

@ -18,7 +18,6 @@
#include "cmake.h"
#include <cmsys/Process.h>
cmCTestConfigureHandler::cmCTestConfigureHandler()
{
}
@ -28,64 +27,58 @@ 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())
{
"Configure project" << std::endl, this->Quiet);
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);
"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);
"Cannot find BuildDirectory key in the DartConfiguration.tcl"
<< std::endl);
return -1;
}
}
double elapsed_time_start = cmSystemTools::GetTime();
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);
<< 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");
@ -97,23 +90,23 @@ int cmCTestConfigureHandler::ProcessHandler()
xml.Element("ConfigureStatus", retVal);
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);
static_cast<unsigned int>(cmSystemTools::GetTime()));
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);
}
if (! res || retVal )
{
"Configure with command: " << cCommand << std::endl,
this->Quiet);
}
if (!res || retVal) {
cmCTestLog(this->CTest, ERROR_MESSAGE,
"Error(s) when configuring the project" << std::endl);
"Error(s) when configuring the project" << std::endl);
return -1;
}
}
return 0;
}

29
Source/CTest/cmCTestCoverageCommand.cxx
View File

@ -21,23 +21,22 @@ 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);
}
}
handler->SetQuiet(this->Quiet);
return handler;
@ -46,12 +45,11 @@ 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;
}
}
// Look for other arguments.
return this->Superclass::CheckArgumentKeyword(arg);
@ -60,11 +58,10 @@ 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;
}
}
// Look for other arguments.
return this->Superclass::CheckArgumentValue(arg);

9
Source/CTest/cmCTestCoverageCommand.h
View File

@ -22,24 +22,23 @@
class cmCTestCoverageCommand : public cmCTestHandlerCommand
{
public:
cmCTestCoverageCommand();
/**
* This is a virtual constructor for the command.
*/
virtual cmCommand* Clone()
{
{
cmCTestCoverageCommand* ni = new cmCTestCoverageCommand;
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
return ni;
}
}
/**
* 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

2202
Source/CTest/cmCTestCoverageHandler.cxx
View File

File diff suppressed because it is too large Load Diff

38
Source/CTest/cmCTestCoverageHandler.h
View File

@ -54,14 +54,14 @@ 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);
private:
bool ShouldIDoCoverage(const char* file, const char* srcDir,
const char* binDir);
const char* binDir);
void CleanCoverageLogFiles(std::ostream& log);
bool StartCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
void EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
@ -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,
std::string& outputFile);
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,
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,
int& percentBranch);
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);
@ -126,7 +119,7 @@ private:
// Find the source file based on the source and build tree. This is used for
// Trace.py mode, since that one does not tell us where the source file is.
std::string FindFile(cmCTestCoverageHandlerContainer* cont,
std::string fileName);
std::string fileName);
std::set<std::string> FindUncoveredFiles(
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;

189
Source/CTest/cmCTestCurl.cxx
View File

@ -42,115 +42,95 @@ 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")
{
this->VerifyHostOff = true;
}
}
if (*i == "CURLOPT_SSL_VERIFYHOST_OFF") {
this->VerifyHostOff = true;
}
}
}
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
curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
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);
}
}
/* HTTP PUT please */
::curl_easy_setopt(this->Curl, CURLOPT_PUT, 1);
::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;
}
}
// set the url
std::string upload_url = url;
upload_url += "?";
@ -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,108 +160,90 @@ 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())
{
<< "url: " << url << "\n"
<< "fields " << fields << "\n");
if (!this->InitCurl()) {
cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
return false;
}
}
curl_easy_setopt(this->Curl, CURLOPT_POST, 1);
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");
}
}
cmCTestLog(this->CTest, DEBUG, "Curl res: " << res << "\n");
return (res == 0);
}
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") )
{
this->HTTPProxyAuth = cmSystemTools::GetEnv("HTTP_PROXY_USER");
}
if ( cmSystemTools::GetEnv("HTTP_PROXY_PASSWD") )
{
this->HTTPProxyAuth += ":";
this->HTTPProxyAuth += cmSystemTools::GetEnv("HTTP_PROXY_PASSWD");
}
}
if (cmSystemTools::GetEnv("HTTP_PROXY_USER")) {
this->HTTPProxyAuth = cmSystemTools::GetEnv("HTTP_PROXY_USER");
}
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;

16
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
View File

@ -13,24 +13,20 @@
#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());
return false;
}
}
return true;
}

18
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
View File

@ -23,36 +23,36 @@
class cmCTestEmptyBinaryDirectoryCommand : public cmCTestCommand
{
public:
cmCTestEmptyBinaryDirectoryCommand() {}
/**
* This is a virtual constructor for the command.
*/
virtual cmCommand* Clone()
{
cmCTestEmptyBinaryDirectoryCommand* ni
= new cmCTestEmptyBinaryDirectoryCommand;
{
cmCTestEmptyBinaryDirectoryCommand* ni =
new cmCTestEmptyBinaryDirectoryCommand;
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
return ni;
}
}
/**
* This is called when the command is first encountered in
* 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

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