summaryrefslogtreecommitdiffstats
path: root/Source/cmGlobalGenerator.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/cmGlobalGenerator.cxx')
-rw-r--r--Source/cmGlobalGenerator.cxx2018
1 files changed, 825 insertions, 1193 deletions
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 2b06d7d..3f4c22f 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -12,7 +12,7 @@
#if defined(_WIN32) && !defined(__CYGWIN__)
#include "windows.h" // this must be first to define GetCurrentDirectory
#if defined(_MSC_VER) && _MSC_VER >= 1800
-# define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
+#define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
#endif
#endif
@@ -40,9 +40,9 @@
#include <cmsys/FStream.hxx>
#if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cm_jsoncpp_value.h"
-# include "cm_jsoncpp_writer.h"
-# include <cmsys/MD5.h>
+#include "cm_jsoncpp_value.h"
+#include "cm_jsoncpp_writer.h"
+#include <cmsys/MD5.h>
#endif
#include <stdlib.h> // required for atof
@@ -53,11 +53,10 @@ bool cmTarget::StrictTargetComparison::operator()(cmTarget const* t1,
cmTarget const* t2) const
{
int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str());
- if (nameResult == 0)
- {
+ if (nameResult == 0) {
return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(),
t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0;
- }
+ }
return nameResult < 0;
}
@@ -105,10 +104,9 @@ cmGlobalGenerator::~cmGlobalGenerator()
bool cmGlobalGenerator::SetGeneratorPlatform(std::string const& p,
cmMakefile* mf)
{
- if(p.empty())
- {
+ if (p.empty()) {
return true;
- }
+ }
std::ostringstream e;
/* clang-format off */
@@ -126,10 +124,9 @@ bool cmGlobalGenerator::SetGeneratorPlatform(std::string const& p,
bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts,
cmMakefile* mf)
{
- if(ts.empty())
- {
+ if (ts.empty()) {
return true;
- }
+ }
std::ostringstream e;
/* clang-format off */
e <<
@@ -144,99 +141,78 @@ bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts,
}
std::string cmGlobalGenerator::SelectMakeProgram(
- const std::string& inMakeProgram,
- const std::string& makeDefault) const
+ const std::string& inMakeProgram, const std::string& makeDefault) const
{
std::string makeProgram = inMakeProgram;
- if(cmSystemTools::IsOff(makeProgram.c_str()))
- {
+ if (cmSystemTools::IsOff(makeProgram.c_str())) {
const char* makeProgramCSTR =
this->CMakeInstance->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
- if(cmSystemTools::IsOff(makeProgramCSTR))
- {
+ if (cmSystemTools::IsOff(makeProgramCSTR)) {
makeProgram = makeDefault;
- }
- else
- {
+ } else {
makeProgram = makeProgramCSTR;
- }
- if(cmSystemTools::IsOff(makeProgram.c_str()) &&
- !makeProgram.empty())
- {
+ }
+ if (cmSystemTools::IsOff(makeProgram.c_str()) && !makeProgram.empty()) {
makeProgram = "CMAKE_MAKE_PROGRAM-NOTFOUND";
- }
}
+ }
return makeProgram;
}
-void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
- cmMakefile *mf,
+void cmGlobalGenerator::ResolveLanguageCompiler(const std::string& lang,
+ cmMakefile* mf,
bool optional) const
{
std::string langComp = "CMAKE_";
langComp += lang;
langComp += "_COMPILER";
- if(!mf->GetDefinition(langComp))
- {
- if(!optional)
- {
- cmSystemTools::Error(langComp.c_str(),
- " not set, after EnableLanguage");
- }
- return;
+ if (!mf->GetDefinition(langComp)) {
+ if (!optional) {
+ cmSystemTools::Error(langComp.c_str(), " not set, after EnableLanguage");
}
+ return;
+ }
const char* name = mf->GetRequiredDefinition(langComp);
std::string path;
- if(!cmSystemTools::FileIsFullPath(name))
- {
+ if (!cmSystemTools::FileIsFullPath(name)) {
path = cmSystemTools::FindProgram(name);
- }
- else
- {
+ } else {
path = name;
- }
- if((path.empty() || !cmSystemTools::FileExists(path.c_str()))
- && (optional==false))
- {
+ }
+ if ((path.empty() || !cmSystemTools::FileExists(path.c_str())) &&
+ (optional == false)) {
return;
- }
- const char* cname = this->GetCMakeInstance()->
- GetState()->GetInitializedCacheValue(langComp);
+ }
+ const char* cname =
+ this->GetCMakeInstance()->GetState()->GetInitializedCacheValue(langComp);
std::string changeVars;
- if(cname && !optional)
- {
+ if (cname && !optional) {
std::string cnameString;
- if(!cmSystemTools::FileIsFullPath(cname))
- {
+ if (!cmSystemTools::FileIsFullPath(cname)) {
cnameString = cmSystemTools::FindProgram(cname);
- }
- else
- {
+ } else {
cnameString = cname;
- }
+ }
std::string pathString = path;
// get rid of potentially multiple slashes:
cmSystemTools::ConvertToUnixSlashes(cnameString);
cmSystemTools::ConvertToUnixSlashes(pathString);
- if (cnameString != pathString)
- {
+ if (cnameString != pathString) {
const char* cvars =
this->GetCMakeInstance()->GetState()->GetGlobalProperty(
"__CMAKE_DELETE_CACHE_CHANGE_VARS_");
- if(cvars)
- {
+ if (cvars) {
changeVars += cvars;
changeVars += ";";
- }
+ }
changeVars += langComp;
changeVars += ";";
changeVars += cname;
this->GetCMakeInstance()->GetState()->SetGlobalProperty(
- "__CMAKE_DELETE_CACHE_CHANGE_VARS_",
- changeVars.c_str());
- }
+ "__CMAKE_DELETE_CACHE_CHANGE_VARS_", changeVars.c_str());
}
+ }
}
void cmGlobalGenerator::AddBuildExportSet(cmExportBuildFileGenerator* gen)
@@ -244,78 +220,70 @@ void cmGlobalGenerator::AddBuildExportSet(cmExportBuildFileGenerator* gen)
this->BuildExportSets[gen->GetMainExportFileName()] = gen;
}
-void
-cmGlobalGenerator::AddBuildExportExportSet(cmExportBuildFileGenerator* gen)
+void cmGlobalGenerator::AddBuildExportExportSet(
+ cmExportBuildFileGenerator* gen)
{
this->BuildExportSets[gen->GetMainExportFileName()] = gen;
this->BuildExportExportSets[gen->GetMainExportFileName()] = gen;
}
-bool cmGlobalGenerator::GenerateImportFile(const std::string &file)
+bool cmGlobalGenerator::GenerateImportFile(const std::string& file)
{
- std::map<std::string, cmExportBuildFileGenerator*>::iterator it
- = this->BuildExportSets.find(file);
- if (it != this->BuildExportSets.end())
- {
+ std::map<std::string, cmExportBuildFileGenerator*>::iterator it =
+ this->BuildExportSets.find(file);
+ if (it != this->BuildExportSets.end()) {
bool result = it->second->GenerateImportFile();
- if (!this->ConfigureDoneCMP0026AndCMP0024)
- {
+ if (!this->ConfigureDoneCMP0026AndCMP0024) {
for (std::vector<cmMakefile*>::const_iterator mit =
- this->Makefiles.begin(); mit != this->Makefiles.end(); ++mit)
- {
+ this->Makefiles.begin();
+ mit != this->Makefiles.end(); ++mit) {
(*mit)->RemoveExportBuildFileGeneratorCMP0024(it->second);
- }
}
+ }
delete it->second;
it->second = 0;
this->BuildExportSets.erase(it);
return result;
- }
+ }
return false;
}
void cmGlobalGenerator::ForceLinkerLanguages()
{
-
}
-bool
-cmGlobalGenerator::IsExportedTargetsFile(const std::string &filename) const
+bool cmGlobalGenerator::IsExportedTargetsFile(
+ const std::string& filename) const
{
- const std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it
- = this->BuildExportSets.find(filename);
- if (it == this->BuildExportSets.end())
- {
+ const std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it =
+ this->BuildExportSets.find(filename);
+ if (it == this->BuildExportSets.end()) {
return false;
- }
- return this->BuildExportExportSets.find(filename)
- == this->BuildExportExportSets.end();
+ }
+ return this->BuildExportExportSets.find(filename) ==
+ this->BuildExportExportSets.end();
}
// Find the make program for the generator, required for try compiles
void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
{
- if(this->FindMakeProgramFile.empty())
- {
+ if (this->FindMakeProgramFile.empty()) {
cmSystemTools::Error(
"Generator implementation error, "
"all generators must specify this->FindMakeProgramFile");
- }
- if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
- || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
- {
+ }
+ if (!mf->GetDefinition("CMAKE_MAKE_PROGRAM") ||
+ cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
std::string setMakeProgram =
mf->GetModulesFile(this->FindMakeProgramFile.c_str());
- if(!setMakeProgram.empty())
- {
+ if (!setMakeProgram.empty()) {
mf->ReadListFile(setMakeProgram.c_str());
- }
}
- if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
- || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
- {
+ }
+ if (!mf->GetDefinition("CMAKE_MAKE_PROGRAM") ||
+ cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
std::ostringstream err;
err << "CMake was unable to find a build program corresponding to \""
<< this->GetName() << "\". CMAKE_MAKE_PROGRAM is not set. You "
@@ -323,28 +291,24 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
cmSystemTools::Error(err.str().c_str());
cmSystemTools::SetFatalErrorOccured();
return;
- }
+ }
std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
// if there are spaces in the make program use short path
// but do not short path the actual program name, as
// this can cause trouble with VSExpress
- if(makeProgram.find(' ') != makeProgram.npos)
- {
+ if (makeProgram.find(' ') != makeProgram.npos) {
std::string dir;
std::string file;
- cmSystemTools::SplitProgramPath(makeProgram,
- dir, file);
+ cmSystemTools::SplitProgramPath(makeProgram, dir, file);
std::string saveFile = file;
cmSystemTools::GetShortPath(makeProgram, makeProgram);
- cmSystemTools::SplitProgramPath(makeProgram,
- dir, file);
+ cmSystemTools::SplitProgramPath(makeProgram, dir, file);
makeProgram = dir;
makeProgram += "/";
makeProgram += saveFile;
mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", makeProgram.c_str(),
- "make program",
- cmState::FILEPATH);
- }
+ "make program", cmState::FILEPATH);
+ }
}
// enable the given language
@@ -392,58 +356,48 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
//
//
-void
-cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
- cmMakefile *mf, bool optional)
+void cmGlobalGenerator::EnableLanguage(
+ std::vector<std::string> const& languages, cmMakefile* mf, bool optional)
{
- if(languages.empty())
- {
+ if (languages.empty()) {
cmSystemTools::Error("EnableLanguage must have a lang specified!");
cmSystemTools::SetFatalErrorOccured();
return;
- }
+ }
std::set<std::string> cur_languages(languages.begin(), languages.end());
for (std::set<std::string>::iterator li = cur_languages.begin();
- li != cur_languages.end(); ++li)
- {
- if (!this->LanguagesInProgress.insert(*li).second)
- {
+ li != cur_languages.end(); ++li) {
+ if (!this->LanguagesInProgress.insert(*li).second) {
std::ostringstream e;
e << "Language '" << *li << "' is currently being enabled. "
- "Recursive call not allowed.";
+ "Recursive call not allowed.";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
cmSystemTools::SetFatalErrorOccured();
return;
- }
}
+ }
- if(this->TryCompileOuterMakefile)
- {
+ if (this->TryCompileOuterMakefile) {
// In a try-compile we can only enable languages provided by caller.
- for(std::vector<std::string>::const_iterator li = languages.begin();
- li != languages.end(); ++li)
- {
- if(*li == "NONE")
- {
+ for (std::vector<std::string>::const_iterator li = languages.begin();
+ li != languages.end(); ++li) {
+ if (*li == "NONE") {
this->SetLanguageEnabled("NONE", mf);
- }
- else
- {
+ } else {
const char* lang = li->c_str();
- if(this->LanguagesReady.find(lang) == this->LanguagesReady.end())
- {
+ if (this->LanguagesReady.find(lang) == this->LanguagesReady.end()) {
std::ostringstream e;
- e << "The test project needs language "
- << lang << " which is not enabled.";
- this->TryCompileOuterMakefile
- ->IssueMessage(cmake::FATAL_ERROR, e.str());
+ e << "The test project needs language " << lang
+ << " which is not enabled.";
+ this->TryCompileOuterMakefile->IssueMessage(cmake::FATAL_ERROR,
+ e.str());
cmSystemTools::SetFatalErrorOccured();
return;
- }
}
}
}
+ }
bool fatalError = false;
@@ -454,15 +408,14 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// If the configuration files path has been set,
// then we are in a try compile and need to copy the enable language
// files from the parent cmake bin dir, into the try compile bin dir
- if(!this->ConfiguredFilesPath.empty())
- {
+ if (!this->ConfiguredFilesPath.empty()) {
rootBin = this->ConfiguredFilesPath;
- }
+ }
rootBin += "/";
rootBin += cmVersion::GetCMakeVersion();
// set the dir for parent files so they can be used by modules
- mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR",rootBin.c_str());
+ mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR", rootBin.c_str());
// find and make sure CMAKE_MAKE_PROGRAM is defined
this->FindMakeProgram(mf);
@@ -470,18 +423,15 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// try and load the CMakeSystem.cmake if it is there
std::string fpath = rootBin;
bool const readCMakeSystem = !mf->GetDefinition("CMAKE_SYSTEM_LOADED");
- if(readCMakeSystem)
- {
+ if (readCMakeSystem) {
fpath += "/CMakeSystem.cmake";
- if(cmSystemTools::FileExists(fpath.c_str()))
- {
+ if (cmSystemTools::FileExists(fpath.c_str())) {
mf->ReadListFile(fpath.c_str());
- }
}
+ }
// Load the CMakeDetermineSystem.cmake file and find out
// what platform we are running on
- if (!mf->GetDefinition("CMAKE_SYSTEM"))
- {
+ if (!mf->GetDefinition("CMAKE_SYSTEM")) {
#if defined(_WIN32) && !defined(__CYGWIN__)
/* Windows version number data. */
OSVERSIONINFOEXW osviex;
@@ -489,12 +439,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
osviex.dwOSVersionInfoSize = sizeof(osviex);
#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-# pragma warning (push)
-# pragma warning (disable:4996)
+#pragma warning(push)
+#pragma warning(disable : 4996)
#endif
GetVersionExW((OSVERSIONINFOW*)&osviex);
#ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
-# pragma warning (pop)
+#pragma warning(pop)
#endif
std::ostringstream windowsVersionString;
windowsVersionString << osviex.dwMajorVersion << "."
@@ -512,45 +462,39 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
fpath = rootBin;
fpath += "/CMakeSystem.cmake";
mf->ReadListFile(fpath.c_str());
- }
+ }
- if(readCMakeSystem)
- {
+ if (readCMakeSystem) {
// Tell the generator about the target system.
std::string system = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME");
- if(!this->SetSystemName(system, mf))
- {
+ if (!this->SetSystemName(system, mf)) {
cmSystemTools::SetFatalErrorOccured();
return;
- }
+ }
// Tell the generator about the platform, if any.
std::string platform = mf->GetSafeDefinition("CMAKE_GENERATOR_PLATFORM");
- if(!this->SetGeneratorPlatform(platform, mf))
- {
+ if (!this->SetGeneratorPlatform(platform, mf)) {
cmSystemTools::SetFatalErrorOccured();
return;
- }
+ }
// Tell the generator about the toolset, if any.
std::string toolset = mf->GetSafeDefinition("CMAKE_GENERATOR_TOOLSET");
- if(!this->SetGeneratorToolset(toolset, mf))
- {
+ if (!this->SetGeneratorToolset(toolset, mf)) {
cmSystemTools::SetFatalErrorOccured();
return;
- }
}
+ }
// **** Load the system specific initialization if not yet loaded
- if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED"))
- {
+ if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED")) {
fpath = mf->GetModulesFile("CMakeSystemSpecificInitialize.cmake");
- if(!mf->ReadListFile(fpath.c_str()))
- {
+ if (!mf->ReadListFile(fpath.c_str())) {
cmSystemTools::Error("Could not find cmake module file: "
"CMakeSystemSpecificInitialize.cmake");
- }
}
+ }
std::map<std::string, bool> needTestLanguage;
std::map<std::string, bool> needSetLanguageEnabledMaps;
@@ -558,21 +502,18 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// load the CMakeDetermine(LANG)Compiler.cmake file to find
// the compiler
- for(std::vector<std::string>::const_iterator l = languages.begin();
- l != languages.end(); ++l)
- {
+ for (std::vector<std::string>::const_iterator l = languages.begin();
+ l != languages.end(); ++l) {
const char* lang = l->c_str();
needSetLanguageEnabledMaps[lang] = false;
- if(*l == "NONE")
- {
+ if (*l == "NONE") {
this->SetLanguageEnabled("NONE", mf);
continue;
- }
+ }
std::string loadedLang = "CMAKE_";
- loadedLang += lang;
+ loadedLang += lang;
loadedLang += "_COMPILER_LOADED";
- if(!mf->GetDefinition(loadedLang))
- {
+ if (!mf->GetDefinition(loadedLang)) {
fpath = rootBin;
fpath += "/CMake";
fpath += lang;
@@ -581,31 +522,27 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// If the existing build tree was already configured with this
// version of CMake then try to load the configured file first
// to avoid duplicate compiler tests.
- if(cmSystemTools::FileExists(fpath.c_str()))
- {
- if(!mf->ReadListFile(fpath.c_str()))
- {
+ if (cmSystemTools::FileExists(fpath.c_str())) {
+ if (!mf->ReadListFile(fpath.c_str())) {
cmSystemTools::Error("Could not find cmake module file: ",
fpath.c_str());
- }
+ }
// if this file was found then the language was already determined
// to be working
needTestLanguage[lang] = false;
this->SetLanguageEnabledFlag(lang, mf);
needSetLanguageEnabledMaps[lang] = true;
// this can only be called after loading CMake(LANG)Compiler.cmake
- }
}
+ }
- if(!this->GetLanguageEnabled(lang) )
- {
- if (this->CMakeInstance->GetIsInTryCompile())
- {
+ if (!this->GetLanguageEnabled(lang)) {
+ if (this->CMakeInstance->GetIsInTryCompile()) {
cmSystemTools::Error("This should not have happened. "
"If you see this message, you are probably "
"using a broken CMakeLists.txt file or a "
"problematic release of CMake");
- }
+ }
// if the CMake(LANG)Compiler.cmake file was not found then
// load CMakeDetermine(LANG)Compiler.cmake
std::string determineCompiler = "CMakeDetermine";
@@ -613,20 +550,17 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
determineCompiler += "Compiler.cmake";
std::string determineFile =
mf->GetModulesFile(determineCompiler.c_str());
- if(!mf->ReadListFile(determineFile.c_str()))
- {
+ if (!mf->ReadListFile(determineFile.c_str())) {
cmSystemTools::Error("Could not find cmake module file: ",
determineCompiler.c_str());
- }
- if (cmSystemTools::GetFatalErrorOccured())
- {
+ }
+ if (cmSystemTools::GetFatalErrorOccured()) {
return;
- }
+ }
needTestLanguage[lang] = true;
// Some generators like visual studio should not use the env variables
// So the global generator can specify that in this variable
- if(!mf->GetDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV"))
- {
+ if (!mf->GetDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV")) {
// put ${CMake_(LANG)_COMPILER_ENV_VAR}=${CMAKE_(LANG)_COMPILER
// into the environment, in case user scripts want to run
// configure, or sub cmakes
@@ -637,13 +571,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
compilerEnv += lang;
compilerEnv += "_COMPILER_ENV_VAR";
std::string envVar = mf->GetRequiredDefinition(compilerEnv);
- std::string envVarValue =
- mf->GetRequiredDefinition(compilerName);
+ std::string envVarValue = mf->GetRequiredDefinition(compilerName);
std::string env = envVar;
env += "=";
env += envVarValue;
cmSystemTools::PutEnv(env);
- }
+ }
// if determineLanguage was called then load the file it
// configures CMake(LANG)Compiler.cmake
@@ -651,11 +584,10 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
fpath += "/CMake";
fpath += lang;
fpath += "Compiler.cmake";
- if(!mf->ReadListFile(fpath.c_str()))
- {
+ if (!mf->ReadListFile(fpath.c_str())) {
cmSystemTools::Error("Could not find cmake module file: ",
fpath.c_str());
- }
+ }
this->SetLanguageEnabledFlag(lang, mf);
needSetLanguageEnabledMaps[lang] = true;
// this can only be called after loading CMake(LANG)Compiler.cmake
@@ -663,30 +595,26 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// not know if it is a working compiler yet so set the test language
// flag
needTestLanguage[lang] = true;
- } // end if(!this->GetLanguageEnabled(lang) )
- } // end loop over languages
+ } // end if(!this->GetLanguageEnabled(lang) )
+ } // end loop over languages
// **** Load the system specific information if not yet loaded
- if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED"))
- {
+ if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED")) {
fpath = mf->GetModulesFile("CMakeSystemSpecificInformation.cmake");
- if(!mf->ReadListFile(fpath.c_str()))
- {
+ if (!mf->ReadListFile(fpath.c_str())) {
cmSystemTools::Error("Could not find cmake module file: "
"CMakeSystemSpecificInformation.cmake");
- }
}
+ }
// loop over languages again loading CMake(LANG)Information.cmake
//
- for(std::vector<std::string>::const_iterator l = languages.begin();
- l != languages.end(); ++l)
- {
+ for (std::vector<std::string>::const_iterator l = languages.begin();
+ l != languages.end(); ++l) {
const char* lang = l->c_str();
- if(*l == "NONE")
- {
+ if (*l == "NONE") {
this->SetLanguageEnabled("NONE", mf);
continue;
- }
+ }
// Check that the compiler was found.
std::string compilerName = "CMAKE_";
@@ -697,20 +625,15 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
compilerEnv += "_COMPILER_ENV_VAR";
std::ostringstream noCompiler;
const char* compilerFile = mf->GetDefinition(compilerName);
- if(!compilerFile || !*compilerFile ||
- cmSystemTools::IsNOTFOUND(compilerFile))
- {
+ if (!compilerFile || !*compilerFile ||
+ cmSystemTools::IsNOTFOUND(compilerFile)) {
/* clang-format off */
noCompiler <<
"No " << compilerName << " could be found.\n"
;
/* clang-format on */
- }
- else if(strcmp(lang, "RC") != 0 &&
- strcmp(lang, "ASM_MASM") != 0)
- {
- if(!cmSystemTools::FileIsFullPath(compilerFile))
- {
+ } else if (strcmp(lang, "RC") != 0 && strcmp(lang, "ASM_MASM") != 0) {
+ if (!cmSystemTools::FileIsFullPath(compilerFile)) {
/* clang-format off */
noCompiler <<
"The " << compilerName << ":\n"
@@ -718,9 +641,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
"is not a full path and was not found in the PATH.\n"
;
/* clang-format on */
- }
- else if(!cmSystemTools::FileExists(compilerFile))
- {
+ } else if (!cmSystemTools::FileExists(compilerFile)) {
/* clang-format off */
noCompiler <<
"The " << compilerName << ":\n"
@@ -728,14 +649,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
"is not a full path to an existing compiler tool.\n"
;
/* clang-format on */
- }
}
- if(!noCompiler.str().empty())
- {
+ }
+ if (!noCompiler.str().empty()) {
// Skip testing this language since the compiler is not found.
needTestLanguage[lang] = false;
- if(!optional)
- {
+ if (!optional) {
// The compiler was not found and it is not optional. Remove
// CMake(LANG)Compiler.cmake so we try again next time CMake runs.
std::string compilerLangFile = rootBin;
@@ -743,40 +662,34 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
compilerLangFile += lang;
compilerLangFile += "Compiler.cmake";
cmSystemTools::RemoveFile(compilerLangFile);
- if(!this->CMakeInstance->GetIsInTryCompile())
- {
+ if (!this->CMakeInstance->GetIsInTryCompile()) {
this->PrintCompilerAdvice(noCompiler, lang,
mf->GetDefinition(compilerEnv));
mf->IssueMessage(cmake::FATAL_ERROR, noCompiler.str());
fatalError = true;
- }
}
}
+ }
std::string langLoadedVar = "CMAKE_";
langLoadedVar += lang;
langLoadedVar += "_INFORMATION_LOADED";
- if (!mf->GetDefinition(langLoadedVar))
- {
+ if (!mf->GetDefinition(langLoadedVar)) {
fpath = "CMake";
- fpath += lang;
+ fpath += lang;
fpath += "Information.cmake";
std::string informationFile = mf->GetModulesFile(fpath.c_str());
- if (informationFile.empty())
- {
+ if (informationFile.empty()) {
cmSystemTools::Error("Could not find cmake module file: ",
fpath.c_str());
- }
- else if(!mf->ReadListFile(informationFile.c_str()))
- {
+ } else if (!mf->ReadListFile(informationFile.c_str())) {
cmSystemTools::Error("Could not process cmake module file: ",
informationFile.c_str());
- }
}
- if (needSetLanguageEnabledMaps[lang])
- {
+ }
+ if (needSetLanguageEnabledMaps[lang]) {
this->SetLanguageEnabledMaps(lang, mf);
- }
+ }
this->LanguagesReady.insert(lang);
// Test the compiler for the language just setup
@@ -784,49 +697,43 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// At this point we should have enough info for a try compile
// which is used in the backward stuff
// If the language is untested then test it now with a try compile.
- if(needTestLanguage[lang])
- {
- if (!this->CMakeInstance->GetIsInTryCompile())
- {
+ if (needTestLanguage[lang]) {
+ if (!this->CMakeInstance->GetIsInTryCompile()) {
std::string testLang = "CMakeTest";
testLang += lang;
testLang += "Compiler.cmake";
std::string ifpath = mf->GetModulesFile(testLang.c_str());
- if(!mf->ReadListFile(ifpath.c_str()))
- {
+ if (!mf->ReadListFile(ifpath.c_str())) {
cmSystemTools::Error("Could not find cmake module file: ",
testLang.c_str());
- }
+ }
std::string compilerWorks = "CMAKE_";
compilerWorks += lang;
compilerWorks += "_COMPILER_WORKS";
// if the compiler did not work, then remove the
// CMake(LANG)Compiler.cmake file so that it will get tested the
// next time cmake is run
- if(!mf->IsOn(compilerWorks))
- {
+ if (!mf->IsOn(compilerWorks)) {
std::string compilerLangFile = rootBin;
compilerLangFile += "/CMake";
compilerLangFile += lang;
compilerLangFile += "Compiler.cmake";
cmSystemTools::RemoveFile(compilerLangFile);
- }
- } // end if in try compile
- } // end need test language
+ }
+ } // end if in try compile
+ } // end need test language
// Store the shared library flags so that we can satisfy CMP0018
std::string sharedLibFlagsVar = "CMAKE_SHARED_LIBRARY_";
sharedLibFlagsVar += lang;
sharedLibFlagsVar += "_FLAGS";
- const char* sharedLibFlags =
- mf->GetSafeDefinition(sharedLibFlagsVar);
- if (sharedLibFlags)
- {
+ const char* sharedLibFlags = mf->GetSafeDefinition(sharedLibFlagsVar);
+ if (sharedLibFlags) {
this->LanguageToOriginalSharedLibFlags[lang] = sharedLibFlags;
- }
+ }
// Translate compiler ids for compatibility.
this->CheckCompilerIdCompatibility(mf, lang);
- } // end for each language
+ } // end for each language
// Now load files that can override any settings on the platform or for
// the project First load the project compatibility file if it is in
@@ -835,26 +742,22 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
projectCompatibility += "/Modules/";
projectCompatibility += mf->GetSafeDefinition("PROJECT_NAME");
projectCompatibility += "Compatibility.cmake";
- if(cmSystemTools::FileExists(projectCompatibility.c_str()))
- {
+ if (cmSystemTools::FileExists(projectCompatibility.c_str())) {
mf->ReadListFile(projectCompatibility.c_str());
- }
+ }
// Inform any extra generator of the new language.
- if (this->ExtraGenerator)
- {
+ if (this->ExtraGenerator) {
this->ExtraGenerator->EnableLanguage(languages, mf, false);
- }
+ }
- if(fatalError)
- {
+ if (fatalError) {
cmSystemTools::SetFatalErrorOccured();
- }
+ }
for (std::set<std::string>::iterator li = cur_languages.begin();
- li != cur_languages.end(); ++li)
- {
+ li != cur_languages.end(); ++li) {
this->LanguagesInProgress.erase(*li);
- }
+ }
}
void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
@@ -862,40 +765,30 @@ void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
const char* envVar) const
{
// Subclasses override this method if they do not support this advice.
- os <<
- "Tell CMake where to find the compiler by setting "
- ;
- if(envVar)
- {
- os <<
- "either the environment variable \"" << envVar << "\" or "
- ;
- }
- os <<
- "the CMake cache entry CMAKE_" << lang << "_COMPILER "
- "to the full path to the compiler, or to the compiler name "
- "if it is in the PATH."
- ;
+ os << "Tell CMake where to find the compiler by setting ";
+ if (envVar) {
+ os << "either the environment variable \"" << envVar << "\" or ";
+ }
+ os << "the CMake cache entry CMAKE_" << lang
+ << "_COMPILER "
+ "to the full path to the compiler, or to the compiler name "
+ "if it is in the PATH.";
}
-void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
- std::string const& lang) const
+void cmGlobalGenerator::CheckCompilerIdCompatibility(
+ cmMakefile* mf, std::string const& lang) const
{
std::string compilerIdVar = "CMAKE_" + lang + "_COMPILER_ID";
const char* compilerId = mf->GetDefinition(compilerIdVar);
- if(!compilerId)
- {
+ if (!compilerId) {
return;
- }
+ }
- if(strcmp(compilerId, "AppleClang") == 0)
- {
- switch(mf->GetPolicyStatus(cmPolicies::CMP0025))
- {
+ if (strcmp(compilerId, "AppleClang") == 0) {
+ switch (mf->GetPolicyStatus(cmPolicies::CMP0025)) {
case cmPolicies::WARN:
- if(!this->CMakeInstance->GetIsInTryCompile() &&
- mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0025"))
- {
+ if (!this->CMakeInstance->GetIsInTryCompile() &&
+ mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0025")) {
std::ostringstream w;
/* clang-format off */
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0025) << "\n"
@@ -904,7 +797,7 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
;
/* clang-format on */
mf->IssueMessage(cmake::AUTHOR_WARNING, w.str());
- }
+ }
case cmPolicies::OLD:
// OLD behavior is to convert AppleClang to Clang.
mf->AddDefinition(compilerIdVar, "Clang");
@@ -913,22 +806,18 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
case cmPolicies::REQUIRED_ALWAYS:
mf->IssueMessage(
cmake::FATAL_ERROR,
- cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0025)
- );
+ cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0025));
case cmPolicies::NEW:
// NEW behavior is to keep AppleClang.
break;
- }
}
+ }
- if(strcmp(compilerId, "QCC") == 0)
- {
- switch(mf->GetPolicyStatus(cmPolicies::CMP0047))
- {
+ if (strcmp(compilerId, "QCC") == 0) {
+ switch (mf->GetPolicyStatus(cmPolicies::CMP0047)) {
case cmPolicies::WARN:
- if(!this->CMakeInstance->GetIsInTryCompile() &&
- mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0047"))
- {
+ if (!this->CMakeInstance->GetIsInTryCompile() &&
+ mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0047")) {
std::ostringstream w;
/* clang-format off */
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0047) << "\n"
@@ -937,78 +826,65 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
;
/* clang-format on */
mf->IssueMessage(cmake::AUTHOR_WARNING, w.str());
- }
+ }
case cmPolicies::OLD:
// OLD behavior is to convert QCC to GNU.
mf->AddDefinition(compilerIdVar, "GNU");
- if(lang == "C")
- {
+ if (lang == "C") {
mf->AddDefinition("CMAKE_COMPILER_IS_GNUCC", "1");
- }
- else if(lang == "CXX")
- {
+ } else if (lang == "CXX") {
mf->AddDefinition("CMAKE_COMPILER_IS_GNUCXX", "1");
- }
+ }
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
mf->IssueMessage(
cmake::FATAL_ERROR,
- cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0047)
- );
+ cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0047));
case cmPolicies::NEW:
// NEW behavior is to keep QCC.
break;
- }
}
+ }
}
-std::string
-cmGlobalGenerator::GetLanguageOutputExtension(cmSourceFile const& source) const
+std::string cmGlobalGenerator::GetLanguageOutputExtension(
+ cmSourceFile const& source) const
{
const std::string& lang = source.GetLanguage();
- if(!lang.empty())
- {
+ if (!lang.empty()) {
std::map<std::string, std::string>::const_iterator it =
- this->LanguageToOutputExtension.find(lang);
+ this->LanguageToOutputExtension.find(lang);
- if(it != this->LanguageToOutputExtension.end())
- {
+ if (it != this->LanguageToOutputExtension.end()) {
return it->second;
- }
}
- else
- {
+ } else {
// if no language is found then check to see if it is already an
// ouput extension for some language. In that case it should be ignored
// and in this map, so it will not be compiled but will just be used.
std::string const& ext = source.GetExtension();
- if(!ext.empty())
- {
- if(this->OutputExtensions.count(ext))
- {
+ if (!ext.empty()) {
+ if (this->OutputExtensions.count(ext)) {
return ext;
- }
}
}
+ }
return "";
}
-
std::string cmGlobalGenerator::GetLanguageFromExtension(const char* ext) const
{
// if there is an extension and it starts with . then move past the
// . because the extensions are not stored with a . in the map
- if(ext && *ext == '.')
- {
+ if (ext && *ext == '.') {
++ext;
- }
- std::map<std::string, std::string>::const_iterator it
- = this->ExtensionToLanguage.find(ext);
- if(it != this->ExtensionToLanguage.end())
- {
+ }
+ std::map<std::string, std::string>::const_iterator it =
+ this->ExtensionToLanguage.find(ext);
+ if (it != this->ExtensionToLanguage.end()) {
return it->second;
- }
+ }
return "";
}
@@ -1050,96 +926,83 @@ void cmGlobalGenerator::SetLanguageEnabledMaps(const std::string& l,
// use LanguageToLinkerPreference to detect whether this functions has
// run before
if (this->LanguageToLinkerPreference.find(l) !=
- this->LanguageToLinkerPreference.end())
- {
+ this->LanguageToLinkerPreference.end()) {
return;
- }
+ }
- std::string linkerPrefVar = std::string("CMAKE_") +
- std::string(l) + std::string("_LINKER_PREFERENCE");
+ std::string linkerPrefVar =
+ std::string("CMAKE_") + std::string(l) + std::string("_LINKER_PREFERENCE");
const char* linkerPref = mf->GetDefinition(linkerPrefVar);
int preference = 0;
- if(linkerPref)
- {
- if (sscanf(linkerPref, "%d", &preference)!=1)
- {
+ if (linkerPref) {
+ if (sscanf(linkerPref, "%d", &preference) != 1) {
// backward compatibility: before 2.6 LINKER_PREFERENCE
// was either "None" or "Preferred", and only the first character was
// tested. So if there is a custom language out there and it is
// "Preferred", set its preference high
- if (linkerPref[0]=='P')
- {
+ if (linkerPref[0] == 'P') {
preference = 100;
- }
- else
- {
+ } else {
preference = 0;
- }
}
}
+ }
- if (preference < 0)
- {
+ if (preference < 0) {
std::string msg = linkerPrefVar;
msg += " is negative, adjusting it to 0";
cmSystemTools::Message(msg.c_str(), "Warning");
preference = 0;
- }
+ }
this->LanguageToLinkerPreference[l] = preference;
- std::string outputExtensionVar = std::string("CMAKE_") +
- std::string(l) + std::string("_OUTPUT_EXTENSION");
+ std::string outputExtensionVar =
+ std::string("CMAKE_") + std::string(l) + std::string("_OUTPUT_EXTENSION");
const char* outputExtension = mf->GetDefinition(outputExtensionVar);
- if(outputExtension)
- {
+ if (outputExtension) {
this->LanguageToOutputExtension[l] = outputExtension;
this->OutputExtensions[outputExtension] = outputExtension;
- if(outputExtension[0] == '.')
- {
- this->OutputExtensions[outputExtension+1] = outputExtension+1;
- }
+ if (outputExtension[0] == '.') {
+ this->OutputExtensions[outputExtension + 1] = outputExtension + 1;
}
+ }
// The map was originally filled by SetLanguageEnabledFlag, but
// since then the compiler- and platform-specific files have been
// loaded which might have added more entries.
this->FillExtensionToLanguageMap(l, mf);
- std::string ignoreExtensionsVar = std::string("CMAKE_") +
- std::string(l) + std::string("_IGNORE_EXTENSIONS");
+ std::string ignoreExtensionsVar =
+ std::string("CMAKE_") + std::string(l) + std::string("_IGNORE_EXTENSIONS");
std::string ignoreExts = mf->GetSafeDefinition(ignoreExtensionsVar);
std::vector<std::string> extensionList;
cmSystemTools::ExpandListArgument(ignoreExts, extensionList);
- for(std::vector<std::string>::iterator i = extensionList.begin();
- i != extensionList.end(); ++i)
- {
+ for (std::vector<std::string>::iterator i = extensionList.begin();
+ i != extensionList.end(); ++i) {
this->IgnoreExtensions[*i] = true;
- }
-
+ }
}
void cmGlobalGenerator::FillExtensionToLanguageMap(const std::string& l,
cmMakefile* mf)
{
- std::string extensionsVar = std::string("CMAKE_") +
- std::string(l) + std::string("_SOURCE_FILE_EXTENSIONS");
+ std::string extensionsVar = std::string("CMAKE_") + std::string(l) +
+ std::string("_SOURCE_FILE_EXTENSIONS");
std::string exts = mf->GetSafeDefinition(extensionsVar);
std::vector<std::string> extensionList;
cmSystemTools::ExpandListArgument(exts, extensionList);
- for(std::vector<std::string>::iterator i = extensionList.begin();
- i != extensionList.end(); ++i)
- {
+ for (std::vector<std::string>::iterator i = extensionList.begin();
+ i != extensionList.end(); ++i) {
this->ExtensionToLanguage[*i] = l;
- }
+ }
}
bool cmGlobalGenerator::IgnoreFile(const char* ext) const
{
- if(!this->GetLanguageFromExtension(ext).empty())
- {
+ if (!this->GetLanguageFromExtension(ext).empty()) {
return false;
- }
+ }
return (this->IgnoreExtensions.count(ext) > 0);
}
@@ -1159,10 +1022,9 @@ void cmGlobalGenerator::CreateLocalGenerators()
this->LocalGenerators.clear();
this->LocalGenerators.reserve(this->Makefiles.size());
for (std::vector<cmMakefile*>::const_iterator it = this->Makefiles.begin();
- it != this->Makefiles.end(); ++it)
- {
+ it != this->Makefiles.end(); ++it) {
this->LocalGenerators.push_back(this->CreateLocalGenerator(*it));
- }
+ }
}
void cmGlobalGenerator::Configure()
@@ -1172,16 +1034,16 @@ void cmGlobalGenerator::Configure()
cmState::Snapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
- snapshot.GetDirectory().SetCurrentSource
- (this->CMakeInstance->GetHomeDirectory());
- snapshot.GetDirectory().SetCurrentBinary
- (this->CMakeInstance->GetHomeOutputDirectory());
+ snapshot.GetDirectory().SetCurrentSource(
+ this->CMakeInstance->GetHomeDirectory());
+ snapshot.GetDirectory().SetCurrentBinary(
+ this->CMakeInstance->GetHomeOutputDirectory());
cmMakefile* dirMf = new cmMakefile(this, snapshot);
this->Makefiles.push_back(dirMf);
this->BinaryDirectories.insert(
- this->CMakeInstance->GetHomeOutputDirectory());
+ this->CMakeInstance->GetHomeOutputDirectory());
// now do it
this->ConfigureDoneCMP0026AndCMP0024 = false;
@@ -1194,55 +1056,47 @@ void cmGlobalGenerator::Configure()
cmTargets globalTargets;
this->CreateDefaultGlobalTargets(&globalTargets);
- for (unsigned int i = 0; i < this->Makefiles.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
cmMakefile* mf = this->Makefiles[i];
cmTargets* targets = &(mf->GetTargets());
cmTargets::iterator tit;
- for ( tit = globalTargets.begin(); tit != globalTargets.end(); ++ tit )
- {
+ for (tit = globalTargets.begin(); tit != globalTargets.end(); ++tit) {
(*targets)[tit->first] = tit->second;
(*targets)[tit->first].SetMakefile(mf);
- }
}
+ }
// update the cache entry for the number of local generators, this is used
// for progress
char num[100];
- sprintf(num,"%d",static_cast<int>(this->Makefiles.size()));
- this->GetCMakeInstance()->AddCacheEntry
- ("CMAKE_NUMBER_OF_MAKEFILES", num,
- "number of local generators", cmState::INTERNAL);
+ sprintf(num, "%d", static_cast<int>(this->Makefiles.size()));
+ this->GetCMakeInstance()->AddCacheEntry("CMAKE_NUMBER_OF_MAKEFILES", num,
+ "number of local generators",
+ cmState::INTERNAL);
// check for link libraries and include directories containing "NOTFOUND"
// and for infinite loops
this->CheckTargetProperties();
- if ( this->CMakeInstance->GetWorkingMode() == cmake::NORMAL_MODE)
- {
+ if (this->CMakeInstance->GetWorkingMode() == cmake::NORMAL_MODE) {
std::ostringstream msg;
- if(cmSystemTools::GetErrorOccuredFlag())
- {
+ if (cmSystemTools::GetErrorOccuredFlag()) {
msg << "Configuring incomplete, errors occurred!";
- const char* logs[] = {"CMakeOutput.log", "CMakeError.log", 0};
- for(const char** log = logs; *log; ++log)
- {
+ const char* logs[] = { "CMakeOutput.log", "CMakeError.log", 0 };
+ for (const char** log = logs; *log; ++log) {
std::string f = this->CMakeInstance->GetHomeOutputDirectory();
f += this->CMakeInstance->GetCMakeFilesDirectory();
f += "/";
f += *log;
- if(cmSystemTools::FileExists(f.c_str()))
- {
+ if (cmSystemTools::FileExists(f.c_str())) {
msg << "\nSee also \"" << f << "\".";
- }
}
}
- else
- {
+ } else {
msg << "Configuring done";
- }
- this->CMakeInstance->UpdateProgress(msg.str().c_str(), -1);
}
+ this->CMakeInstance->UpdateProgress(msg.str().c_str(), -1);
+ }
}
void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes)
@@ -1252,31 +1106,29 @@ void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes)
this->ComputeBuildFileGenerators();
}
-void cmGlobalGenerator::CreateImportedGenerationObjects(cmMakefile* mf,
- const std::vector<std::string>& targets,
- std::vector<const cmGeneratorTarget*>& exports)
+void cmGlobalGenerator::CreateImportedGenerationObjects(
+ cmMakefile* mf, const std::vector<std::string>& targets,
+ std::vector<const cmGeneratorTarget*>& exports)
{
this->CreateGenerationObjects(ImportedOnly);
std::vector<cmMakefile*>::iterator mfit =
- std::find(this->Makefiles.begin(), this->Makefiles.end(), mf);
+ std::find(this->Makefiles.begin(), this->Makefiles.end(), mf);
cmLocalGenerator* lg =
- this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)];
+ this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)];
for (std::vector<std::string>::const_iterator it = targets.begin();
- it != targets.end(); ++it)
- {
+ it != targets.end(); ++it) {
cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(*it);
- if (gt)
- {
+ if (gt) {
exports.push_back(gt);
- }
}
+ }
}
-cmExportBuildFileGenerator*
-cmGlobalGenerator::GetExportedTargetsFile(const std::string &filename) const
+cmExportBuildFileGenerator* cmGlobalGenerator::GetExportedTargetsFile(
+ const std::string& filename) const
{
- std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it
- = this->BuildExportSets.find(filename);
+ std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it =
+ this->BuildExportSets.find(filename);
return it == this->BuildExportSets.end() ? 0 : it->second;
}
@@ -1288,11 +1140,10 @@ void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target)
bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
{
// If the property is not enabled then okay.
- if(!this->CMakeInstance->GetState()
- ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS"))
- {
+ if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+ "ALLOW_DUPLICATE_CUSTOM_TARGETS")) {
return true;
- }
+ }
// This generator does not support duplicate custom targets.
std::ostringstream e;
@@ -1308,16 +1159,15 @@ bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
void cmGlobalGenerator::ComputeBuildFileGenerators()
{
- for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
std::vector<cmExportBuildFileGenerator*> gens =
- this->Makefiles[i]->GetExportBuildFileGenerators();
+ this->Makefiles[i]->GetExportBuildFileGenerators();
for (std::vector<cmExportBuildFileGenerator*>::const_iterator it =
- gens.begin(); it != gens.end(); ++it)
- {
+ gens.begin();
+ it != gens.end(); ++it) {
(*it)->Compute(this->LocalGenerators[i]);
- }
}
+ }
}
bool cmGlobalGenerator::Compute()
@@ -1330,10 +1180,9 @@ bool cmGlobalGenerator::Compute()
this->CMP0042WarnTargets.clear();
// Check whether this generator is allowed to run.
- if(!this->CheckALLOW_DUPLICATE_CUSTOM_TARGETS())
- {
+ if (!this->CheckALLOW_DUPLICATE_CUSTOM_TARGETS()) {
return false;
- }
+ }
this->FinalizeTargetCompileInfo();
this->CreateGenerationObjects();
@@ -1346,63 +1195,56 @@ bool cmGlobalGenerator::Compute()
// Iterate through all targets and set up automoc for those which have
// the AUTOMOC, AUTOUIC or AUTORCC property set
std::vector<cmGeneratorTarget const*> autogenTargets =
- this->CreateQtAutoGeneratorsTargets();
+ this->CreateQtAutoGeneratorsTargets();
#endif
unsigned int i;
// Add generator specific helper commands
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
this->LocalGenerators[i]->AddHelperCommands();
- }
+ }
#ifdef CMAKE_BUILD_WITH_CMAKE
for (std::vector<cmGeneratorTarget const*>::iterator it =
- autogenTargets.begin(); it != autogenTargets.end(); ++it)
- {
+ autogenTargets.begin();
+ it != autogenTargets.end(); ++it) {
cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(*it);
- }
+ }
#endif
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
cmMakefile* mf = this->LocalGenerators[i]->GetMakefile();
std::vector<cmInstallGenerator*>& gens = mf->GetInstallGenerators();
for (std::vector<cmInstallGenerator*>::const_iterator git = gens.begin();
- git != gens.end(); ++git)
- {
+ git != gens.end(); ++git) {
(*git)->Compute(this->LocalGenerators[i]);
- }
}
+ }
this->AddExtraIDETargets();
// Trace the dependencies, after that no custom commands should be added
// because their dependencies might not be handled correctly
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
this->LocalGenerators[i]->TraceDependencies();
- }
+ }
this->ForceLinkerLanguages();
// Compute the manifest of main targets generated.
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
this->LocalGenerators[i]->ComputeTargetManifest();
- }
+ }
// Compute the inter-target dependencies.
- if(!this->ComputeTargetDepends())
- {
+ if (!this->ComputeTargetDepends()) {
return false;
- }
+ }
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
this->LocalGenerators[i]->ComputeHomeRelativeOutputPath();
- }
+ }
return true;
}
@@ -1416,65 +1258,56 @@ void cmGlobalGenerator::Generate()
this->ProcessEvaluationFiles();
// Generate project files
- for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
this->SetCurrentMakefile(this->LocalGenerators[i]->GetMakefile());
this->LocalGenerators[i]->Generate();
- if(!this->LocalGenerators[i]->GetMakefile()->IsOn(
- "CMAKE_SKIP_INSTALL_RULES"))
- {
+ if (!this->LocalGenerators[i]->GetMakefile()->IsOn(
+ "CMAKE_SKIP_INSTALL_RULES")) {
this->LocalGenerators[i]->GenerateInstallRules();
- }
- this->LocalGenerators[i]->GenerateTestFiles();
- this->CMakeInstance->UpdateProgress("Generating",
- (static_cast<float>(i)+1.0f)/
- static_cast<float>(this->LocalGenerators.size()));
}
+ this->LocalGenerators[i]->GenerateTestFiles();
+ this->CMakeInstance->UpdateProgress(
+ "Generating", (static_cast<float>(i) + 1.0f) /
+ static_cast<float>(this->LocalGenerators.size()));
+ }
this->SetCurrentMakefile(0);
- if(!this->GenerateCPackPropertiesFile())
- {
+ if (!this->GenerateCPackPropertiesFile()) {
this->GetCMakeInstance()->IssueMessage(
cmake::FATAL_ERROR, "Could not write CPack properties file.");
- }
+ }
- for (std::map<std::string, cmExportBuildFileGenerator*>::iterator
- it = this->BuildExportSets.begin(); it != this->BuildExportSets.end();
- ++it)
- {
- if (!it->second->GenerateImportFile()
- && !cmSystemTools::GetErrorOccuredFlag())
- {
- this->GetCMakeInstance()
- ->IssueMessage(cmake::FATAL_ERROR, "Could not write export file.");
+ for (std::map<std::string, cmExportBuildFileGenerator*>::iterator it =
+ this->BuildExportSets.begin();
+ it != this->BuildExportSets.end(); ++it) {
+ if (!it->second->GenerateImportFile() &&
+ !cmSystemTools::GetErrorOccuredFlag()) {
+ this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR,
+ "Could not write export file.");
return;
- }
}
+ }
// Update rule hashes.
this->CheckRuleHashes();
this->WriteSummary();
- if (this->ExtraGenerator != 0)
- {
+ if (this->ExtraGenerator != 0) {
this->ExtraGenerator->Generate();
- }
+ }
- if(!this->CMP0042WarnTargets.empty())
- {
+ if (!this->CMP0042WarnTargets.empty()) {
std::ostringstream w;
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0042) << "\n";
w << "MACOSX_RPATH is not specified for"
" the following targets:\n";
- for(std::set<std::string>::iterator
- iter = this->CMP0042WarnTargets.begin();
- iter != this->CMP0042WarnTargets.end();
- ++iter)
- {
+ for (std::set<std::string>::iterator iter =
+ this->CMP0042WarnTargets.begin();
+ iter != this->CMP0042WarnTargets.end(); ++iter) {
w << " " << *iter << "\n";
- }
- this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
+ this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+ }
this->CMakeInstance->UpdateProgress("Generating done", -1);
}
@@ -1482,16 +1315,15 @@ void cmGlobalGenerator::Generate()
bool cmGlobalGenerator::ComputeTargetDepends()
{
cmComputeTargetDepends ctd(this);
- if(!ctd.Compute())
- {
+ if (!ctd.Compute()) {
return false;
- }
+ }
std::vector<cmGeneratorTarget const*> const& targets = ctd.GetTargets();
- for(std::vector<cmGeneratorTarget const*>::const_iterator ti
- = targets.begin(); ti != targets.end(); ++ti)
- {
+ for (std::vector<cmGeneratorTarget const*>::const_iterator ti =
+ targets.begin();
+ ti != targets.end(); ++ti) {
ctd.GetTargetDirectDepends(*ti, this->TargetDependencies[*ti]);
- }
+ }
return true;
}
@@ -1501,59 +1333,52 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
std::vector<const cmGeneratorTarget*> autogenTargets;
#ifdef CMAKE_BUILD_WITH_CMAKE
- for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
std::vector<cmGeneratorTarget*> targets =
this->LocalGenerators[i]->GetGeneratorTargets();
std::vector<cmGeneratorTarget*> filteredTargets;
filteredTargets.reserve(targets.size());
- for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
- ti != targets.end(); ++ti)
- {
- if ((*ti)->GetType() == cmState::GLOBAL_TARGET)
- {
+ for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
+ ti != targets.end(); ++ti) {
+ if ((*ti)->GetType() == cmState::GLOBAL_TARGET) {
continue;
- }
- if((*ti)->GetType() != cmState::EXECUTABLE &&
- (*ti)->GetType() != cmState::STATIC_LIBRARY &&
- (*ti)->GetType() != cmState::SHARED_LIBRARY &&
- (*ti)->GetType() != cmState::MODULE_LIBRARY &&
- (*ti)->GetType() != cmState::OBJECT_LIBRARY)
- {
+ }
+ if ((*ti)->GetType() != cmState::EXECUTABLE &&
+ (*ti)->GetType() != cmState::STATIC_LIBRARY &&
+ (*ti)->GetType() != cmState::SHARED_LIBRARY &&
+ (*ti)->GetType() != cmState::MODULE_LIBRARY &&
+ (*ti)->GetType() != cmState::OBJECT_LIBRARY) {
continue;
- }
- if((!(*ti)->GetPropertyAsBool("AUTOMOC")
- && !(*ti)->GetPropertyAsBool("AUTOUIC")
- && !(*ti)->GetPropertyAsBool("AUTORCC"))
- || (*ti)->IsImported())
- {
+ }
+ if ((!(*ti)->GetPropertyAsBool("AUTOMOC") &&
+ !(*ti)->GetPropertyAsBool("AUTOUIC") &&
+ !(*ti)->GetPropertyAsBool("AUTORCC")) ||
+ (*ti)->IsImported()) {
continue;
- }
+ }
// don't do anything if there is no Qt4 or Qt5Core (which contains moc):
cmMakefile* mf = (*ti)->Target->GetMakefile();
std::string qtMajorVersion = mf->GetSafeDefinition("QT_VERSION_MAJOR");
- if (qtMajorVersion == "")
- {
+ if (qtMajorVersion == "") {
qtMajorVersion = mf->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
- }
- if (qtMajorVersion != "4" && qtMajorVersion != "5")
- {
+ }
+ if (qtMajorVersion != "4" && qtMajorVersion != "5") {
continue;
- }
+ }
cmGeneratorTarget* gt = *ti;
cmQtAutoGeneratorInitializer::InitializeAutogenSources(gt);
filteredTargets.push_back(gt);
- }
- for(std::vector<cmGeneratorTarget*>::iterator ti = filteredTargets.begin();
- ti != filteredTargets.end(); ++ti)
- {
+ }
+ for (std::vector<cmGeneratorTarget*>::iterator ti =
+ filteredTargets.begin();
+ ti != filteredTargets.end(); ++ti) {
cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
- this->LocalGenerators[i], *ti);
+ this->LocalGenerators[i], *ti);
autogenTargets.push_back(*ti);
- }
}
+ }
#endif
return autogenTargets;
}
@@ -1561,114 +1386,95 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
void cmGlobalGenerator::FinalizeTargetCompileInfo()
{
// Construct per-target generator information.
- for(unsigned int i=0; i < this->Makefiles.size(); ++i)
- {
- cmMakefile *mf = this->Makefiles[i];
+ for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
+ cmMakefile* mf = this->Makefiles[i];
const cmStringRange noconfig_compile_definitions =
- mf->GetCompileDefinitionsEntries();
+ mf->GetCompileDefinitionsEntries();
const cmBacktraceRange noconfig_compile_definitions_bts =
- mf->GetCompileDefinitionsBacktraces();
+ mf->GetCompileDefinitionsBacktraces();
cmTargets& targets = mf->GetTargets();
- for(cmTargets::iterator ti = targets.begin();
- ti != targets.end(); ++ti)
- {
+ for (cmTargets::iterator ti = targets.begin(); ti != targets.end(); ++ti) {
cmTarget* t = &ti->second;
- if (t->GetType() == cmState::GLOBAL_TARGET)
- {
+ if (t->GetType() == cmState::GLOBAL_TARGET) {
continue;
- }
+ }
t->AppendBuildInterfaceIncludes();
- if (t->GetType() == cmState::INTERFACE_LIBRARY)
- {
+ if (t->GetType() == cmState::INTERFACE_LIBRARY) {
continue;
- }
+ }
- cmBacktraceRange::const_iterator btIt
- = noconfig_compile_definitions_bts.begin();
- for (cmStringRange::const_iterator it
- = noconfig_compile_definitions.begin();
- it != noconfig_compile_definitions.end(); ++it, ++btIt)
- {
+ cmBacktraceRange::const_iterator btIt =
+ noconfig_compile_definitions_bts.begin();
+ for (cmStringRange::const_iterator
+ it = noconfig_compile_definitions.begin();
+ it != noconfig_compile_definitions.end(); ++it, ++btIt) {
t->InsertCompileDefinition(*it, *btIt);
- }
+ }
- cmPolicies::PolicyStatus polSt
- = mf->GetPolicyStatus(cmPolicies::CMP0043);
- if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
- {
+ cmPolicies::PolicyStatus polSt =
+ mf->GetPolicyStatus(cmPolicies::CMP0043);
+ if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) {
std::vector<std::string> configs;
mf->GetConfigurations(configs);
- for(std::vector<std::string>::const_iterator ci = configs.begin();
- ci != configs.end(); ++ci)
- {
+ for (std::vector<std::string>::const_iterator ci = configs.begin();
+ ci != configs.end(); ++ci) {
std::string defPropName = "COMPILE_DEFINITIONS_";
defPropName += cmSystemTools::UpperCase(*ci);
- t->AppendProperty(defPropName,
- mf->GetProperty(defPropName));
- }
+ t->AppendProperty(defPropName, mf->GetProperty(defPropName));
}
}
}
+ }
}
void cmGlobalGenerator::CreateGeneratorTargets(
- TargetTypes targetTypes,
- cmMakefile *mf,
- cmLocalGenerator *lg,
- std::map<cmTarget*, cmGeneratorTarget*> const& importedMap)
+ TargetTypes targetTypes, cmMakefile* mf, cmLocalGenerator* lg,
+ std::map<cmTarget*, cmGeneratorTarget*> const& importedMap)
{
- if (targetTypes == AllTargets)
- {
+ if (targetTypes == AllTargets) {
cmTargets& targets = mf->GetTargets();
- for(cmTargets::iterator ti = targets.begin();
- ti != targets.end(); ++ti)
- {
+ for (cmTargets::iterator ti = targets.begin(); ti != targets.end(); ++ti) {
cmTarget* t = &ti->second;
cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg);
lg->AddGeneratorTarget(gt);
- }
}
+ }
std::vector<cmTarget*> itgts = mf->GetImportedTargets();
- for(std::vector<cmTarget*>::const_iterator
- j = itgts.begin(); j != itgts.end(); ++j)
- {
+ for (std::vector<cmTarget*>::const_iterator j = itgts.begin();
+ j != itgts.end(); ++j) {
lg->AddImportedGeneratorTarget(importedMap.find(*j)->second);
- }
+ }
}
void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes)
{
std::map<cmTarget*, cmGeneratorTarget*> importedMap;
- for(unsigned int i=0; i < this->Makefiles.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
cmMakefile* mf = this->Makefiles[i];
- for(std::vector<cmTarget*>::const_iterator
- j = mf->GetOwnedImportedTargets().begin();
- j != mf->GetOwnedImportedTargets().end(); ++j)
- {
+ for (std::vector<cmTarget*>::const_iterator j =
+ mf->GetOwnedImportedTargets().begin();
+ j != mf->GetOwnedImportedTargets().end(); ++j) {
cmLocalGenerator* lg = this->LocalGenerators[i];
cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg);
lg->AddOwnedImportedGeneratorTarget(gt);
importedMap[*j] = gt;
- }
}
+ }
// Construct per-target generator information.
- for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
this->CreateGeneratorTargets(targetTypes, this->Makefiles[i],
this->LocalGenerators[i], importedMap);
- }
+ }
}
-
void cmGlobalGenerator::ClearGeneratorMembers()
{
cmDeleteAll(this->BuildExportSets);
@@ -1697,126 +1503,108 @@ void cmGlobalGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const
void cmGlobalGenerator::CheckTargetProperties()
{
std::map<std::string, std::string> notFoundMap;
-// std::set<std::string> notFoundMap;
+ // std::set<std::string> notFoundMap;
// after it is all done do a ConfigureFinalPass
cmState* state = this->GetCMakeInstance()->GetState();
- for (unsigned int i = 0; i < this->Makefiles.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
this->Makefiles[i]->ConfigureFinalPass();
- cmTargets &targets =
- this->Makefiles[i]->GetTargets();
- for (cmTargets::iterator l = targets.begin();
- l != targets.end(); l++)
- {
- if (l->second.GetType() == cmState::INTERFACE_LIBRARY)
- {
+ cmTargets& targets = this->Makefiles[i]->GetTargets();
+ for (cmTargets::iterator l = targets.begin(); l != targets.end(); l++) {
+ if (l->second.GetType() == cmState::INTERFACE_LIBRARY) {
continue;
- }
+ }
const cmTarget::LinkLibraryVectorType& libs =
l->second.GetOriginalLinkLibraries();
- for(cmTarget::LinkLibraryVectorType::const_iterator lib = libs.begin();
- lib != libs.end(); ++lib)
- {
- if(lib->first.size() > 9 &&
- cmSystemTools::IsNOTFOUND(lib->first.c_str()))
- {
- std::string varName = lib->first.substr(0, lib->first.size()-9);
- if(state->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
- {
+ for (cmTarget::LinkLibraryVectorType::const_iterator lib = libs.begin();
+ lib != libs.end(); ++lib) {
+ if (lib->first.size() > 9 &&
+ cmSystemTools::IsNOTFOUND(lib->first.c_str())) {
+ std::string varName = lib->first.substr(0, lib->first.size() - 9);
+ if (state->GetCacheEntryPropertyAsBool(varName, "ADVANCED")) {
varName += " (ADVANCED)";
- }
+ }
std::string text = notFoundMap[varName];
text += "\n linked by target \"";
text += l->second.GetName();
text += "\" in directory ";
- text+=this->Makefiles[i]->GetCurrentSourceDirectory();
+ text += this->Makefiles[i]->GetCurrentSourceDirectory();
notFoundMap[varName] = text;
- }
}
+ }
std::vector<std::string> incs;
- const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
- if (!incDirProp)
- {
+ const char* incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
+ if (!incDirProp) {
continue;
- }
+ }
- std::string incDirs = cmGeneratorExpression::Preprocess(incDirProp,
- cmGeneratorExpression::StripAllGeneratorExpressions);
+ std::string incDirs = cmGeneratorExpression::Preprocess(
+ incDirProp, cmGeneratorExpression::StripAllGeneratorExpressions);
cmSystemTools::ExpandListArgument(incDirs, incs);
- for( std::vector<std::string>::const_iterator incDir = incs.begin();
- incDir != incs.end(); ++incDir)
- {
- if(incDir->size() > 9 &&
- cmSystemTools::IsNOTFOUND(incDir->c_str()))
- {
- std::string varName = incDir->substr(0, incDir->size()-9);
- if(state->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
- {
+ for (std::vector<std::string>::const_iterator incDir = incs.begin();
+ incDir != incs.end(); ++incDir) {
+ if (incDir->size() > 9 && cmSystemTools::IsNOTFOUND(incDir->c_str())) {
+ std::string varName = incDir->substr(0, incDir->size() - 9);
+ if (state->GetCacheEntryPropertyAsBool(varName, "ADVANCED")) {
varName += " (ADVANCED)";
- }
+ }
std::string text = notFoundMap[varName];
text += "\n used as include directory in directory ";
text += this->Makefiles[i]->GetCurrentSourceDirectory();
notFoundMap[varName] = text;
- }
}
}
- this->CMakeInstance->UpdateProgress
- ("Configuring", 0.9f+0.1f*(static_cast<float>(i)+1.0f)/
- static_cast<float>(this->Makefiles.size()));
}
+ this->CMakeInstance->UpdateProgress(
+ "Configuring", 0.9f +
+ 0.1f * (static_cast<float>(i) + 1.0f) /
+ static_cast<float>(this->Makefiles.size()));
+ }
- if(!notFoundMap.empty())
- {
+ if (!notFoundMap.empty()) {
std::string notFoundVars;
- for(std::map<std::string, std::string>::const_iterator
- ii = notFoundMap.begin();
- ii != notFoundMap.end();
- ++ii)
- {
+ for (std::map<std::string, std::string>::const_iterator ii =
+ notFoundMap.begin();
+ ii != notFoundMap.end(); ++ii) {
notFoundVars += ii->first;
notFoundVars += ii->second;
notFoundVars += "\n";
- }
+ }
cmSystemTools::Error("The following variables are used in this project, "
"but they are set to NOTFOUND.\n"
"Please set them or make sure they are set and "
"tested correctly in the CMake files:\n",
notFoundVars.c_str());
- }
+ }
}
int cmGlobalGenerator::TryCompile(const std::string& srcdir,
const std::string& bindir,
const std::string& projectName,
const std::string& target, bool fast,
- std::string& output, cmMakefile *mf)
+ std::string& output, cmMakefile* mf)
{
// if this is not set, then this is a first time configure
// and there is a good chance that the try compile stuff will
// take the bulk of the time, so try and guess some progress
// by getting closer and closer to 100 without actually getting there.
- if (!this->CMakeInstance->GetState()->GetInitializedCacheValue
- ("CMAKE_NUMBER_OF_MAKEFILES"))
- {
+ if (!this->CMakeInstance->GetState()->GetInitializedCacheValue(
+ "CMAKE_NUMBER_OF_MAKEFILES")) {
// If CMAKE_NUMBER_OF_MAKEFILES is not set
// we are in the first time progress and we have no
// idea how long it will be. So, just move 1/10th of the way
// there each time, and don't go over 95%
- this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) /30.0f);
- if(this->FirstTimeProgress > 0.95f)
- {
+ this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) / 30.0f);
+ if (this->FirstTimeProgress > 0.95f) {
this->FirstTimeProgress = 0.95f;
- }
+ }
this->CMakeInstance->UpdateProgress("Configuring",
this->FirstTimeProgress);
- }
+ }
std::string newTarget;
- if (!target.empty())
- {
+ if (!target.empty()) {
newTarget += target;
#if 0
#if defined(_WIN32) || defined(__CYGWIN__)
@@ -1829,35 +1617,30 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir,
}
#endif // WIN32
#endif
- }
+ }
std::string config =
mf->GetSafeDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
- return this->Build(srcdir,bindir,projectName,
- newTarget,
- output,"",config,false,fast,false,
- this->TryCompileTimeout);
+ return this->Build(srcdir, bindir, projectName, newTarget, output, "",
+ config, false, fast, false, this->TryCompileTimeout);
}
void cmGlobalGenerator::GenerateBuildCommand(
std::vector<std::string>& makeCommand, const std::string&,
const std::string&, const std::string&, const std::string&,
- const std::string&, bool, bool,
- std::vector<std::string> const&)
+ const std::string&, bool, bool, std::vector<std::string> const&)
{
makeCommand.push_back(
"cmGlobalGenerator::GenerateBuildCommand not implemented");
}
-int cmGlobalGenerator::Build(
- const std::string&, const std::string& bindir,
- const std::string& projectName, const std::string& target,
- std::string& output,
- const std::string& makeCommandCSTR,
- const std::string& config,
- bool clean, bool fast, bool verbose,
- double timeout,
- cmSystemTools::OutputOption outputflag,
- std::vector<std::string> const& nativeOptions)
+int cmGlobalGenerator::Build(const std::string&, const std::string& bindir,
+ const std::string& projectName,
+ const std::string& target, std::string& output,
+ const std::string& makeCommandCSTR,
+ const std::string& config, bool clean, bool fast,
+ bool verbose, double timeout,
+ cmSystemTools::OutputOption outputflag,
+ std::vector<std::string> const& nativeOptions)
{
/**
* Run an executable command and put the stdout in output.
@@ -1875,21 +1658,19 @@ int cmGlobalGenerator::Build(
std::string* outputPtr = &outputBuffer;
std::vector<std::string> makeCommand;
- this->GenerateBuildCommand(makeCommand, makeCommandCSTR, projectName,
- bindir, target, config, fast, verbose,
- nativeOptions);
+ this->GenerateBuildCommand(makeCommand, makeCommandCSTR, projectName, bindir,
+ target, config, fast, verbose, nativeOptions);
// Workaround to convince VCExpress.exe to produce output.
if (outputflag == cmSystemTools::OUTPUT_PASSTHROUGH &&
- !makeCommand.empty() && cmSystemTools::LowerCase(
- cmSystemTools::GetFilenameName(makeCommand[0])) == "vcexpress.exe")
- {
+ !makeCommand.empty() &&
+ cmSystemTools::LowerCase(
+ cmSystemTools::GetFilenameName(makeCommand[0])) == "vcexpress.exe") {
outputflag = cmSystemTools::OUTPUT_FORWARD;
- }
+ }
// should we do a clean first?
- if (clean)
- {
+ if (clean) {
std::vector<std::string> cleanCommand;
this->GenerateBuildCommand(cleanCommand, makeCommandCSTR, projectName,
bindir, "clean", config, fast, verbose);
@@ -1898,8 +1679,7 @@ int cmGlobalGenerator::Build(
output += "\n";
if (!cmSystemTools::RunSingleCommand(cleanCommand, outputPtr, outputPtr,
- &retVal, 0, outputflag, timeout))
- {
+ &retVal, 0, outputflag, timeout)) {
cmSystemTools::SetRunCommandHideConsole(hideconsole);
cmSystemTools::Error("Generator: execution of make clean failed.");
output += *outputPtr;
@@ -1908,9 +1688,9 @@ int cmGlobalGenerator::Build(
// return to the original directory
cmSystemTools::ChangeDirectory(cwd);
return 1;
- }
- output += *outputPtr;
}
+ output += *outputPtr;
+ }
// now build
std::string makeCommandStr = cmSystemTools::PrintSingleCommand(makeCommand);
@@ -1919,30 +1699,28 @@ int cmGlobalGenerator::Build(
output += "\n";
if (!cmSystemTools::RunSingleCommand(makeCommand, outputPtr, outputPtr,
- &retVal, 0, outputflag, timeout))
- {
+ &retVal, 0, outputflag, timeout)) {
cmSystemTools::SetRunCommandHideConsole(hideconsole);
- cmSystemTools::Error
- ("Generator: execution of make failed. Make command was: ",
- makeCommandStr.c_str());
+ cmSystemTools::Error(
+ "Generator: execution of make failed. Make command was: ",
+ makeCommandStr.c_str());
output += *outputPtr;
- output += "\nGenerator: execution of make failed. Make command was: "
- + makeCommandStr + "\n";
+ output += "\nGenerator: execution of make failed. Make command was: " +
+ makeCommandStr + "\n";
// return to the original directory
cmSystemTools::ChangeDirectory(cwd);
return 1;
- }
+ }
output += *outputPtr;
cmSystemTools::SetRunCommandHideConsole(hideconsole);
// The SGI MipsPro 7.3 compiler does not return an error code when
// the source has a #error in it! This is a work-around for such
// compilers.
- if((retVal == 0) && (output.find("#error") != std::string::npos))
- {
+ if ((retVal == 0) && (output.find("#error") != std::string::npos)) {
retVal = 1;
- }
+ }
cmSystemTools::ChangeDirectory(cwd);
return retVal;
@@ -1950,85 +1728,75 @@ int cmGlobalGenerator::Build(
std::string cmGlobalGenerator::GenerateCMakeBuildCommand(
const std::string& target, const std::string& config,
- const std::string& native,
- bool ignoreErrors)
+ const std::string& native, bool ignoreErrors)
{
std::string makeCommand = cmSystemTools::GetCMakeCommand();
makeCommand = cmSystemTools::ConvertToOutputPath(makeCommand.c_str());
makeCommand += " --build .";
- if(!config.empty())
- {
+ if (!config.empty()) {
makeCommand += " --config \"";
makeCommand += config;
makeCommand += "\"";
- }
- if(!target.empty())
- {
+ }
+ if (!target.empty()) {
makeCommand += " --target \"";
makeCommand += target;
makeCommand += "\"";
- }
+ }
const char* sep = " -- ";
- if(ignoreErrors)
- {
+ if (ignoreErrors) {
const char* iflag = this->GetBuildIgnoreErrorsFlag();
- if(iflag && *iflag)
- {
+ if (iflag && *iflag) {
makeCommand += sep;
makeCommand += iflag;
sep = " ";
- }
}
- if(!native.empty())
- {
+ }
+ if (!native.empty()) {
makeCommand += sep;
makeCommand += native;
- }
+ }
return makeCommand;
}
-void cmGlobalGenerator::AddMakefile(cmMakefile *mf)
+void cmGlobalGenerator::AddMakefile(cmMakefile* mf)
{
this->Makefiles.push_back(mf);
// update progress
// estimate how many lg there will be
- const char *numGenC =
- this->CMakeInstance->GetState()->GetInitializedCacheValue
- ("CMAKE_NUMBER_OF_MAKEFILES");
+ const char* numGenC =
+ this->CMakeInstance->GetState()->GetInitializedCacheValue(
+ "CMAKE_NUMBER_OF_MAKEFILES");
- if (!numGenC)
- {
+ if (!numGenC) {
// If CMAKE_NUMBER_OF_MAKEFILES is not set
// we are in the first time progress and we have no
// idea how long it will be. So, just move half way
// there each time, and don't go over 95%
- this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) /30.0f);
- if(this->FirstTimeProgress > 0.95f)
- {
+ this->FirstTimeProgress += ((1.0f - this->FirstTimeProgress) / 30.0f);
+ if (this->FirstTimeProgress > 0.95f) {
this->FirstTimeProgress = 0.95f;
- }
+ }
this->CMakeInstance->UpdateProgress("Configuring",
this->FirstTimeProgress);
return;
- }
+ }
int numGen = atoi(numGenC);
- float prog = 0.9f*static_cast<float>(this->Makefiles.size())/
+ float prog = 0.9f * static_cast<float>(this->Makefiles.size()) /
static_cast<float>(numGen);
- if (prog > 0.9f)
- {
+ if (prog > 0.9f) {
prog = 0.9f;
- }
+ }
this->CMakeInstance->UpdateProgress("Configuring", prog);
}
void cmGlobalGenerator::AddInstallComponent(const char* component)
{
- if(component && *component)
- {
+ if (component && *component) {
this->InstallComponents.insert(component);
- }
+ }
}
void cmGlobalGenerator::EnableInstallTarget()
@@ -2036,13 +1804,12 @@ void cmGlobalGenerator::EnableInstallTarget()
this->InstallTargetEnabled = true;
}
-cmLocalGenerator*
-cmGlobalGenerator::CreateLocalGenerator(cmMakefile* mf)
+cmLocalGenerator* cmGlobalGenerator::CreateLocalGenerator(cmMakefile* mf)
{
return new cmLocalGenerator(this, mf);
}
-void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
+void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator* gen,
cmMakefile* mf)
{
this->SetConfiguredFilesPath(gen);
@@ -2050,12 +1817,10 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
const char* make =
gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
- "make program",
- cmState::FILEPATH);
+ "make program", cmState::FILEPATH);
// copy the enabled languages
this->GetCMakeInstance()->GetState()->SetEnabledLanguages(
- gen->GetCMakeInstance()->GetState()->GetEnabledLanguages()
- );
+ gen->GetCMakeInstance()->GetState()->GetEnabledLanguages());
this->LanguagesReady = gen->LanguagesReady;
this->ExtensionToLanguage = gen->ExtensionToLanguage;
this->IgnoreExtensions = gen->IgnoreExtensions;
@@ -2066,36 +1831,30 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
void cmGlobalGenerator::SetConfiguredFilesPath(cmGlobalGenerator* gen)
{
- if(!gen->ConfiguredFilesPath.empty())
- {
+ if (!gen->ConfiguredFilesPath.empty()) {
this->ConfiguredFilesPath = gen->ConfiguredFilesPath;
- }
- else
- {
+ } else {
this->ConfiguredFilesPath = gen->CMakeInstance->GetHomeOutputDirectory();
this->ConfiguredFilesPath += cmake::GetCMakeFilesDirectory();
- }
+ }
}
bool cmGlobalGenerator::IsExcluded(cmState::Snapshot const& rootSnp,
- cmState::Snapshot const& snp_) const
+ cmState::Snapshot const& snp_) const
{
cmState::Snapshot snp = snp_;
- while (snp.IsValid())
- {
- if(snp == rootSnp)
- {
+ while (snp.IsValid()) {
+ if (snp == rootSnp) {
// No directory excludes itself.
return false;
- }
+ }
- if(snp.GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL"))
- {
+ if (snp.GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
// This directory is excluded from its parent.
return true;
- }
- snp = snp.GetBuildsystemDirectoryParent();
}
+ snp = snp.GetBuildsystemDirectoryParent();
+ }
return false;
}
@@ -2113,19 +1872,18 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
cmGeneratorTarget* target) const
{
- if(target->GetType() == cmState::INTERFACE_LIBRARY
- || target->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
- {
+ if (target->GetType() == cmState::INTERFACE_LIBRARY ||
+ target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
// This target is excluded from its directory.
return true;
- }
+ }
// This target is included in its directory. Check whether the
// directory is excluded.
return this->IsExcluded(root, target->GetLocalGenerator());
}
-void
-cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
+void cmGlobalGenerator::GetEnabledLanguages(
+ std::vector<std::string>& lang) const
{
lang = this->CMakeInstance->GetState()->GetEnabledLanguages();
}
@@ -2133,11 +1891,10 @@ cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
int cmGlobalGenerator::GetLinkerPreference(const std::string& lang) const
{
std::map<std::string, int>::const_iterator it =
- this->LanguageToLinkerPreference.find(lang);
- if (it != this->LanguageToLinkerPreference.end())
- {
+ this->LanguageToLinkerPreference.find(lang);
+ if (it != this->LanguageToLinkerPreference.end()) {
return it->second;
- }
+ }
return 0;
}
@@ -2145,53 +1902,45 @@ void cmGlobalGenerator::FillProjectMap()
{
this->ProjectMap.clear(); // make sure we start with a clean map
unsigned int i;
- for(i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
// for each local generator add all projects
cmState::Snapshot snp = this->LocalGenerators[i]->GetStateSnapshot();
std::string name;
- do
- {
+ do {
std::string snpProjName = snp.GetProjectName();
- if (name != snpProjName)
- {
+ if (name != snpProjName) {
name = snpProjName;
this->ProjectMap[name].push_back(this->LocalGenerators[i]);
- }
- snp = snp.GetBuildsystemDirectoryParent();
}
- while (snp.IsValid());
- }
+ snp = snp.GetBuildsystemDirectoryParent();
+ } while (snp.IsValid());
+ }
}
-cmMakefile*
-cmGlobalGenerator::FindMakefile(const std::string& start_dir) const
+cmMakefile* cmGlobalGenerator::FindMakefile(const std::string& start_dir) const
{
- for(std::vector<cmMakefile*>::const_iterator it =
- this->Makefiles.begin(); it != this->Makefiles.end(); ++it)
- {
+ for (std::vector<cmMakefile*>::const_iterator it = this->Makefiles.begin();
+ it != this->Makefiles.end(); ++it) {
std::string sd = (*it)->GetCurrentSourceDirectory();
- if (sd == start_dir)
- {
+ if (sd == start_dir) {
return *it;
- }
}
+ }
return 0;
}
///! Find a local generator by its startdirectory
-cmLocalGenerator*
-cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const
+cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(
+ const std::string& start_dir) const
{
- for(std::vector<cmLocalGenerator*>::const_iterator it =
- this->LocalGenerators.begin(); it != this->LocalGenerators.end(); ++it)
- {
+ for (std::vector<cmLocalGenerator*>::const_iterator it =
+ this->LocalGenerators.begin();
+ it != this->LocalGenerators.end(); ++it) {
std::string sd = (*it)->GetCurrentSourceDirectory();
- if (sd == start_dir)
- {
+ if (sd == start_dir) {
return *it;
- }
}
+ }
return 0;
}
@@ -2208,95 +1957,83 @@ bool cmGlobalGenerator::IsAlias(const std::string& name) const
void cmGlobalGenerator::IndexTarget(cmTarget* t)
{
- if (!t->IsImported() || t->IsImportedGloballyVisible())
- {
+ if (!t->IsImported() || t->IsImportedGloballyVisible()) {
this->TargetSearchIndex[t->GetName()] = t;
- }
+ }
}
void cmGlobalGenerator::IndexGeneratorTarget(cmGeneratorTarget* gt)
{
- if (!gt->IsImported() || gt->IsImportedGloballyVisible())
- {
+ if (!gt->IsImported() || gt->IsImportedGloballyVisible()) {
this->GeneratorTargetSearchIndex[gt->GetName()] = gt;
- }
+ }
}
cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const
{
TargetMap::const_iterator i = this->TargetSearchIndex.find(name);
- if (i != this->TargetSearchIndex.end())
- {
+ if (i != this->TargetSearchIndex.end()) {
return i->second;
- }
+ }
return 0;
}
-cmGeneratorTarget*
-cmGlobalGenerator::FindGeneratorTargetImpl(std::string const& name) const
+cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTargetImpl(
+ std::string const& name) const
{
GeneratorTargetMap::const_iterator i =
this->GeneratorTargetSearchIndex.find(name);
- if (i != this->GeneratorTargetSearchIndex.end())
- {
+ if (i != this->GeneratorTargetSearchIndex.end()) {
return i->second;
- }
+ }
return 0;
}
-cmTarget*
-cmGlobalGenerator::FindTarget(const std::string& name,
- bool excludeAliases) const
+cmTarget* cmGlobalGenerator::FindTarget(const std::string& name,
+ bool excludeAliases) const
{
- if (!excludeAliases)
- {
+ if (!excludeAliases) {
std::map<std::string, std::string>::const_iterator ai =
- this->AliasTargets.find(name);
- if (ai != this->AliasTargets.end())
- {
+ this->AliasTargets.find(name);
+ if (ai != this->AliasTargets.end()) {
return this->FindTargetImpl(ai->second);
- }
}
+ }
return this->FindTargetImpl(name);
}
-cmGeneratorTarget*
-cmGlobalGenerator::FindGeneratorTarget(const std::string& name) const
+cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTarget(
+ const std::string& name) const
{
std::map<std::string, std::string>::const_iterator ai =
- this->AliasTargets.find(name);
- if (ai != this->AliasTargets.end())
- {
+ this->AliasTargets.find(name);
+ if (ai != this->AliasTargets.end()) {
return this->FindGeneratorTargetImpl(ai->second);
- }
+ }
return this->FindGeneratorTargetImpl(name);
}
-bool
-cmGlobalGenerator::NameResolvesToFramework(const std::string& libname) const
+bool cmGlobalGenerator::NameResolvesToFramework(
+ const std::string& libname) const
{
- if(cmSystemTools::IsPathToFramework(libname.c_str()))
- {
+ if (cmSystemTools::IsPathToFramework(libname.c_str())) {
return true;
- }
+ }
- if(cmTarget* tgt = this->FindTarget(libname))
- {
- if(tgt->IsFrameworkOnApple())
- {
- return true;
- }
+ if (cmTarget* tgt = this->FindTarget(libname)) {
+ if (tgt->IsFrameworkOnApple()) {
+ return true;
}
+ }
return false;
}
inline std::string removeQuotes(const std::string& s)
{
- if(s[0] == '\"' && s[s.size()-1] == '\"')
- {
- return s.substr(1, s.size()-2);
- }
+ if (s[0] == '\"' && s[s.size() - 1] == '\"') {
+ return s.substr(1, s.size() - 2);
+ }
return s;
}
@@ -2306,98 +2043,86 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir();
// CPack
- std::string workingDir = mf->GetCurrentBinaryDirectory();
+ std::string workingDir = mf->GetCurrentBinaryDirectory();
cmCustomCommandLines cpackCommandLines;
std::vector<std::string> depends;
cmCustomCommandLine singleLine;
singleLine.push_back(cmSystemTools::GetCPackCommand());
- if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' )
- {
+ if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
singleLine.push_back("-C");
singleLine.push_back(cmakeCfgIntDir);
- }
+ }
singleLine.push_back("--config");
- std::string configFile = mf->GetCurrentBinaryDirectory();;
+ std::string configFile = mf->GetCurrentBinaryDirectory();
+ ;
configFile += "/CPackConfig.cmake";
std::string relConfigFile = "./CPackConfig.cmake";
singleLine.push_back(relConfigFile);
cpackCommandLines.push_back(singleLine);
- if ( this->GetPreinstallTargetName() )
- {
+ if (this->GetPreinstallTargetName()) {
depends.push_back(this->GetPreinstallTargetName());
- }
- else
- {
+ } else {
const char* noPackageAll =
mf->GetDefinition("CMAKE_SKIP_PACKAGE_ALL_DEPENDENCY");
- if(!noPackageAll || cmSystemTools::IsOff(noPackageAll))
- {
+ if (!noPackageAll || cmSystemTools::IsOff(noPackageAll)) {
depends.push_back(this->GetAllTargetName());
- }
- }
- if(cmSystemTools::FileExists(configFile.c_str()))
- {
- (*targets)[this->GetPackageTargetName()]
- = this->CreateGlobalTarget(this->GetPackageTargetName(),
- "Run CPack packaging tool...",
- &cpackCommandLines, depends,
- workingDir.c_str(), /*uses_terminal*/true);
}
+ }
+ if (cmSystemTools::FileExists(configFile.c_str())) {
+ (*targets)[this->GetPackageTargetName()] = this->CreateGlobalTarget(
+ this->GetPackageTargetName(), "Run CPack packaging tool...",
+ &cpackCommandLines, depends, workingDir.c_str(), /*uses_terminal*/ true);
+ }
// CPack source
const char* packageSourceTargetName = this->GetPackageSourceTargetName();
- if ( packageSourceTargetName )
- {
+ if (packageSourceTargetName) {
cpackCommandLines.erase(cpackCommandLines.begin(),
cpackCommandLines.end());
singleLine.erase(singleLine.begin(), singleLine.end());
depends.erase(depends.begin(), depends.end());
singleLine.push_back(cmSystemTools::GetCPackCommand());
singleLine.push_back("--config");
- configFile = mf->GetCurrentBinaryDirectory();;
+ configFile = mf->GetCurrentBinaryDirectory();
+ ;
configFile += "/CPackSourceConfig.cmake";
relConfigFile = "./CPackSourceConfig.cmake";
singleLine.push_back(relConfigFile);
- if(cmSystemTools::FileExists(configFile.c_str()))
- {
+ if (cmSystemTools::FileExists(configFile.c_str())) {
singleLine.push_back(configFile);
cpackCommandLines.push_back(singleLine);
- (*targets)[packageSourceTargetName]
- = this->CreateGlobalTarget(packageSourceTargetName,
- "Run CPack packaging tool for source...",
- &cpackCommandLines, depends,
- workingDir.c_str(), /*uses_terminal*/true);
- }
+ (*targets)[packageSourceTargetName] = this->CreateGlobalTarget(
+ packageSourceTargetName, "Run CPack packaging tool for source...",
+ &cpackCommandLines, depends, workingDir.c_str(),
+ /*uses_terminal*/ true);
}
+ }
// Test
- if(mf->IsOn("CMAKE_TESTING_ENABLED"))
- {
+ if (mf->IsOn("CMAKE_TESTING_ENABLED")) {
cpackCommandLines.erase(cpackCommandLines.begin(),
cpackCommandLines.end());
singleLine.erase(singleLine.begin(), singleLine.end());
depends.erase(depends.begin(), depends.end());
singleLine.push_back(cmSystemTools::GetCTestCommand());
singleLine.push_back("--force-new-ctest-process");
- if(cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.')
- {
+ if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
singleLine.push_back("-C");
singleLine.push_back(cmakeCfgIntDir);
- }
- else // TODO: This is a hack. Should be something to do with the generator
- {
+ } else // TODO: This is a hack. Should be something to do with the
+ // generator
+ {
singleLine.push_back("$(ARGS)");
- }
- cpackCommandLines.push_back(singleLine);
- (*targets)[this->GetTestTargetName()]
- = this->CreateGlobalTarget(this->GetTestTargetName(),
- "Running tests...", &cpackCommandLines, depends, 0,
- /*uses_terminal*/true);
}
+ cpackCommandLines.push_back(singleLine);
+ (*targets)[this->GetTestTargetName()] =
+ this->CreateGlobalTarget(this->GetTestTargetName(), "Running tests...",
+ &cpackCommandLines, depends, 0,
+ /*uses_terminal*/ true);
+ }
- //Edit Cache
+ // Edit Cache
const char* editCacheTargetName = this->GetEditCacheTargetName();
- if ( editCacheTargetName )
- {
+ if (editCacheTargetName) {
cpackCommandLines.erase(cpackCommandLines.begin(),
cpackCommandLines.end());
singleLine.erase(singleLine.begin(), singleLine.end());
@@ -2405,36 +2130,29 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
// Use generator preference for the edit_cache rule if it is defined.
std::string edit_cmd = this->GetEditCacheCommand();
- if (!edit_cmd.empty())
- {
+ if (!edit_cmd.empty()) {
singleLine.push_back(edit_cmd);
singleLine.push_back("-H$(CMAKE_SOURCE_DIR)");
singleLine.push_back("-B$(CMAKE_BINARY_DIR)");
cpackCommandLines.push_back(singleLine);
- (*targets)[editCacheTargetName] =
- this->CreateGlobalTarget(
- editCacheTargetName, "Running CMake cache editor...",
- &cpackCommandLines, depends, 0, /*uses_terminal*/true);
- }
- else
- {
+ (*targets)[editCacheTargetName] = this->CreateGlobalTarget(
+ editCacheTargetName, "Running CMake cache editor...",
+ &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
+ } else {
singleLine.push_back(cmSystemTools::GetCMakeCommand());
singleLine.push_back("-E");
singleLine.push_back("echo");
singleLine.push_back("No interactive CMake dialog available.");
cpackCommandLines.push_back(singleLine);
- (*targets)[editCacheTargetName] =
- this->CreateGlobalTarget(
- editCacheTargetName,
- "No interactive CMake dialog available...",
- &cpackCommandLines, depends, 0, /*uses_terminal*/false);
- }
+ (*targets)[editCacheTargetName] = this->CreateGlobalTarget(
+ editCacheTargetName, "No interactive CMake dialog available...",
+ &cpackCommandLines, depends, 0, /*uses_terminal*/ false);
}
+ }
- //Rebuild Cache
+ // Rebuild Cache
const char* rebuildCacheTargetName = this->GetRebuildCacheTargetName();
- if ( rebuildCacheTargetName )
- {
+ if (rebuildCacheTargetName) {
cpackCommandLines.erase(cpackCommandLines.begin(),
cpackCommandLines.end());
singleLine.erase(singleLine.begin(), singleLine.end());
@@ -2443,155 +2161,131 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
singleLine.push_back("-H$(CMAKE_SOURCE_DIR)");
singleLine.push_back("-B$(CMAKE_BINARY_DIR)");
cpackCommandLines.push_back(singleLine);
- (*targets)[rebuildCacheTargetName] =
- this->CreateGlobalTarget(
- rebuildCacheTargetName, "Running CMake to regenerate build system...",
- &cpackCommandLines, depends, 0, /*uses_terminal*/true);
- }
+ (*targets)[rebuildCacheTargetName] = this->CreateGlobalTarget(
+ rebuildCacheTargetName, "Running CMake to regenerate build system...",
+ &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
+ }
- //Install
+ // Install
bool skipInstallRules = mf->IsOn("CMAKE_SKIP_INSTALL_RULES");
- if(this->InstallTargetEnabled && skipInstallRules)
- {
+ if (this->InstallTargetEnabled && skipInstallRules) {
mf->IssueMessage(cmake::WARNING,
- "CMAKE_SKIP_INSTALL_RULES was enabled even though "
- "installation rules have been specified");
- }
- else if(this->InstallTargetEnabled && !skipInstallRules)
- {
- if(!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.')
- {
+ "CMAKE_SKIP_INSTALL_RULES was enabled even though "
+ "installation rules have been specified");
+ } else if (this->InstallTargetEnabled && !skipInstallRules) {
+ if (!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.') {
std::set<std::string>* componentsSet = &this->InstallComponents;
cpackCommandLines.erase(cpackCommandLines.begin(),
- cpackCommandLines.end());
+ cpackCommandLines.end());
depends.erase(depends.begin(), depends.end());
std::ostringstream ostr;
- if (!componentsSet->empty())
- {
+ if (!componentsSet->empty()) {
ostr << "Available install components are: ";
ostr << cmWrap('"', *componentsSet, '"', " ");
- }
- else
- {
+ } else {
ostr << "Only default component available";
- }
- singleLine.push_back(ostr.str());
- (*targets)["list_install_components"]
- = this->CreateGlobalTarget("list_install_components",
- ostr.str().c_str(),
- &cpackCommandLines, depends, 0, /*uses_terminal*/false);
}
+ singleLine.push_back(ostr.str());
+ (*targets)["list_install_components"] = this->CreateGlobalTarget(
+ "list_install_components", ostr.str().c_str(), &cpackCommandLines,
+ depends, 0, /*uses_terminal*/ false);
+ }
std::string cmd = cmSystemTools::GetCMakeCommand();
cpackCommandLines.erase(cpackCommandLines.begin(),
- cpackCommandLines.end());
+ cpackCommandLines.end());
singleLine.erase(singleLine.begin(), singleLine.end());
depends.erase(depends.begin(), depends.end());
- if ( this->GetPreinstallTargetName() )
- {
+ if (this->GetPreinstallTargetName()) {
depends.push_back(this->GetPreinstallTargetName());
- }
- else
- {
+ } else {
const char* noall =
mf->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
- if(!noall || cmSystemTools::IsOff(noall))
- {
+ if (!noall || cmSystemTools::IsOff(noall)) {
depends.push_back(this->GetAllTargetName());
- }
}
- if(mf->GetDefinition("CMake_BINARY_DIR") &&
- !mf->IsOn("CMAKE_CROSSCOMPILING"))
- {
+ }
+ if (mf->GetDefinition("CMake_BINARY_DIR") &&
+ !mf->IsOn("CMAKE_CROSSCOMPILING")) {
// We are building CMake itself. We cannot use the original
// executable to install over itself. The generator will
// automatically convert this name to the build-time location.
cmd = "cmake";
- }
+ }
singleLine.push_back(cmd);
- if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' )
- {
+ if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
std::string cfgArg = "-DBUILD_TYPE=";
bool iosPlatform = mf->PlatformIsAppleIos();
- if(iosPlatform)
- {
+ if (iosPlatform) {
cfgArg += "$(CONFIGURATION)";
singleLine.push_back(cfgArg);
cfgArg = "-DEFFECTIVE_PLATFORM_NAME=$(EFFECTIVE_PLATFORM_NAME)";
- }
- else
- {
+ } else {
cfgArg += mf->GetDefinition("CMAKE_CFG_INTDIR");
- }
- singleLine.push_back(cfgArg);
}
+ singleLine.push_back(cfgArg);
+ }
singleLine.push_back("-P");
singleLine.push_back("cmake_install.cmake");
cpackCommandLines.push_back(singleLine);
- (*targets)[this->GetInstallTargetName()] =
- this->CreateGlobalTarget(
- this->GetInstallTargetName(), "Install the project...",
- &cpackCommandLines, depends, 0, /*uses_terminal*/true);
+ (*targets)[this->GetInstallTargetName()] = this->CreateGlobalTarget(
+ this->GetInstallTargetName(), "Install the project...",
+ &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
// install_local
- if(const char* install_local = this->GetInstallLocalTargetName())
- {
+ if (const char* install_local = this->GetInstallLocalTargetName()) {
cmCustomCommandLine localCmdLine = singleLine;
- localCmdLine.insert(localCmdLine.begin()+1,
- "-DCMAKE_INSTALL_LOCAL_ONLY=1");
+ localCmdLine.insert(localCmdLine.begin() + 1,
+ "-DCMAKE_INSTALL_LOCAL_ONLY=1");
cpackCommandLines.erase(cpackCommandLines.begin(),
- cpackCommandLines.end());
+ cpackCommandLines.end());
cpackCommandLines.push_back(localCmdLine);
- (*targets)[install_local] =
- this->CreateGlobalTarget(
- install_local, "Installing only the local directory...",
- &cpackCommandLines, depends, 0, /*uses_terminal*/true);
- }
+ (*targets)[install_local] = this->CreateGlobalTarget(
+ install_local, "Installing only the local directory...",
+ &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
+ }
// install_strip
const char* install_strip = this->GetInstallStripTargetName();
- if((install_strip !=0) && (mf->IsSet("CMAKE_STRIP")))
- {
+ if ((install_strip != 0) && (mf->IsSet("CMAKE_STRIP"))) {
cmCustomCommandLine stripCmdLine = singleLine;
- stripCmdLine.insert(stripCmdLine.begin()+1,"-DCMAKE_INSTALL_DO_STRIP=1");
+ stripCmdLine.insert(stripCmdLine.begin() + 1,
+ "-DCMAKE_INSTALL_DO_STRIP=1");
cpackCommandLines.erase(cpackCommandLines.begin(),
- cpackCommandLines.end());
+ cpackCommandLines.end());
cpackCommandLines.push_back(stripCmdLine);
- (*targets)[install_strip] =
- this->CreateGlobalTarget(
- install_strip, "Installing the project stripped...",
- &cpackCommandLines, depends, 0, /*uses_terminal*/true);
- }
+ (*targets)[install_strip] = this->CreateGlobalTarget(
+ install_strip, "Installing the project stripped...",
+ &cpackCommandLines, depends, 0, /*uses_terminal*/ true);
}
+ }
}
const char* cmGlobalGenerator::GetPredefinedTargetsFolder()
{
- const char* prop = this->GetCMakeInstance()->GetState()
- ->GetGlobalProperty("PREDEFINED_TARGETS_FOLDER");
+ const char* prop = this->GetCMakeInstance()->GetState()->GetGlobalProperty(
+ "PREDEFINED_TARGETS_FOLDER");
- if (prop)
- {
+ if (prop) {
return prop;
- }
+ }
return "CMakePredefinedTargets";
}
bool cmGlobalGenerator::UseFolderProperty()
{
- const char* prop = this->GetCMakeInstance()->GetState()
- ->GetGlobalProperty("USE_FOLDERS");
+ const char* prop =
+ this->GetCMakeInstance()->GetState()->GetGlobalProperty("USE_FOLDERS");
// If this property is defined, let the setter turn this on or off...
//
- if (prop)
- {
+ if (prop) {
return cmSystemTools::IsOn(prop);
- }
+ }
// By default, this feature is OFF, since it is not supported in the
// Visual Studio Express editions until VS11:
@@ -2601,64 +2295,58 @@ bool cmGlobalGenerator::UseFolderProperty()
cmTarget cmGlobalGenerator::CreateGlobalTarget(
const std::string& name, const char* message,
- const cmCustomCommandLines* commandLines,
- std::vector<std::string> depends,
- const char* workingDirectory,
- bool uses_terminal)
+ const cmCustomCommandLines* commandLines, std::vector<std::string> depends,
+ const char* workingDirectory, bool uses_terminal)
{
// Package
cmTarget target;
target.SetType(cmState::GLOBAL_TARGET, name);
- target.SetProperty("EXCLUDE_FROM_ALL","TRUE");
+ target.SetProperty("EXCLUDE_FROM_ALL", "TRUE");
std::vector<std::string> no_outputs;
std::vector<std::string> no_byproducts;
std::vector<std::string> no_depends;
// Store the custom command in the target.
- cmCustomCommand cc(0, no_outputs, no_byproducts, no_depends,
- *commandLines, 0, workingDirectory);
+ cmCustomCommand cc(0, no_outputs, no_byproducts, no_depends, *commandLines,
+ 0, workingDirectory);
cc.SetUsesTerminal(uses_terminal);
target.AddPostBuildCommand(cc);
target.SetProperty("EchoString", message);
std::vector<std::string>::iterator dit;
- for ( dit = depends.begin(); dit != depends.end(); ++ dit )
- {
+ for (dit = depends.begin(); dit != depends.end(); ++dit) {
target.AddUtility(*dit);
- }
+ }
// Organize in the "predefined targets" folder:
//
- if (this->UseFolderProperty())
- {
+ if (this->UseFolderProperty()) {
target.SetProperty("FOLDER", this->GetPredefinedTargetsFolder());
- }
+ }
return target;
}
-std::string
-cmGlobalGenerator::GenerateRuleFile(std::string const& output) const
+std::string cmGlobalGenerator::GenerateRuleFile(
+ std::string const& output) const
{
std::string ruleFile = output;
ruleFile += ".rule";
const char* dir = this->GetCMakeCFGIntDir();
- if(dir && dir[0] == '$')
- {
+ if (dir && dir[0] == '$') {
cmSystemTools::ReplaceString(ruleFile, dir,
cmake::GetCMakeFilesDirectory());
- }
+ }
return ruleFile;
}
std::string cmGlobalGenerator::GetSharedLibFlagsForLanguage(
- std::string const& l) const
+ std::string const& l) const
{
std::map<std::string, std::string>::const_iterator it =
- this->LanguageToOriginalSharedLibFlags.find(l);
- if(it != this->LanguageToOriginalSharedLibFlags.end())
- {
+ this->LanguageToOriginalSharedLibFlags.find(l);
+ if (it != this->LanguageToOriginalSharedLibFlags.end()) {
return it->second;
- }
+ }
return "";
}
@@ -2684,39 +2372,29 @@ bool cmGlobalGenerator::IsReservedTarget(std::string const& name)
// by one or more of the cmake generators.
// Adding additional targets to this list will require a policy!
- const char* reservedTargets[] =
- {
- "all", "ALL_BUILD",
- "help",
- "install", "INSTALL",
- "preinstall",
- "clean",
- "edit_cache",
- "rebuild_cache",
- "test", "RUN_TESTS",
- "package", "PACKAGE",
- "package_source",
- "ZERO_CHECK"
+ const char* reservedTargets[] = {
+ "all", "ALL_BUILD", "help", "install", "INSTALL",
+ "preinstall", "clean", "edit_cache", "rebuild_cache", "test",
+ "RUN_TESTS", "package", "PACKAGE", "package_source", "ZERO_CHECK"
};
- return std::find(cmArrayBegin(reservedTargets),
- cmArrayEnd(reservedTargets), name)
- != cmArrayEnd(reservedTargets);
+ return std::find(cmArrayBegin(reservedTargets), cmArrayEnd(reservedTargets),
+ name) != cmArrayEnd(reservedTargets);
}
void cmGlobalGenerator::SetExternalMakefileProjectGenerator(
- cmExternalMakefileProjectGenerator *extraGenerator)
+ cmExternalMakefileProjectGenerator* extraGenerator)
{
this->ExtraGenerator = extraGenerator;
- if (this->ExtraGenerator!=0)
- {
+ if (this->ExtraGenerator != 0) {
this->ExtraGenerator->SetGlobalGenerator(this);
- }
+ }
}
std::string cmGlobalGenerator::GetExtraGeneratorName() const
{
- return this->ExtraGenerator? this->ExtraGenerator->GetName() : std::string();
+ return this->ExtraGenerator ? this->ExtraGenerator->GetName()
+ : std::string();
}
void cmGlobalGenerator::FileReplacedDuringGenerate(const std::string& filename)
@@ -2724,15 +2402,13 @@ void cmGlobalGenerator::FileReplacedDuringGenerate(const std::string& filename)
this->FilesReplacedDuringGenerate.push_back(filename);
}
-void
-cmGlobalGenerator
-::GetFilesReplacedDuringGenerate(std::vector<std::string>& filenames)
+void cmGlobalGenerator::GetFilesReplacedDuringGenerate(
+ std::vector<std::string>& filenames)
{
filenames.clear();
- std::copy(
- this->FilesReplacedDuringGenerate.begin(),
- this->FilesReplacedDuringGenerate.end(),
- std::back_inserter(filenames));
+ std::copy(this->FilesReplacedDuringGenerate.begin(),
+ this->FilesReplacedDuringGenerate.end(),
+ std::back_inserter(filenames));
}
void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
@@ -2741,32 +2417,28 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
GeneratorVector const& generators)
{
// loop over all local generators
- for(std::vector<cmLocalGenerator*>::const_iterator i = generators.begin();
- i != generators.end(); ++i)
- {
+ for (std::vector<cmLocalGenerator*>::const_iterator i = generators.begin();
+ i != generators.end(); ++i) {
// check to make sure generator is not excluded
- if(this->IsExcluded(root, *i))
- {
+ if (this->IsExcluded(root, *i)) {
continue;
- }
+ }
// Get the targets in the makefile
std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets();
// loop over all the targets
for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
- l != tgts.end(); ++l)
- {
+ l != tgts.end(); ++l) {
cmGeneratorTarget* target = *l;
- if(this->IsRootOnlyTarget(target) &&
- target->GetLocalGenerator() != root)
- {
+ if (this->IsRootOnlyTarget(target) &&
+ target->GetLocalGenerator() != root) {
continue;
- }
+ }
// put the target in the set of original targets
originalTargets.insert(target);
// Get the set of targets that depend on target
this->AddTargetDepends(target, projectTargets);
- }
}
+ }
}
bool cmGlobalGenerator::IsRootOnlyTarget(cmGeneratorTarget* target) const
@@ -2779,19 +2451,16 @@ void cmGlobalGenerator::AddTargetDepends(cmGeneratorTarget const* target,
TargetDependSet& projectTargets)
{
// add the target itself
- if(projectTargets.insert(target).second)
- {
+ if (projectTargets.insert(target).second) {
// This is the first time we have encountered the target.
// Recursively follow its dependencies.
TargetDependSet const& ts = this->GetTargetDirectDepends(target);
- for(TargetDependSet::const_iterator i = ts.begin(); i != ts.end(); ++i)
- {
+ for (TargetDependSet::const_iterator i = ts.begin(); i != ts.end(); ++i) {
this->AddTargetDepends(*i, projectTargets);
- }
}
+ }
}
-
void cmGlobalGenerator::AddToManifest(std::string const& f)
{
// Add to the content listing for the file's directory.
@@ -2802,66 +2471,59 @@ void cmGlobalGenerator::AddToManifest(std::string const& f)
dc.All.insert(file);
}
-std::set<std::string> const&
-cmGlobalGenerator::GetDirectoryContent(std::string const& dir, bool needDisk)
+std::set<std::string> const& cmGlobalGenerator::GetDirectoryContent(
+ std::string const& dir, bool needDisk)
{
DirectoryContent& dc = this->DirectoryContentMap[dir];
- if(needDisk)
- {
+ if (needDisk) {
long mt = cmSystemTools::ModifiedTime(dir);
- if (mt != dc.LastDiskTime)
- {
+ if (mt != dc.LastDiskTime) {
// Reset to non-loaded directory content.
dc.All = dc.Generated;
// Load the directory content from disk.
cmsys::Directory d;
- if(d.Load(dir))
- {
+ if (d.Load(dir)) {
unsigned long n = d.GetNumberOfFiles();
- for(unsigned long i = 0; i < n; ++i)
- {
+ for (unsigned long i = 0; i < n; ++i) {
const char* f = d.GetFile(i);
- if(strcmp(f, ".") != 0 && strcmp(f, "..") != 0)
- {
+ if (strcmp(f, ".") != 0 && strcmp(f, "..") != 0) {
dc.All.insert(f);
- }
}
}
- dc.LastDiskTime = mt;
}
+ dc.LastDiskTime = mt;
}
+ }
return dc.All;
}
-void
-cmGlobalGenerator::AddRuleHash(const std::vector<std::string>& outputs,
- std::string const& content)
+void cmGlobalGenerator::AddRuleHash(const std::vector<std::string>& outputs,
+ std::string const& content)
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
// Ignore if there are no outputs.
- if(outputs.empty())
- {
+ if (outputs.empty()) {
return;
- }
+ }
// Compute a hash of the rule.
RuleHash hash;
{
- unsigned char const* data =
- reinterpret_cast<unsigned char const*>(content.c_str());
- int length = static_cast<int>(content.length());
- cmsysMD5* sum = cmsysMD5_New();
- cmsysMD5_Initialize(sum);
- cmsysMD5_Append(sum, data, length);
- cmsysMD5_FinalizeHex(sum, hash.Data);
- cmsysMD5_Delete(sum);
+ unsigned char const* data =
+ reinterpret_cast<unsigned char const*>(content.c_str());
+ int length = static_cast<int>(content.length());
+ cmsysMD5* sum = cmsysMD5_New();
+ cmsysMD5_Initialize(sum);
+ cmsysMD5_Append(sum, data, length);
+ cmsysMD5_FinalizeHex(sum, hash.Data);
+ cmsysMD5_Delete(sum);
}
// Shorten the output name (in expected use case).
cmOutputConverter converter(this->GetMakefiles()[0]->GetStateSnapshot());
- std::string fname = converter.Convert(
- outputs[0], cmLocalGenerator::HOME_OUTPUT);
+ std::string fname =
+ converter.Convert(outputs[0], cmLocalGenerator::HOME_OUTPUT);
// Associate the hash with this output.
this->RuleHashes[fname] = hash;
@@ -2891,22 +2553,19 @@ void cmGlobalGenerator::CheckRuleHashes(std::string const& pfile,
#else
cmsys::ifstream fin(pfile.c_str(), std::ios::in);
#endif
- if(!fin)
- {
+ if (!fin) {
return;
- }
+ }
std::string line;
std::string fname;
- while(cmSystemTools::GetLineFromStream(fin, line))
- {
+ while (cmSystemTools::GetLineFromStream(fin, line)) {
// Line format is a 32-byte hex string followed by a space
// followed by a file name (with no escaping).
// Skip blank and comment lines.
- if(line.size() < 34 || line[0] == '#')
- {
+ if (line.size() < 34 || line[0] == '#') {
continue;
- }
+ }
// Get the filename.
fname = line.substr(33, line.npos);
@@ -2914,55 +2573,46 @@ void cmGlobalGenerator::CheckRuleHashes(std::string const& pfile,
// Look for a hash for this file's rule.
std::map<std::string, RuleHash>::const_iterator rhi =
this->RuleHashes.find(fname);
- if(rhi != this->RuleHashes.end())
- {
+ if (rhi != this->RuleHashes.end()) {
// Compare the rule hash in the file to that we were given.
- if(strncmp(line.c_str(), rhi->second.Data, 32) != 0)
- {
+ if (strncmp(line.c_str(), rhi->second.Data, 32) != 0) {
// The rule has changed. Delete the output so it will be
// built again.
fname = cmSystemTools::CollapseFullPath(fname, home.c_str());
cmSystemTools::RemoveFile(fname);
- }
}
- else
- {
+ } else {
// We have no hash for a rule previously listed. This may be a
// case where a user has turned off a build option and might
// want to turn it back on later, so do not delete the file.
// Instead, we keep the rule hash as long as the file exists so
// that if the feature is turned back on and the rule has
// changed the file is still rebuilt.
- std::string fpath =
- cmSystemTools::CollapseFullPath(fname, home.c_str());
- if(cmSystemTools::FileExists(fpath.c_str()))
- {
+ std::string fpath = cmSystemTools::CollapseFullPath(fname, home.c_str());
+ if (cmSystemTools::FileExists(fpath.c_str())) {
RuleHash hash;
strncpy(hash.Data, line.c_str(), 32);
this->RuleHashes[fname] = hash;
- }
}
}
+ }
}
void cmGlobalGenerator::WriteRuleHashes(std::string const& pfile)
{
// Now generate a new persistence file with the current hashes.
- if(this->RuleHashes.empty())
- {
+ if (this->RuleHashes.empty()) {
cmSystemTools::RemoveFile(pfile);
- }
- else
- {
+ } else {
cmGeneratedFileStream fout(pfile.c_str());
fout << "# Hashes of file build rules.\n";
- for(std::map<std::string, RuleHash>::const_iterator
- rhi = this->RuleHashes.begin(); rhi != this->RuleHashes.end(); ++rhi)
- {
+ for (std::map<std::string, RuleHash>::const_iterator rhi =
+ this->RuleHashes.begin();
+ rhi != this->RuleHashes.end(); ++rhi) {
fout.write(rhi->second.Data, 32);
fout << " " << rhi->first << "\n";
- }
}
+ }
}
void cmGlobalGenerator::WriteSummary()
@@ -2973,21 +2623,18 @@ void cmGlobalGenerator::WriteSummary()
fname += "/TargetDirectories.txt";
cmGeneratedFileStream fout(fname.c_str());
- for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
std::vector<cmGeneratorTarget*> tgts =
- this->LocalGenerators[i]->GetGeneratorTargets();
+ this->LocalGenerators[i]->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin();
- it != tgts.end(); ++it)
- {
- if ((*it)->GetType() == cmState::INTERFACE_LIBRARY)
- {
+ it != tgts.end(); ++it) {
+ if ((*it)->GetType() == cmState::INTERFACE_LIBRARY) {
continue;
- }
+ }
this->WriteSummary(*it);
fout << (*it)->GetSupportDirectory() << "\n";
- }
}
+ }
}
void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
@@ -3000,16 +2647,12 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
#ifdef CMAKE_BUILD_WITH_CMAKE
// Check whether labels are enabled for this target.
- if(const char* value = target->GetProperty("LABELS"))
- {
+ if (const char* value = target->GetProperty("LABELS")) {
Json::Value lj_root(Json::objectValue);
- Json::Value& lj_target =
- lj_root["target"] = Json::objectValue;
+ Json::Value& lj_target = lj_root["target"] = Json::objectValue;
lj_target["name"] = target->GetName();
- Json::Value& lj_target_labels =
- lj_target["labels"] = Json::arrayValue;
- Json::Value& lj_sources =
- lj_root["sources"] = Json::arrayValue;
+ Json::Value& lj_target_labels = lj_target["labels"] = Json::arrayValue;
+ Json::Value& lj_sources = lj_root["sources"] = Json::arrayValue;
cmSystemTools::MakeDirectory(dir.c_str());
cmGeneratedFileStream fout(file.c_str());
@@ -3018,68 +2661,60 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
// these labels.
std::vector<std::string> labels;
cmSystemTools::ExpandListArgument(value, labels);
- if(!labels.empty())
- {
+ if (!labels.empty()) {
fout << "# Target labels\n";
- for(std::vector<std::string>::const_iterator li = labels.begin();
- li != labels.end(); ++li)
- {
+ for (std::vector<std::string>::const_iterator li = labels.begin();
+ li != labels.end(); ++li) {
fout << " " << *li << "\n";
lj_target_labels.append(*li);
- }
}
+ }
// List the source files with any per-source labels.
fout << "# Source files and their labels\n";
std::vector<cmSourceFile*> sources;
std::vector<std::string> configs;
target->Target->GetMakefile()->GetConfigurations(configs);
- if (configs.empty())
- {
+ if (configs.empty()) {
configs.push_back("");
- }
- for(std::vector<std::string>::const_iterator ci = configs.begin();
- ci != configs.end(); ++ci)
- {
+ }
+ for (std::vector<std::string>::const_iterator ci = configs.begin();
+ ci != configs.end(); ++ci) {
target->GetSourceFiles(sources, *ci);
- }
- std::vector<cmSourceFile*>::const_iterator sourcesEnd
- = cmRemoveDuplicates(sources);
- for(std::vector<cmSourceFile*>::const_iterator si = sources.begin();
- si != sourcesEnd; ++si)
- {
+ }
+ std::vector<cmSourceFile*>::const_iterator sourcesEnd =
+ cmRemoveDuplicates(sources);
+ for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
+ si != sourcesEnd; ++si) {
Json::Value& lj_source = lj_sources.append(Json::objectValue);
cmSourceFile* sf = *si;
std::string const& sfp = sf->GetFullPath();
fout << sfp << "\n";
lj_source["file"] = sfp;
- if(const char* svalue = sf->GetProperty("LABELS"))
- {
+ if (const char* svalue = sf->GetProperty("LABELS")) {
labels.clear();
- Json::Value& lj_source_labels =
- lj_source["labels"] = Json::arrayValue;
+ Json::Value& lj_source_labels = lj_source["labels"] = Json::arrayValue;
cmSystemTools::ExpandListArgument(svalue, labels);
- for(std::vector<std::string>::const_iterator li = labels.begin();
- li != labels.end(); ++li)
- {
+ for (std::vector<std::string>::const_iterator li = labels.begin();
+ li != labels.end(); ++li) {
fout << " " << *li << "\n";
lj_source_labels.append(*li);
- }
}
}
+ }
cmGeneratedFileStream json_fout(json_file.c_str());
json_fout << lj_root;
- }
- else
+ } else
#endif
- {
+ {
cmSystemTools::RemoveFile(file);
cmSystemTools::RemoveFile(json_file);
- }
+ }
}
// static
-std::string cmGlobalGenerator::EscapeJSON(const std::string& s) {
+std::string cmGlobalGenerator::EscapeJSON(const std::string& s)
+{
std::string result;
for (std::string::size_type i = 0; i < s.size(); ++i) {
if (s[i] == '"' || s[i] == '\\') {
@@ -3090,39 +2725,38 @@ std::string cmGlobalGenerator::EscapeJSON(const std::string& s) {
return result;
}
-void cmGlobalGenerator::SetFilenameTargetDepends(cmSourceFile* sf,
- std::set<cmGeneratorTarget const*> tgts)
+void cmGlobalGenerator::SetFilenameTargetDepends(
+ cmSourceFile* sf, std::set<cmGeneratorTarget const*> tgts)
{
this->FilenameTargetDepends[sf] = tgts;
}
std::set<cmGeneratorTarget const*> const&
-cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const {
+cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const
+{
return this->FilenameTargetDepends[sf];
}
void cmGlobalGenerator::CreateEvaluationSourceFiles(
- std::string const& config) const
+ std::string const& config) const
{
unsigned int i;
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
this->LocalGenerators[i]->CreateEvaluationFileOutputs(config);
- }
+ }
}
void cmGlobalGenerator::ProcessEvaluationFiles()
{
std::vector<std::string> generatedFiles;
unsigned int i;
- for (i = 0; i < this->LocalGenerators.size(); ++i)
- {
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
this->LocalGenerators[i]->ProcessEvaluationFiles(generatedFiles);
- }
+ }
}
-std::string cmGlobalGenerator::ExpandCFGIntDir(const std::string& str,
- const std::string& /*config*/) const
+std::string cmGlobalGenerator::ExpandCFGIntDir(
+ const std::string& str, const std::string& /*config*/) const
{
return str;
}
@@ -3141,24 +2775,22 @@ bool cmGlobalGenerator::GenerateCPackPropertiesFile()
std::string path = this->CMakeInstance->GetHomeOutputDirectory();
path += "/CPackProperties.cmake";
- if(!cmSystemTools::FileExists(path.c_str()) && installedFiles.empty())
- {
- return true;
- }
+ if (!cmSystemTools::FileExists(path.c_str()) && installedFiles.empty()) {
+ return true;
+ }
cmGeneratedFileStream file(path.c_str());
file << "# CPack properties\n";
- for(cmake::InstalledFilesMap::const_iterator i = installedFiles.begin();
- i != installedFiles.end(); ++i)
- {
+ for (cmake::InstalledFilesMap::const_iterator i = installedFiles.begin();
+ i != installedFiles.end(); ++i) {
cmInstalledFile const& installedFile = i->second;
- cmCPackPropertiesGenerator cpackPropertiesGenerator(
- lg, installedFile, configs);
+ cmCPackPropertiesGenerator cpackPropertiesGenerator(lg, installedFile,
+ configs);
cpackPropertiesGenerator.Generate(file, config, configs);
- }
+ }
return true;
}