diff options
Diffstat (limited to 'Source/cmGlobalGenerator.cxx')
| -rw-r--r-- | Source/cmGlobalGenerator.cxx | 733 |
1 files changed, 429 insertions, 304 deletions
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 099f705..6e903fb 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -89,9 +89,9 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm) // how long to let try compiles run this->TryCompileTimeout = 0; - this->ExtraGenerator = CM_NULLPTR; - this->CurrentMakefile = CM_NULLPTR; - this->TryCompileOuterMakefile = CM_NULLPTR; + this->ExtraGenerator = nullptr; + this->CurrentConfigureMakefile = nullptr; + this->TryCompileOuterMakefile = nullptr; this->ConfigureDoneCMP0026AndCMP0024 = false; this->FirstTimeProgress = 0.0f; @@ -111,6 +111,26 @@ cmGlobalGenerator::~cmGlobalGenerator() delete this->ExtraGenerator; } +bool cmGlobalGenerator::SetGeneratorInstance(std::string const& i, + cmMakefile* mf) +{ + if (i.empty()) { + return true; + } + + std::ostringstream e; + /* clang-format off */ + e << + "Generator\n" + " " << this->GetName() << "\n" + "does not support instance specification, but instance\n" + " " << i << "\n" + "was specified."; + /* clang-format on */ + mf->IssueMessage(cmake::FATAL_ERROR, e.str()); + return false; +} + bool cmGlobalGenerator::SetGeneratorPlatform(std::string const& p, cmMakefile* mf) { @@ -244,15 +264,13 @@ bool cmGlobalGenerator::GenerateImportFile(const std::string& file) bool result = it->second->GenerateImportFile(); if (!this->ConfigureDoneCMP0026AndCMP0024) { - for (std::vector<cmMakefile*>::const_iterator mit = - this->Makefiles.begin(); - mit != this->Makefiles.end(); ++mit) { - (*mit)->RemoveExportBuildFileGeneratorCMP0024(it->second); + for (cmMakefile* m : this->Makefiles) { + m->RemoveExportBuildFileGeneratorCMP0024(it->second); } } delete it->second; - it->second = CM_NULLPTR; + it->second = nullptr; this->BuildExportSets.erase(it); return result; } @@ -263,6 +281,43 @@ void cmGlobalGenerator::ForceLinkerLanguages() { } +bool cmGlobalGenerator::CheckTargetsForMissingSources() const +{ + bool failed = false; + for (cmLocalGenerator* localGen : this->LocalGenerators) { + const std::vector<cmGeneratorTarget*>& targets = + localGen->GetGeneratorTargets(); + + for (cmGeneratorTarget* target : targets) { + if (target->GetType() == cmStateEnums::TargetType::GLOBAL_TARGET || + target->GetType() == cmStateEnums::TargetType::INTERFACE_LIBRARY || + target->GetType() == cmStateEnums::TargetType::UTILITY) { + continue; + } + + std::vector<std::string> configs; + target->Makefile->GetConfigurations(configs); + std::vector<cmSourceFile*> srcs; + if (configs.empty()) { + target->GetSourceFiles(srcs, ""); + } else { + for (std::vector<std::string>::const_iterator ci = configs.begin(); + ci != configs.end() && srcs.empty(); ++ci) { + target->GetSourceFiles(srcs, *ci); + } + } + if (srcs.empty()) { + std::ostringstream e; + e << "No SOURCES given to target: " << target->GetName(); + this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, e.str(), + target->GetBacktrace()); + failed = true; + } + } + } + return failed; +} + bool cmGlobalGenerator::IsExportedTargetsFile( const std::string& filename) const { @@ -383,12 +438,11 @@ void cmGlobalGenerator::EnableLanguage( } 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) { + for (std::string const& li : cur_languages) { + if (!this->LanguagesInProgress.insert(li).second) { std::ostringstream e; - e << "Language '" << *li << "' is currently being enabled. " - "Recursive call not allowed."; + e << "Language '" << li << "' is currently being enabled. " + "Recursive call not allowed."; mf->IssueMessage(cmake::FATAL_ERROR, e.str()); cmSystemTools::SetFatalErrorOccured(); return; @@ -397,12 +451,11 @@ void cmGlobalGenerator::EnableLanguage( 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::string const& li : languages) { + if (li == "NONE") { this->SetLanguageEnabled("NONE", mf); } else { - const char* lang = li->c_str(); + const char* lang = li.c_str(); if (this->LanguagesReady.find(lang) == this->LanguagesReady.end()) { std::ostringstream e; e << "The test project needs language " << lang @@ -451,15 +504,6 @@ void cmGlobalGenerator::EnableLanguage( "Platform information initialized", cmStateEnums::INTERNAL); } - // find and make sure CMAKE_MAKE_PROGRAM is defined - if (!this->FindMakeProgram(mf)) { - return; - } - - if (!this->CheckLanguages(languages, mf)) { - return; - } - // try and load the CMakeSystem.cmake if it is there std::string fpath = rootBin; bool const readCMakeSystem = !mf->GetDefinition("CMAKE_SYSTEM_LOADED"); @@ -490,7 +534,6 @@ void cmGlobalGenerator::EnableLanguage( windowsVersionString << osviex.dwMajorVersion << "." << osviex.dwMinorVersion << "." << osviex.dwBuildNumber; - windowsVersionString.str(); mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", windowsVersionString.str().c_str()); #endif @@ -505,6 +548,18 @@ void cmGlobalGenerator::EnableLanguage( } if (readCMakeSystem) { + // Tell the generator about the instance, if any. + std::string instance = mf->GetSafeDefinition("CMAKE_GENERATOR_INSTANCE"); + if (!this->SetGeneratorInstance(instance, mf)) { + cmSystemTools::SetFatalErrorOccured(); + return; + } + + // Find the native build tool for this generator. + if (!this->FindMakeProgram(mf)) { + return; + } + // Tell the generator about the target system. std::string system = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME"); if (!this->SetSystemName(system, mf)) { @@ -527,6 +582,12 @@ void cmGlobalGenerator::EnableLanguage( } } + // Check that the languages are supported by the generator and its + // native build tool found above. + if (!this->CheckLanguages(languages, mf)) { + return; + } + // **** Load the system specific initialization if not yet loaded if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INITIALIZE_LOADED")) { fpath = mf->GetModulesFile("CMakeSystemSpecificInitialize.cmake"); @@ -542,11 +603,10 @@ void cmGlobalGenerator::EnableLanguage( // 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) { - const char* lang = l->c_str(); + for (std::string const& l : languages) { + const char* lang = l.c_str(); needSetLanguageEnabledMaps[lang] = false; - if (*l == "NONE") { + if (l == "NONE") { this->SetLanguageEnabled("NONE", mf); continue; } @@ -648,10 +708,9 @@ void cmGlobalGenerator::EnableLanguage( } // loop over languages again loading CMake(LANG)Information.cmake // - for (std::vector<std::string>::const_iterator l = languages.begin(); - l != languages.end(); ++l) { - const char* lang = l->c_str(); - if (*l == "NONE") { + for (std::string const& l : languages) { + const char* lang = l.c_str(); + if (l == "NONE") { this->SetLanguageEnabled("NONE", mf); continue; } @@ -794,9 +853,8 @@ void cmGlobalGenerator::EnableLanguage( cmSystemTools::SetFatalErrorOccured(); } - for (std::set<std::string>::iterator li = cur_languages.begin(); - li != cur_languages.end(); ++li) { - this->LanguagesInProgress.erase(*li); + for (std::string const& lang : cur_languages) { + this->LanguagesInProgress.erase(lang); } } @@ -904,7 +962,7 @@ std::string cmGlobalGenerator::GetLanguageOutputExtension( } } 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 + // output 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()) { @@ -1021,9 +1079,8 @@ void cmGlobalGenerator::SetLanguageEnabledMaps(const std::string& l, 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) { - this->IgnoreExtensions[*i] = true; + for (std::string const& i : extensionList) { + this->IgnoreExtensions[i] = true; } } @@ -1035,9 +1092,8 @@ void cmGlobalGenerator::FillExtensionToLanguageMap(const std::string& l, 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) { - this->ExtensionToLanguage[*i] = l; + for (std::string const& i : extensionList) { + this->ExtensionToLanguage[i] = l; } } @@ -1075,7 +1131,7 @@ bool cmGlobalGenerator::GetLanguageEnabled(const std::string& l) const void cmGlobalGenerator::ClearEnabledLanguages() { - return this->CMakeInstance->GetState()->ClearEnabledLanguages(); + this->CMakeInstance->GetState()->ClearEnabledLanguages(); } void cmGlobalGenerator::CreateLocalGenerators() @@ -1083,9 +1139,8 @@ void cmGlobalGenerator::CreateLocalGenerators() cmDeleteAll(this->LocalGenerators); this->LocalGenerators.clear(); this->LocalGenerators.reserve(this->Makefiles.size()); - for (std::vector<cmMakefile*>::const_iterator it = this->Makefiles.begin(); - it != this->Makefiles.end(); ++it) { - this->LocalGenerators.push_back(this->CreateLocalGenerator(*it)); + for (cmMakefile* m : this->Makefiles) { + this->LocalGenerators.push_back(this->CreateLocalGenerator(m)); } } @@ -1119,13 +1174,11 @@ void cmGlobalGenerator::Configure() std::vector<GlobalTargetInfo> globalTargets; this->CreateDefaultGlobalTargets(globalTargets); - for (unsigned int i = 0; i < this->Makefiles.size(); ++i) { - cmMakefile* mf = this->Makefiles[i]; + for (cmMakefile* mf : this->Makefiles) { cmTargets* targets = &(mf->GetTargets()); - for (std::vector<GlobalTargetInfo>::iterator gti = globalTargets.begin(); - gti != globalTargets.end(); ++gti) { - targets->insert( - cmTargets::value_type(gti->Name, this->CreateGlobalTarget(*gti, mf))); + for (GlobalTargetInfo const& globalTarget : globalTargets) { + targets->insert(cmTargets::value_type( + globalTarget.Name, this->CreateGlobalTarget(globalTarget, mf))); } } @@ -1145,7 +1198,7 @@ void cmGlobalGenerator::Configure() std::ostringstream msg; if (cmSystemTools::GetErrorOccuredFlag()) { msg << "Configuring incomplete, errors occurred!"; - const char* logs[] = { "CMakeOutput.log", "CMakeError.log", CM_NULLPTR }; + const char* logs[] = { "CMakeOutput.log", "CMakeError.log", nullptr }; for (const char** log = logs; *log; ++log) { std::string f = this->CMakeInstance->GetHomeOutputDirectory(); f += this->CMakeInstance->GetCMakeFilesDirectory(); @@ -1178,9 +1231,8 @@ void cmGlobalGenerator::CreateImportedGenerationObjects( std::find(this->Makefiles.begin(), this->Makefiles.end(), mf); cmLocalGenerator* lg = this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)]; - for (std::vector<std::string>::const_iterator it = targets.begin(); - it != targets.end(); ++it) { - cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(*it); + for (std::string const& t : targets) { + cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(t); if (gt) { exports.push_back(gt); } @@ -1192,7 +1244,7 @@ cmExportBuildFileGenerator* cmGlobalGenerator::GetExportedTargetsFile( { std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it = this->BuildExportSets.find(filename); - return it == this->BuildExportSets.end() ? CM_NULLPTR : it->second; + return it == this->BuildExportSets.end() ? nullptr : it->second; } void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target) @@ -1230,10 +1282,8 @@ void cmGlobalGenerator::ComputeBuildFileGenerators() for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { std::vector<cmExportBuildFileGenerator*> gens = this->Makefiles[i]->GetExportBuildFileGenerators(); - for (std::vector<cmExportBuildFileGenerator*>::const_iterator it = - gens.begin(); - it != gens.end(); ++it) { - (*it)->Compute(this->LocalGenerators[i]); + for (cmExportBuildFileGenerator* g : gens) { + g->Compute(this->LocalGenerators[i]); } } } @@ -1264,15 +1314,15 @@ bool cmGlobalGenerator::Compute() #ifdef CMAKE_BUILD_WITH_CMAKE // 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(); + auto autogenInits = this->CreateQtAutoGenInitializers(); + for (auto& autoGen : autogenInits) { + autoGen->InitCustomTargets(); + } #endif - unsigned int i; - // Add generator specific helper commands - for (i = 0; i < this->LocalGenerators.size(); ++i) { - this->LocalGenerators[i]->AddHelperCommands(); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + localGen->AddHelperCommands(); } // Finalize the set of compile features for each target. @@ -1281,26 +1331,24 @@ bool cmGlobalGenerator::Compute() // on the original cmTarget instance. It accumulates features // across all configurations. Some refactoring is needed to // compute a per-config resulta purely during generation. - for (i = 0; i < this->LocalGenerators.size(); ++i) { - if (!this->LocalGenerators[i]->ComputeTargetCompileFeatures()) { + for (cmLocalGenerator* localGen : this->LocalGenerators) { + if (!localGen->ComputeTargetCompileFeatures()) { return false; } } #ifdef CMAKE_BUILD_WITH_CMAKE - for (std::vector<cmGeneratorTarget const*>::iterator it = - autogenTargets.begin(); - it != autogenTargets.end(); ++it) { - cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(*it); + for (auto& autoGen : autogenInits) { + autoGen->SetupCustomTargets(); + autoGen.reset(nullptr); } + autogenInits.clear(); #endif - 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)->Compute(this->LocalGenerators[i]); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + cmMakefile* mf = localGen->GetMakefile(); + for (cmInstallGenerator* g : mf->GetInstallGenerators()) { + g->Compute(localGen); } } @@ -1308,15 +1356,20 @@ bool cmGlobalGenerator::Compute() // 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) { - this->LocalGenerators[i]->TraceDependencies(); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + localGen->TraceDependencies(); + } + + // Make sure that all (non-imported) targets have source files added! + if (this->CheckTargetsForMissingSources()) { + return false; } this->ForceLinkerLanguages(); // Compute the manifest of main targets generated. - for (i = 0; i < this->LocalGenerators.size(); ++i) { - this->LocalGenerators[i]->ComputeTargetManifest(); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + localGen->ComputeTargetManifest(); } // Compute the inter-target dependencies. @@ -1324,8 +1377,8 @@ bool cmGlobalGenerator::Compute() return false; } - for (i = 0; i < this->LocalGenerators.size(); ++i) { - this->LocalGenerators[i]->ComputeHomeRelativeOutputPath(); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + localGen->ComputeHomeRelativeOutputPath(); } return true; @@ -1352,17 +1405,15 @@ void cmGlobalGenerator::Generate() "Generating", (static_cast<float>(i) + 1.0f) / static_cast<float>(this->LocalGenerators.size())); } - this->SetCurrentMakefile(CM_NULLPTR); + this->SetCurrentMakefile(nullptr); 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()) { + for (auto& buildExpSet : this->BuildExportSets) { + if (!buildExpSet.second->GenerateImportFile()) { if (!cmSystemTools::GetErrorOccuredFlag()) { this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, "Could not write export file."); @@ -1375,7 +1426,7 @@ void cmGlobalGenerator::Generate() this->WriteSummary(); - if (this->ExtraGenerator != CM_NULLPTR) { + if (this->ExtraGenerator != nullptr) { this->ExtraGenerator->Generate(); } @@ -1384,10 +1435,8 @@ void cmGlobalGenerator::Generate() 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) { - w << " " << *iter << "\n"; + for (std::string const& t : this->CMP0042WarnTargets) { + w << " " << t << "\n"; } this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str()); } @@ -1402,10 +1451,8 @@ void cmGlobalGenerator::Generate() "settings:\n" ; /* clang-format on */ - for (std::set<std::string>::iterator iter = - this->CMP0068WarnTargets.begin(); - iter != this->CMP0068WarnTargets.end(); ++iter) { - w << " " << *iter << "\n"; + for (std::string const& t : this->CMP0068WarnTargets) { + w << " " << t << "\n"; } this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str()); } @@ -1420,68 +1467,57 @@ bool cmGlobalGenerator::ComputeTargetDepends() return false; } std::vector<cmGeneratorTarget const*> const& targets = ctd.GetTargets(); - for (std::vector<cmGeneratorTarget const*>::const_iterator ti = - targets.begin(); - ti != targets.end(); ++ti) { - ctd.GetTargetDirectDepends(*ti, this->TargetDependencies[*ti]); + for (cmGeneratorTarget const* target : targets) { + ctd.GetTargetDirectDepends(target, this->TargetDependencies[target]); } return true; } -std::vector<const cmGeneratorTarget*> -cmGlobalGenerator::CreateQtAutoGeneratorsTargets() +std::vector<std::unique_ptr<cmQtAutoGeneratorInitializer>> +cmGlobalGenerator::CreateQtAutoGenInitializers() { - std::vector<const cmGeneratorTarget*> autogenTargets; + std::vector<std::unique_ptr<cmQtAutoGeneratorInitializer>> autogenInits; #ifdef CMAKE_BUILD_WITH_CMAKE - 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() == cmStateEnums::GLOBAL_TARGET) { + for (cmLocalGenerator* localGen : this->LocalGenerators) { + const std::vector<cmGeneratorTarget*>& targets = + localGen->GetGeneratorTargets(); + // Find targets that require AUTOGEN processing + for (cmGeneratorTarget* target : targets) { + if (target->GetType() == cmStateEnums::GLOBAL_TARGET) { continue; } - if ((*ti)->GetType() != cmStateEnums::EXECUTABLE && - (*ti)->GetType() != cmStateEnums::STATIC_LIBRARY && - (*ti)->GetType() != cmStateEnums::SHARED_LIBRARY && - (*ti)->GetType() != cmStateEnums::MODULE_LIBRARY && - (*ti)->GetType() != cmStateEnums::OBJECT_LIBRARY) { + if (target->GetType() != cmStateEnums::EXECUTABLE && + target->GetType() != cmStateEnums::STATIC_LIBRARY && + target->GetType() != cmStateEnums::SHARED_LIBRARY && + target->GetType() != cmStateEnums::MODULE_LIBRARY && + target->GetType() != cmStateEnums::OBJECT_LIBRARY) { continue; } - if ((!(*ti)->GetPropertyAsBool("AUTOMOC") && - !(*ti)->GetPropertyAsBool("AUTOUIC") && - !(*ti)->GetPropertyAsBool("AUTORCC")) || - (*ti)->IsImported()) { + if (target->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 == "") { - qtMajorVersion = mf->GetSafeDefinition("Qt5Core_VERSION_MAJOR"); - } - if (qtMajorVersion != "4" && qtMajorVersion != "5") { + + const bool mocEnabled = target->GetPropertyAsBool("AUTOMOC"); + const bool uicEnabled = target->GetPropertyAsBool("AUTOUIC"); + const bool rccEnabled = target->GetPropertyAsBool("AUTORCC"); + if (!mocEnabled && !uicEnabled && !rccEnabled) { continue; } - cmGeneratorTarget* gt = *ti; + std::string qtVersionMajor = + cmQtAutoGeneratorInitializer::GetQtMajorVersion(target); + // don't do anything if there is no Qt4 or Qt5Core (which contains moc) + if (qtVersionMajor != "4" && qtVersionMajor != "5") { + continue; + } - cmQtAutoGeneratorInitializer::InitializeAutogenSources(gt); - filteredTargets.push_back(gt); - } - for (std::vector<cmGeneratorTarget*>::iterator ti = - filteredTargets.begin(); - ti != filteredTargets.end(); ++ti) { - cmQtAutoGeneratorInitializer::InitializeAutogenTarget( - this->LocalGenerators[i], *ti); - autogenTargets.push_back(*ti); + autogenInits.emplace_back(new cmQtAutoGeneratorInitializer( + target, mocEnabled, uicEnabled, rccEnabled, qtVersionMajor)); } } #endif - return autogenTargets; + return autogenInits; } cmLinkLineComputer* cmGlobalGenerator::CreateLinkLineComputer( @@ -1502,17 +1538,15 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() this->CMakeInstance->GetState()->GetEnabledLanguages(); // Construct per-target generator information. - for (unsigned int i = 0; i < this->Makefiles.size(); ++i) { - cmMakefile* mf = this->Makefiles[i]; - + for (cmMakefile* mf : this->Makefiles) { const cmStringRange noconfig_compile_definitions = mf->GetCompileDefinitionsEntries(); const cmBacktraceRange noconfig_compile_definitions_bts = mf->GetCompileDefinitionsBacktraces(); cmTargets& targets = mf->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - cmTarget* t = &ti->second; + for (auto& target : targets) { + cmTarget* t = &target.second; if (t->GetType() == cmStateEnums::GLOBAL_TARGET) { continue; } @@ -1537,10 +1571,9 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() std::vector<std::string> configs; mf->GetConfigurations(configs); - for (std::vector<std::string>::const_iterator ci = configs.begin(); - ci != configs.end(); ++ci) { + for (std::string const& c : configs) { std::string defPropName = "COMPILE_DEFINITIONS_"; - defPropName += cmSystemTools::UpperCase(*ci); + defPropName += cmSystemTools::UpperCase(c); t->AppendProperty(defPropName, mf->GetProperty(defPropName)); } } @@ -1549,10 +1582,9 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo() // The standard include directories for each language // should be treated as system include directories. std::set<std::string> standardIncludesSet; - for (std::vector<std::string>::const_iterator li = langs.begin(); - li != langs.end(); ++li) { + for (std::string const& li : langs) { std::string const standardIncludesVar = - "CMAKE_" + *li + "_STANDARD_INCLUDE_DIRECTORIES"; + "CMAKE_" + li + "_STANDARD_INCLUDE_DIRECTORIES"; std::string const standardIncludesStr = mf->GetSafeDefinition(standardIncludesVar); std::vector<std::string> standardIncludesVec; @@ -1571,8 +1603,8 @@ void cmGlobalGenerator::CreateGeneratorTargets( { if (targetTypes == AllTargets) { cmTargets& targets = mf->GetTargets(); - for (cmTargets::iterator ti = targets.begin(); ti != targets.end(); ++ti) { - cmTarget* t = &ti->second; + for (auto& target : targets) { + cmTarget* t = &target.second; cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg); lg->AddGeneratorTarget(gt); } @@ -1580,9 +1612,8 @@ void cmGlobalGenerator::CreateGeneratorTargets( std::vector<cmTarget*> itgts = mf->GetImportedTargets(); - for (std::vector<cmTarget*>::const_iterator j = itgts.begin(); - j != itgts.end(); ++j) { - lg->AddImportedGeneratorTarget(importedMap.find(*j)->second); + for (cmTarget* t : itgts) { + lg->AddImportedGeneratorTarget(importedMap.find(t)->second); } } @@ -1591,13 +1622,11 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes) std::map<cmTarget*, cmGeneratorTarget*> importedMap; 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 (cmTarget* ownedImpTgt : mf->GetOwnedImportedTargets()) { cmLocalGenerator* lg = this->LocalGenerators[i]; - cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg); + cmGeneratorTarget* gt = new cmGeneratorTarget(ownedImpTgt, lg); lg->AddOwnedImportedGeneratorTarget(gt); - importedMap[*j] = gt; + importedMap[ownedImpTgt] = gt; } } @@ -1644,30 +1673,30 @@ void cmGlobalGenerator::CheckTargetProperties() 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() == cmStateEnums::INTERFACE_LIBRARY) { + for (auto const& target : targets) { + if (target.second.GetType() == cmStateEnums::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); + target.second.GetOriginalLinkLibraries(); + for (auto const& lib : libs) { + 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 += target.second.GetName(); text += "\" in directory "; text += this->Makefiles[i]->GetCurrentSourceDirectory(); notFoundMap[varName] = text; } } std::vector<std::string> incs; - const char* incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES"); + const char* incDirProp = + target.second.GetProperty("INCLUDE_DIRECTORIES"); if (!incDirProp) { continue; } @@ -1677,10 +1706,9 @@ void cmGlobalGenerator::CheckTargetProperties() 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); + for (std::string const& incDir : incs) { + 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)"; } @@ -1699,11 +1727,9 @@ void cmGlobalGenerator::CheckTargetProperties() if (!notFoundMap.empty()) { std::string notFoundVars; - for (std::map<std::string, std::string>::const_iterator ii = - notFoundMap.begin(); - ii != notFoundMap.end(); ++ii) { - notFoundVars += ii->first; - notFoundVars += ii->second; + for (auto const& notFound : notFoundMap) { + notFoundVars += notFound.first; + notFoundVars += notFound.second; notFoundVars += "\n"; } cmSystemTools::Error("The following variables are used in this project, " @@ -1815,7 +1841,7 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/, output += "\n"; if (!cmSystemTools::RunSingleCommand(cleanCommand, outputPtr, outputPtr, - &retVal, CM_NULLPTR, outputflag, + &retVal, nullptr, outputflag, timeout)) { cmSystemTools::SetRunCommandHideConsole(hideconsole); cmSystemTools::Error("Generator: execution of make clean failed."); @@ -1834,7 +1860,7 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/, output += "\n"; if (!cmSystemTools::RunSingleCommand(makeCommand, outputPtr, outputPtr, - &retVal, CM_NULLPTR, outputflag, + &retVal, nullptr, outputflag, timeout)) { cmSystemTools::SetRunCommandHideConsole(hideconsole); cmSystemTools::Error( @@ -1859,6 +1885,16 @@ int cmGlobalGenerator::Build(const std::string& /*unused*/, return retVal; } +bool cmGlobalGenerator::Open(const std::string& bindir, + const std::string& projectName, bool dryRun) +{ + if (this->ExtraGenerator) { + return this->ExtraGenerator->Open(bindir, projectName, dryRun); + } + + return false; +} + std::string cmGlobalGenerator::GenerateCMakeBuildCommand( const std::string& target, const std::string& config, const std::string& native, bool ignoreErrors) @@ -2035,16 +2071,15 @@ int cmGlobalGenerator::GetLinkerPreference(const std::string& lang) const 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 (cmLocalGenerator* localGen : this->LocalGenerators) { // for each local generator add all projects - cmStateSnapshot snp = this->LocalGenerators[i]->GetStateSnapshot(); + cmStateSnapshot snp = localGen->GetStateSnapshot(); std::string name; do { std::string snpProjName = snp.GetProjectName(); if (name != snpProjName) { name = snpProjName; - this->ProjectMap[name].push_back(this->LocalGenerators[i]); + this->ProjectMap[name].push_back(localGen); } snp = snp.GetBuildsystemDirectoryParent(); } while (snp.IsValid()); @@ -2057,22 +2092,20 @@ cmMakefile* cmGlobalGenerator::FindMakefile(const std::string& start_dir) const if (i != this->MakefileSearchIndex.end()) { return i->second; } - return CM_NULLPTR; + return nullptr; } ///! Find a local generator by its startdirectory cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator( const std::string& start_dir) const { - for (std::vector<cmLocalGenerator*>::const_iterator it = - this->LocalGenerators.begin(); - it != this->LocalGenerators.end(); ++it) { - std::string sd = (*it)->GetCurrentSourceDirectory(); + for (cmLocalGenerator* lg : this->LocalGenerators) { + std::string sd = lg->GetCurrentSourceDirectory(); if (sd == start_dir) { - return *it; + return lg; } } - return CM_NULLPTR; + return nullptr; } void cmGlobalGenerator::AddAlias(const std::string& name, @@ -2117,7 +2150,7 @@ cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const if (i != this->TargetSearchIndex.end()) { return i->second; } - return CM_NULLPTR; + return nullptr; } cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTargetImpl( @@ -2128,7 +2161,7 @@ cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTargetImpl( if (i != this->GeneratorTargetSearchIndex.end()) { return i->second; } - return CM_NULLPTR; + return nullptr; } cmTarget* cmGlobalGenerator::FindTarget(const std::string& name, @@ -2179,6 +2212,45 @@ inline std::string removeQuotes(const std::string& s) return s; } +bool cmGlobalGenerator::CheckCMP0037(std::string const& targetName, + std::string const& reason) const +{ + cmTarget* tgt = this->FindTarget(targetName); + if (!tgt) { + return true; + } + cmake::MessageType messageType = cmake::AUTHOR_WARNING; + std::ostringstream e; + bool issueMessage = false; + switch (tgt->GetPolicyStatusCMP0037()) { + case cmPolicies::WARN: + e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n"; + issueMessage = true; + CM_FALLTHROUGH; + case cmPolicies::OLD: + break; + case cmPolicies::NEW: + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + issueMessage = true; + messageType = cmake::FATAL_ERROR; + break; + } + if (issueMessage) { + e << "The target name \"" << targetName << "\" is reserved " << reason + << "."; + if (messageType == cmake::AUTHOR_WARNING) { + e << " It may result in undefined behavior."; + } + this->GetCMakeInstance()->IssueMessage(messageType, e.str(), + tgt->GetBacktrace()); + if (messageType == cmake::FATAL_ERROR) { + return false; + } + } + return true; +} + void cmGlobalGenerator::CreateDefaultGlobalTargets( std::vector<GlobalTargetInfo>& targets) { @@ -2194,6 +2266,20 @@ void cmGlobalGenerator::AddGlobalTarget_Package( std::vector<GlobalTargetInfo>& targets) { cmMakefile* mf = this->Makefiles[0]; + std::string configFile = mf->GetCurrentBinaryDirectory(); + configFile += "/CPackConfig.cmake"; + if (!cmSystemTools::FileExists(configFile.c_str())) { + return; + } + + const char* reservedTargets[] = { "package", "PACKAGE" }; + for (const char* const* tn = cm::cbegin(reservedTargets); + tn != cm::cend(reservedTargets); ++tn) { + if (!this->CheckCMP0037(*tn, "when CPack packaging is enabled")) { + return; + } + } + const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir(); GlobalTargetInfo gti; gti.Name = this->GetPackageTargetName(); @@ -2207,8 +2293,6 @@ void cmGlobalGenerator::AddGlobalTarget_Package( singleLine.push_back(cmakeCfgIntDir); } singleLine.push_back("--config"); - std::string configFile = mf->GetCurrentBinaryDirectory(); - configFile += "/CPackConfig.cmake"; std::string relConfigFile = "./CPackConfig.cmake"; singleLine.push_back(relConfigFile); gti.CommandLines.push_back(singleLine); @@ -2221,61 +2305,81 @@ void cmGlobalGenerator::AddGlobalTarget_Package( gti.Depends.push_back(this->GetAllTargetName()); } } - if (cmSystemTools::FileExists(configFile.c_str())) { - targets.push_back(gti); - } + targets.push_back(gti); } void cmGlobalGenerator::AddGlobalTarget_PackageSource( std::vector<GlobalTargetInfo>& targets) { - cmMakefile* mf = this->Makefiles[0]; const char* packageSourceTargetName = this->GetPackageSourceTargetName(); - if (packageSourceTargetName) { - GlobalTargetInfo gti; - gti.Name = packageSourceTargetName; - gti.Message = "Run CPack packaging tool for source..."; - gti.WorkingDir = mf->GetCurrentBinaryDirectory(); - gti.UsesTerminal = true; - cmCustomCommandLine singleLine; - singleLine.push_back(cmSystemTools::GetCPackCommand()); - singleLine.push_back("--config"); - std::string configFile = mf->GetCurrentBinaryDirectory(); - configFile += "/CPackSourceConfig.cmake"; - std::string relConfigFile = "./CPackSourceConfig.cmake"; - singleLine.push_back(relConfigFile); - if (cmSystemTools::FileExists(configFile.c_str())) { - singleLine.push_back(configFile); - gti.CommandLines.push_back(singleLine); - targets.push_back(gti); + if (!packageSourceTargetName) { + return; + } + + cmMakefile* mf = this->Makefiles[0]; + std::string configFile = mf->GetCurrentBinaryDirectory(); + configFile += "/CPackSourceConfig.cmake"; + if (!cmSystemTools::FileExists(configFile.c_str())) { + return; + } + + const char* reservedTargets[] = { "package_source" }; + for (const char* const* tn = cm::cbegin(reservedTargets); + tn != cm::cend(reservedTargets); ++tn) { + if (!this->CheckCMP0037(*tn, "when CPack source packaging is enabled")) { + return; } } + + GlobalTargetInfo gti; + gti.Name = packageSourceTargetName; + gti.Message = "Run CPack packaging tool for source..."; + gti.WorkingDir = mf->GetCurrentBinaryDirectory(); + gti.UsesTerminal = true; + cmCustomCommandLine singleLine; + singleLine.push_back(cmSystemTools::GetCPackCommand()); + singleLine.push_back("--config"); + std::string relConfigFile = "./CPackSourceConfig.cmake"; + singleLine.push_back(relConfigFile); + singleLine.push_back(configFile); + gti.CommandLines.push_back(singleLine); + targets.push_back(gti); } void cmGlobalGenerator::AddGlobalTarget_Test( std::vector<GlobalTargetInfo>& targets) { cmMakefile* mf = this->Makefiles[0]; - const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir(); - if (mf->IsOn("CMAKE_TESTING_ENABLED")) { - GlobalTargetInfo gti; - gti.Name = this->GetTestTargetName(); - gti.Message = "Running tests..."; - gti.UsesTerminal = true; - cmCustomCommandLine singleLine; - singleLine.push_back(cmSystemTools::GetCTestCommand()); - singleLine.push_back("--force-new-ctest-process"); - 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 - { - singleLine.push_back("$(ARGS)"); + if (!mf->IsOn("CMAKE_TESTING_ENABLED")) { + return; + } + + const char* reservedTargets[] = { "test", "RUN_TESTS" }; + for (const char* const* tn = cm::cbegin(reservedTargets); + tn != cm::cend(reservedTargets); ++tn) { + if (!this->CheckCMP0037(*tn, "when CTest testing is enabled")) { + return; } - gti.CommandLines.push_back(singleLine); - targets.push_back(gti); } + + const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir(); + GlobalTargetInfo gti; + gti.Name = this->GetTestTargetName(); + gti.Message = "Running tests..."; + gti.UsesTerminal = true; + cmCustomCommandLine singleLine; + singleLine.push_back(cmSystemTools::GetCTestCommand()); + singleLine.push_back("--force-new-ctest-process"); + 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 + { + singleLine.push_back("$(ARGS)"); + } + gti.CommandLines.push_back(singleLine); + targets.push_back(gti); } void cmGlobalGenerator::AddGlobalTarget_EditCache( @@ -2413,7 +2517,7 @@ void cmGlobalGenerator::AddGlobalTarget_Install( // install_strip const char* install_strip = this->GetInstallStripTargetName(); - if ((install_strip != CM_NULLPTR) && (mf->IsSet("CMAKE_STRIP"))) { + if ((install_strip != nullptr) && (mf->IsSet("CMAKE_STRIP"))) { gti.Name = install_strip; gti.Message = "Installing the project stripped..."; gti.UsesTerminal = true; @@ -2470,16 +2574,15 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(GlobalTargetInfo const& gti, std::vector<std::string> no_byproducts; std::vector<std::string> no_depends; // Store the custom command in the target. - cmCustomCommand cc(CM_NULLPTR, no_outputs, no_byproducts, no_depends, - gti.CommandLines, CM_NULLPTR, gti.WorkingDir.c_str()); + cmCustomCommand cc(nullptr, no_outputs, no_byproducts, no_depends, + gti.CommandLines, nullptr, gti.WorkingDir.c_str()); cc.SetUsesTerminal(gti.UsesTerminal); target.AddPostBuildCommand(cc); if (!gti.Message.empty()) { target.SetProperty("EchoString", gti.Message.c_str()); } - for (std::vector<std::string>::const_iterator dit = gti.Depends.begin(); - dit != gti.Depends.end(); ++dit) { - target.AddUtility(*dit); + for (std::string const& d : gti.Depends) { + target.AddUtility(d); } // Organize in the "predefined targets" folder: @@ -2542,21 +2645,20 @@ 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", + "ZERO_CHECK" }; - return std::find(cmArrayBegin(reservedTargets), cmArrayEnd(reservedTargets), - name) != cmArrayEnd(reservedTargets); + return std::find(cm::cbegin(reservedTargets), cm::cend(reservedTargets), + name) != cm::cend(reservedTargets); } void cmGlobalGenerator::SetExternalMakefileProjectGenerator( cmExternalMakefileProjectGenerator* extraGenerator) { this->ExtraGenerator = extraGenerator; - if (this->ExtraGenerator != CM_NULLPTR) { + if (this->ExtraGenerator != nullptr) { this->ExtraGenerator->SetGlobalGenerator(this); } } @@ -2587,18 +2689,16 @@ 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 (cmLocalGenerator* generator : generators) { // check to make sure generator is not excluded - if (this->IsExcluded(root, *i)) { + if (this->IsExcluded(root, generator)) { continue; } // Get the targets in the makefile - std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets(); + const std::vector<cmGeneratorTarget*>& tgts = + generator->GetGeneratorTargets(); // loop over all the targets - for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin(); - l != tgts.end(); ++l) { - cmGeneratorTarget* target = *l; + for (cmGeneratorTarget* target : tgts) { if (this->IsRootOnlyTarget(target) && target->GetLocalGenerator() != root) { continue; @@ -2625,8 +2725,8 @@ void cmGlobalGenerator::AddTargetDepends(cmGeneratorTarget const* target, // 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) { - this->AddTargetDepends(*i, projectTargets); + for (auto const& t : ts) { + this->AddTargetDepends(t, projectTargets); } } } @@ -2771,11 +2871,9 @@ void cmGlobalGenerator::WriteRuleHashes(std::string const& pfile) } 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) { - fout.write(rhi->second.Data, 32); - fout << " " << rhi->first << "\n"; + for (auto const& rh : this->RuleHashes) { + fout.write(rh.second.Data, 32); + fout << " " << rh.first << "\n"; } } } @@ -2788,16 +2886,14 @@ void cmGlobalGenerator::WriteSummary() fname += "/TargetDirectories.txt"; cmGeneratedFileStream fout(fname.c_str()); - for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { - std::vector<cmGeneratorTarget*> tgts = - this->LocalGenerators[i]->GetGeneratorTargets(); - for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin(); - it != tgts.end(); ++it) { - if ((*it)->GetType() == cmStateEnums::INTERFACE_LIBRARY) { + for (cmLocalGenerator* lg : this->LocalGenerators) { + const std::vector<cmGeneratorTarget*>& tgts = lg->GetGeneratorTargets(); + for (cmGeneratorTarget* tgt : tgts) { + if (tgt->GetType() == cmStateEnums::INTERFACE_LIBRARY) { continue; } - this->WriteSummary(*it); - fout << (*it)->GetSupportDirectory() << "\n"; + this->WriteSummary(tgt); + fout << tgt->GetSupportDirectory() << "\n"; } } } @@ -2812,7 +2908,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")) { + const char* targetLabels = target->GetProperty("LABELS"); + const char* directoryLabels = + target->Target->GetMakefile()->GetProperty("LABELS"); + const char* cmakeDirectoryLabels = + target->Target->GetMakefile()->GetDefinition("CMAKE_DIRECTORY_LABELS"); + if (targetLabels || directoryLabels || cmakeDirectoryLabels) { Json::Value lj_root(Json::objectValue); Json::Value& lj_target = lj_root["target"] = Json::objectValue; lj_target["name"] = target->GetName(); @@ -2822,19 +2923,48 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target) cmSystemTools::MakeDirectory(dir.c_str()); cmGeneratedFileStream fout(file.c_str()); + std::vector<std::string> labels; + // List the target-wide labels. All sources in the target get // these labels. - std::vector<std::string> labels; - cmSystemTools::ExpandListArgument(value, labels); - if (!labels.empty()) { - fout << "# Target labels\n"; - for (std::vector<std::string>::const_iterator li = labels.begin(); - li != labels.end(); ++li) { - fout << " " << *li << "\n"; - lj_target_labels.append(*li); + if (targetLabels) { + cmSystemTools::ExpandListArgument(targetLabels, labels); + if (!labels.empty()) { + fout << "# Target labels\n"; + for (std::string const& l : labels) { + fout << " " << l << "\n"; + lj_target_labels.append(l); + } } } + // List directory labels + std::vector<std::string> directoryLabelsList; + std::vector<std::string> cmakeDirectoryLabelsList; + + if (directoryLabels) { + cmSystemTools::ExpandListArgument(directoryLabels, directoryLabelsList); + } + + if (cmakeDirectoryLabels) { + cmSystemTools::ExpandListArgument(cmakeDirectoryLabels, + cmakeDirectoryLabelsList); + } + + if (!directoryLabelsList.empty() || !cmakeDirectoryLabelsList.empty()) { + fout << "# Directory labels\n"; + } + + for (std::string const& li : directoryLabelsList) { + fout << " " << li << "\n"; + lj_target_labels.append(li); + } + + for (std::string const& li : cmakeDirectoryLabelsList) { + 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; @@ -2843,9 +2973,8 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target) if (configs.empty()) { configs.push_back(""); } - for (std::vector<std::string>::const_iterator ci = configs.begin(); - ci != configs.end(); ++ci) { - target->GetSourceFiles(sources, *ci); + for (std::string const& c : configs) { + target->GetSourceFiles(sources, c); } std::vector<cmSourceFile*>::const_iterator sourcesEnd = cmRemoveDuplicates(sources); @@ -2860,10 +2989,9 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target) labels.clear(); 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) { - fout << " " << *li << "\n"; - lj_source_labels.append(*li); + for (std::string const& label : labels) { + fout << " " << label << "\n"; + lj_source_labels.append(label); } } } @@ -2881,11 +3009,11 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target) 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] == '\\') { + for (char i : s) { + if (i == '"' || i == '\\') { result += '\\'; } - result += s[i]; + result += i; } return result; } @@ -2905,18 +3033,16 @@ cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const void cmGlobalGenerator::CreateEvaluationSourceFiles( std::string const& config) const { - unsigned int i; - for (i = 0; i < this->LocalGenerators.size(); ++i) { - this->LocalGenerators[i]->CreateEvaluationFileOutputs(config); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + localGen->CreateEvaluationFileOutputs(config); } } void cmGlobalGenerator::ProcessEvaluationFiles() { std::vector<std::string> generatedFiles; - unsigned int i; - for (i = 0; i < this->LocalGenerators.size(); ++i) { - this->LocalGenerators[i]->ProcessEvaluationFiles(generatedFiles); + for (cmLocalGenerator* localGen : this->LocalGenerators) { + localGen->ProcessEvaluationFiles(generatedFiles); } } @@ -2947,9 +3073,8 @@ bool cmGlobalGenerator::GenerateCPackPropertiesFile() cmGeneratedFileStream file(path.c_str()); file << "# CPack properties\n"; - for (cmake::InstalledFilesMap::const_iterator i = installedFiles.begin(); - i != installedFiles.end(); ++i) { - cmInstalledFile const& installedFile = i->second; + for (auto const& i : installedFiles) { + cmInstalledFile const& installedFile = i.second; cmCPackPropertiesGenerator cpackPropertiesGenerator(lg, installedFile, configs); |