diff options
Diffstat (limited to 'Source/cmGlobalGenerator.cxx')
| -rw-r--r-- | Source/cmGlobalGenerator.cxx | 2018 |
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; } |