mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-04-21 05:38:24 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge topic 'ranged-for'

Browse Source 
7d509579 Meta: modernize old-fashioned loops to range-based `for`.

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1249
This commit is contained in:
Brad King
2017-09-13 12:34:49 +00:00
committed by Kitware Robot
parent a763cffd6b 7d5095796a
commit 67810849b9
133 changed files with 2453 additions and 3589 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/bindexplib.cxx
+4 -6
View File
@@ -394,12 +394,10 @@ bool bindexplib::AddDefinitionFile(const char* filename)
void bindexplib::WriteFile(FILE* file)
{
fprintf(file, "EXPORTS \n");
for (std::set<std::string>::const_iterator i = this->DataSymbols.begin();
i != this->DataSymbols.end(); ++i) {
fprintf(file, "\t%s \t DATA\n", i->c_str());
for (std::string const& ds : this->DataSymbols) {
fprintf(file, "\t%s \t DATA\n", ds.c_str());
}
for (std::set<std::string>::const_iterator i = this->Symbols.begin();
i != this->Symbols.end(); ++i) {
fprintf(file, "\t%s\n", i->c_str());
for (std::string const& s : this->Symbols) {
fprintf(file, "\t%s\n", s.c_str());
}
}
Source/cmAddCompileOptionsCommand.cxx
+2 -3
View File
@@ -13,9 +13,8 @@ bool cmAddCompileOptionsCommand::InitialPass(
return true;
}
for (std::vector<std::string>::const_iterator i = args.begin();
i != args.end(); ++i) {
this->Makefile->AddCompileOption(i->c_str());
for (std::string const& i : args) {
this->Makefile->AddCompileOption(i.c_str());
}
return true;
}
Source/cmAddCustomCommandCommand.cxx
+6 -9
View File
@@ -68,9 +68,7 @@ bool cmAddCustomCommandCommand::InitialPass(
tdoing doing = doing_nothing;
for (unsigned int j = 0; j < args.size(); ++j) {
std::string const& copy = args[j];
for (std::string const& copy : args) {
if (copy == "SOURCE") {
doing = doing_source;
} else if (copy == "COMMAND") {
@@ -355,12 +353,11 @@ bool cmAddCustomCommandCommand::InitialPass(
bool cmAddCustomCommandCommand::CheckOutputs(
const std::vector<std::string>& outputs)
{
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
for (std::string const& o : outputs) {
// Make sure the file will not be generated into the source
// directory during an out of source build.
if (!this->Makefile->CanIWriteThisFile(o->c_str())) {
std::string e = "attempted to have a file \"" + *o +
if (!this->Makefile->CanIWriteThisFile(o.c_str())) {
std::string e = "attempted to have a file \"" + o +
"\" in a source directory as an output of custom command.";
this->SetError(e);
cmSystemTools::SetFatalErrorOccured();
@@ -368,10 +365,10 @@ bool cmAddCustomCommandCommand::CheckOutputs(
}
// Make sure the output file name has no invalid characters.
std::string::size_type pos = o->find_first_of("#<>");
std::string::size_type pos = o.find_first_of("#<>");
if (pos != std::string::npos) {
std::ostringstream msg;
msg << "called with OUTPUT containing a \"" << (*o)[pos]
msg << "called with OUTPUT containing a \"" << o[pos]
<< "\". This character is not allowed.";
this->SetError(msg.str());
return false;
Source/cmAddDefinitionsCommand.cxx
+2 -3
View File
@@ -15,9 +15,8 @@ bool cmAddDefinitionsCommand::InitialPass(std::vector<std::string> const& args,
return true;
}
for (std::vector<std::string>::const_iterator i = args.begin();
i != args.end(); ++i) {
this->Makefile->AddDefineFlag(i->c_str());
for (std::string const& i : args) {
this->Makefile->AddDefineFlag(i.c_str());
}
return true;
}
Source/cmCLocaleEnvironmentScope.cxx
+2 -3
View File
@@ -45,10 +45,9 @@ void cmCLocaleEnvironmentScope::SetEnv(std::string const& key,
cmCLocaleEnvironmentScope::~cmCLocaleEnvironmentScope()
{
for (backup_map_t::const_iterator i = this->EnvironmentBackup.begin();
i != this->EnvironmentBackup.end(); ++i) {
for (auto const& envb : this->EnvironmentBackup) {
std::ostringstream tmp;
tmp << i->first << "=" << i->second;
tmp << envb.first << "=" << envb.second;
cmSystemTools::PutEnv(tmp.str());
}
}
Source/cmCMakeMinimumRequired.cxx
+5 -5
View File
@@ -19,10 +19,10 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
// Process arguments.
std::string version_string;
bool doing_version = false;
for (unsigned int i = 0; i < args.size(); ++i) {
if (args[i] == "VERSION") {
for (std::string const& arg : args) {
if (arg == "VERSION") {
doing_version = true;
} else if (args[i] == "FATAL_ERROR") {
} else if (arg == "FATAL_ERROR") {
if (doing_version) {
this->SetError("called with no value for VERSION.");
return false;
@@ -30,9 +30,9 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
doing_version = false;
} else if (doing_version) {
doing_version = false;
version_string = args[i];
version_string = arg;
} else {
this->UnknownArguments.push_back(args[i]);
this->UnknownArguments.push_back(arg);
}
}
if (doing_version) {
Source/cmCPackPropertiesGenerator.cxx
+6 -9
View File
@@ -6,7 +6,6 @@
#include <map>
#include <ostream>
#include <utility>
cmCPackPropertiesGenerator::cmCPackPropertiesGenerator(
cmLocalGenerator* lg, cmInstalledFile const& installedFile,
@@ -27,19 +26,17 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(
cmInstalledFile::PropertyMapType const& properties =
this->InstalledFile.GetProperties();
for (cmInstalledFile::PropertyMapType::const_iterator i = properties.begin();
i != properties.end(); ++i) {
std::string const& name = i->first;
cmInstalledFile::Property const& property = i->second;
for (cmInstalledFile::PropertyMapType::value_type const& i : properties) {
std::string const& name = i.first;
cmInstalledFile::Property const& property = i.second;
os << indent << "set_property(INSTALL "
<< cmOutputConverter::EscapeForCMake(expandedFileName) << " PROPERTY "
<< cmOutputConverter::EscapeForCMake(name);
for (cmInstalledFile::ExpressionVectorType::const_iterator j =
property.ValueExpressions.begin();
j != property.ValueExpressions.end(); ++j) {
std::string value = (*j)->Evaluate(this->LG, config);
for (cmInstalledFile::ExpressionVectorType::value_type const& j :
property.ValueExpressions) {
std::string value = j->Evaluate(this->LG, config);
os << " " << cmOutputConverter::EscapeForCMake(value);
}
Source/cmCPluginAPI.cxx
+4 -5
View File
@@ -504,8 +504,8 @@ public:
typedef derived::value_type value_type;
~cmCPluginAPISourceFileMap()
{
for (iterator i = this->begin(); i != this->end(); ++i) {
delete i->second;
for (auto const& i : *this) {
delete i.second;
}
}
};
@@ -568,9 +568,8 @@ void* CCONV cmAddSource(void* arg, void* arg2)
// Create the real cmSourceFile instance and copy over saved information.
cmSourceFile* rsf = mf->GetOrCreateSource(osf->FullPath);
rsf->GetProperties() = osf->Properties;
for (std::vector<std::string>::iterator i = osf->Depends.begin();
i != osf->Depends.end(); ++i) {
rsf->AddDepend(*i);
for (std::string const& d : osf->Depends) {
rsf->AddDepend(d);
}
// Create the proxy for the real source file.
Source/cmCTest.cxx
+16 -21
View File
@@ -222,8 +222,7 @@ std::string cmCTest::MakeURLSafe(const std::string& str)
{
std::ostringstream ost;
char buffer[10];
for (std::string::size_type pos = 0; pos < str.size(); pos++) {
unsigned char ch = str[pos];
for (unsigned char ch : str) {
if ((ch > 126 || ch < 32 || ch == '&' || ch == '%' || ch == '+' ||
ch == '=' || ch == '@') &&
ch != 9) {
@@ -973,9 +972,8 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
}
std::vector<const char*> argv;
for (std::vector<std::string>::const_iterator a = args.begin();
a != args.end(); ++a) {
argv.push_back(a->c_str());
for (std::string const& a : args) {
argv.push_back(a.c_str());
}
argv.push_back(nullptr);
@@ -1009,9 +1007,9 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
<< " " << std::flush);
while (cmsysProcess_WaitForData(cp, &data, &length, nullptr)) {
processOutput.DecodeText(data, length, strdata);
for (size_t cc = 0; cc < strdata.size(); ++cc) {
if (strdata[cc] == 0) {
strdata[cc] = '\n';
for (char& cc : strdata) {
if (cc == 0) {
cc = '\n';
}
}
output.append(strdata);
@@ -1107,18 +1105,18 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
inst.SetStreams(&oss, &oss);
std::vector<std::string> args;
for (unsigned int i = 0; i < argv.size(); ++i) {
if (argv[i]) {
for (char const* i : argv) {
if (i) {
// make sure we pass the timeout in for any build and test
// invocations. Since --build-generator is required this is a
// good place to check for it, and to add the arguments in
if (strcmp(argv[i], "--build-generator") == 0 && timeout > 0) {
if (strcmp(i, "--build-generator") == 0 && timeout > 0) {
args.push_back("--test-timeout");
std::ostringstream msg;
msg << timeout;
args.push_back(msg.str());
}
args.push_back(argv[i]);
args.push_back(i);
}
}
if (log) {
@@ -1348,9 +1346,8 @@ void cmCTest::AddSiteProperties(cmXMLWriter& xml)
std::string l = labels;
std::vector<std::string> args;
cmSystemTools::ExpandListArgument(l, args);
for (std::vector<std::string>::iterator i = args.begin();
i != args.end(); ++i) {
xml.Element("Label", *i);
for (std::string const& i : args) {
xml.Element("Label", i);
}
xml.EndElement();
}
@@ -2352,9 +2349,8 @@ void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
vec.clear();
cmSystemTools::ExpandListArgument(dval, vec);
for (std::vector<std::string>::const_iterator it = vec.begin();
it != vec.end(); ++it) {
cmCTestLog(this, DEBUG, " -- " << *it << std::endl);
for (std::string const& it : vec) {
cmCTestLog(this, DEBUG, " -- " << it << std::endl);
}
}
@@ -2592,9 +2588,8 @@ bool cmCTest::RunCommand(const char* command, std::string* stdOut,
}
std::vector<const char*> argv;
for (std::vector<std::string>::const_iterator a = args.begin();
a != args.end(); ++a) {
argv.push_back(a->c_str());
for (std::string const& a : args) {
argv.push_back(a.c_str());
}
argv.push_back(nullptr);
Source/cmCacheManager.cxx
+9 -14
View File
@@ -297,10 +297,8 @@ bool cmCacheManager::SaveCache(const std::string& path)
fout << "########################\n";
fout << "\n";
for (std::map<std::string, CacheEntry>::const_iterator i =
this->Cache.begin();
i != this->Cache.end(); ++i) {
const CacheEntry& ce = (*i).second;
for (auto const& i : this->Cache) {
CacheEntry const& ce = i.second;
cmStateEnums::CacheEntryType t = ce.Type;
if (!ce.Initialized) {
/*
@@ -315,7 +313,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
} else {
cmCacheManager::OutputHelpString(fout, "Missing description");
}
this->OutputKey(fout, i->first);
this->OutputKey(fout, i.first);
fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
this->OutputValue(fout, ce.Value);
fout << "\n\n";
@@ -462,11 +460,9 @@ void cmCacheManager::PrintCache(std::ostream& out) const
{
out << "=================================================" << std::endl;
out << "CMakeCache Contents:" << std::endl;
for (std::map<std::string, CacheEntry>::const_iterator i =
this->Cache.begin();
i != this->Cache.end(); ++i) {
if ((*i).second.Type != cmStateEnums::INTERNAL) {
out << (*i).first << " = " << (*i).second.Value << std::endl;
for (auto const& i : this->Cache) {
if (i.second.Type != cmStateEnums::INTERNAL) {
out << i.first << " = " << i.second.Value << std::endl;
}
}
out << "\n\n";
@@ -494,11 +490,10 @@ void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
cmSystemTools::ExpandListArgument(e.Value, paths);
const char* sep = "";
e.Value = "";
for (std::vector<std::string>::iterator i = paths.begin();
i != paths.end(); ++i) {
cmSystemTools::ConvertToUnixSlashes(*i);
for (std::string& i : paths) {
cmSystemTools::ConvertToUnixSlashes(i);
e.Value += sep;
e.Value += *i;
e.Value += i;
sep = ";";
}
} else {
Source/cmCommandArgumentParserHelper.cxx
+2 -2
View File
@@ -258,8 +258,8 @@ int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
void cmCommandArgumentParserHelper::CleanupParser()
{
std::vector<char*>::iterator sit;
for (sit = this->Variables.begin(); sit != this->Variables.end(); ++sit) {
delete[] * sit;
for (char* var : this->Variables) {
delete[] var;
}
this->Variables.erase(this->Variables.begin(), this->Variables.end());
}
Source/cmCommandArgumentsHelper.cxx
+16 -28
View File
@@ -61,11 +61,9 @@ bool cmCommandArgument::KeyMatches(const std::string& key) const
void cmCommandArgument::ApplyOwnGroup()
{
if (this->Group != nullptr) {
for (std::vector<cmCommandArgument*>::const_iterator it =
this->Group->ContainedArguments.begin();
it != this->Group->ContainedArguments.end(); ++it) {
if (*it != this) {
this->ArgumentsBefore.insert(*it);
for (cmCommandArgument* cargs : this->Group->ContainedArguments) {
if (cargs != this) {
this->ArgumentsBefore.insert(cargs);
}
}
}
@@ -180,19 +178,15 @@ void cmCADisabler::DoReset()
void cmCommandArgumentGroup::Follows(const cmCommandArgument* arg)
{
for (std::vector<cmCommandArgument*>::iterator it =
this->ContainedArguments.begin();
it != this->ContainedArguments.end(); ++it) {
(*it)->Follows(arg);
for (cmCommandArgument* ca : this->ContainedArguments) {
ca->Follows(arg);
}
}
void cmCommandArgumentGroup::FollowsGroup(const cmCommandArgumentGroup* group)
{
for (std::vector<cmCommandArgument*>::iterator it =
this->ContainedArguments.begin();
it != this->ContainedArguments.end(); ++it) {
(*it)->FollowsGroup(group);
for (cmCommandArgument* ca : this->ContainedArguments) {
ca->FollowsGroup(group);
}
}
@@ -203,37 +197,31 @@ void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args,
return;
}
for (std::vector<cmCommandArgument*>::iterator argIt =
this->Arguments.begin();
argIt != this->Arguments.end(); ++argIt) {
(*argIt)->ApplyOwnGroup();
(*argIt)->Reset();
for (cmCommandArgument* ca : this->Arguments) {
ca->ApplyOwnGroup();
ca->Reset();
}
cmCommandArgument* activeArgument = nullptr;
const cmCommandArgument* previousArgument = nullptr;
for (std::vector<std::string>::const_iterator it = args->begin();
it != args->end(); ++it) {
for (std::vector<cmCommandArgument*>::iterator argIt =
this->Arguments.begin();
argIt != this->Arguments.end(); ++argIt) {
if ((*argIt)->KeyMatches(*it) &&
((*argIt)->MayFollow(previousArgument))) {
activeArgument = *argIt;
for (std::string const& it : *args) {
for (cmCommandArgument* ca : this->Arguments) {
if (ca->KeyMatches(it) && (ca->MayFollow(previousArgument))) {
activeArgument = ca;
activeArgument->Activate();
break;
}
}
if (activeArgument) {
bool argDone = activeArgument->Consume(*it);
bool argDone = activeArgument->Consume(it);
previousArgument = activeArgument;
if (argDone) {
activeArgument = nullptr;
}
} else {
if (unconsumedArgs != nullptr) {
unconsumedArgs->push_back(*it);
unconsumedArgs->push_back(it);
}
}
}
Source/cmCommonTargetGenerator.cxx
+4 -7
View File
@@ -147,10 +147,8 @@ std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories()
if (cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(this->ConfigName)) {
cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
for (cmComputeLinkInformation::ItemVector::const_iterator i =
items.begin();
i != items.end(); ++i) {
cmGeneratorTarget const* linkee = i->Target;
for (auto const& item : items) {
cmGeneratorTarget const* linkee = item.Target;
if (linkee && !linkee->IsImported()
// We can ignore the INTERFACE_LIBRARY items because
// Target->GetLinkInformation already processed their
@@ -196,12 +194,11 @@ std::string cmCommonTargetGenerator::GetManifests()
this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
std::vector<std::string> manifests;
for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
mi != manifest_srcs.end(); ++mi) {
for (cmSourceFile const* manifest_src : manifest_srcs) {
manifests.push_back(this->LocalCommonGenerator->ConvertToOutputFormat(
this->LocalCommonGenerator->ConvertToRelativePath(
this->LocalCommonGenerator->GetWorkingDirectory(),
(*mi)->GetFullPath()),
manifest_src->GetFullPath()),
cmOutputConverter::SHELL));
}
Source/cmComputeComponentGraph.cxx
+5 -5
View File
@@ -57,8 +57,8 @@ void cmComputeComponentGraph::TarjanVisit(int i)
// Follow outgoing edges.
EdgeList const& nl = this->InputGraph[i];
for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int j = *ni;
for (cmGraphEdge const& ni : nl) {
int j = ni;
// Ignore edges to nodes that have been reached by a previous DFS
// walk. Since we did not reach the current node from that walk
@@ -119,14 +119,14 @@ void cmComputeComponentGraph::TransferEdges()
for (int i = 0; i < n; ++i) {
int i_component = this->TarjanComponents[i];
EdgeList const& nl = this->InputGraph[i];
for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int j = *ni;
for (cmGraphEdge const& ni : nl) {
int j = ni;
int j_component = this->TarjanComponents[j];
if (i_component != j_component) {
// We do not attempt to combine duplicate edges, but instead
// store the inter-component edges with suitable multiplicity.
this->ComponentGraph[i_component].push_back(
cmGraphEdge(j_component, ni->IsStrong()));
cmGraphEdge(j_component, ni.IsStrong()));
}
}
}
Source/cmComputeLinkDepends.cxx
+39 -52
View File
@@ -357,10 +357,8 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry qe)
this->FollowSharedDeps(depender_index, iface);
// Support for CMP0003.
for (std::vector<cmLinkItem>::const_iterator oi =
iface->WrongConfigLibraries.begin();
oi != iface->WrongConfigLibraries.end(); ++oi) {
this->CheckWrongConfigItem(*oi);
for (cmLinkItem const& oi : iface->WrongConfigLibraries) {
this->CheckWrongConfigItem(oi);
}
}
} else {
@@ -385,10 +383,9 @@ void cmComputeLinkDepends::FollowSharedDeps(int depender_index,
void cmComputeLinkDepends::QueueSharedDependencies(
int depender_index, std::vector<cmLinkItem> const& deps)
{
for (std::vector<cmLinkItem>::const_iterator li = deps.begin();
li != deps.end(); ++li) {
for (cmLinkItem const& li : deps) {
SharedDepEntry qe;
qe.Item = *li;
qe.Item = li;
qe.DependerIndex = depender_index;
this->SharedDepQueue.push(qe);
}
@@ -445,25 +442,24 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
std::vector<cmLinkItem> actual_libs;
cmTargetLinkLibraryType llt = GENERAL_LibraryType;
bool haveLLT = false;
for (std::vector<std::string>::const_iterator di = deplist.begin();
di != deplist.end(); ++di) {
if (*di == "debug") {
for (std::string const& d : deplist) {
if (d == "debug") {
llt = DEBUG_LibraryType;
haveLLT = true;
} else if (*di == "optimized") {
} else if (d == "optimized") {
llt = OPTIMIZED_LibraryType;
haveLLT = true;
} else if (*di == "general") {
} else if (d == "general") {
llt = GENERAL_LibraryType;
haveLLT = true;
} else if (!di->empty()) {
} else if (!d.empty()) {
// If no explicit link type was given prior to this entry then
// check if the entry has its own link type variable. This is
// needed for compatibility with dependency files generated by
// the export_library_dependencies command from CMake 2.4 and
// lower.
if (!haveLLT) {
std::string var = *di;
std::string var = d;
var += "_LINK_TYPE";
if (const char* val = this->Makefile->GetDefinition(var)) {
if (strcmp(val, "debug") == 0) {
@@ -476,10 +472,10 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
// If the library is meant for this link type then use it.
if (llt == GENERAL_LibraryType || llt == this->LinkType) {
cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
cmLinkItem item(d, this->FindTargetToLink(depender_index, d));
actual_libs.push_back(item);
} else if (this->OldLinkDirMode) {
cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
cmLinkItem item(d, this->FindTargetToLink(depender_index, d));
this->CheckWrongConfigItem(item);
}
@@ -499,10 +495,8 @@ void cmComputeLinkDepends::AddDirectLinkEntries()
cmLinkImplementation const* impl =
this->Target->GetLinkImplementation(this->Config);
this->AddLinkEntries(-1, impl->Libraries);
for (std::vector<cmLinkItem>::const_iterator wi =
impl->WrongConfigLibraries.begin();
wi != impl->WrongConfigLibraries.end(); ++wi) {
this->CheckWrongConfigItem(*wi);
for (cmLinkItem const& wi : impl->WrongConfigLibraries) {
this->CheckWrongConfigItem(wi);
}
}
@@ -514,17 +508,16 @@ void cmComputeLinkDepends::AddLinkEntries(int depender_index,
std::map<int, DependSet> dependSets;
// Loop over the libraries linked directly by the depender.
for (typename std::vector<T>::const_iterator li = libs.begin();
li != libs.end(); ++li) {
for (T const& l : libs) {
// Skip entries that will resolve to the target getting linked or
// are empty.
cmLinkItem const& item = *li;
cmLinkItem const& item = l;
if (item == this->Target->GetName() || item.empty()) {
continue;
}
// Add a link entry for this item.
int dependee_index = this->AddLinkEntry(*li);
int dependee_index = this->AddLinkEntry(l);
// The dependee must come after the depender.
if (depender_index >= 0) {
@@ -535,16 +528,15 @@ void cmComputeLinkDepends::AddLinkEntries(int depender_index,
}
// Update the inferred dependencies for earlier items.
for (std::map<int, DependSet>::iterator dsi = dependSets.begin();
dsi != dependSets.end(); ++dsi) {
for (auto& dependSet : dependSets) {
// Add this item to the inferred dependencies of other items.
// Target items are never inferred dependees because unknown
// items are outside libraries that should not be depending on
// targets.
if (!this->EntryList[dependee_index].Target &&
!this->EntryList[dependee_index].IsFlag &&
dependee_index != dsi->first) {
dsi->second.insert(dependee_index);
dependee_index != dependSet.first) {
dependSet.second.insert(dependee_index);
}
}
@@ -556,9 +548,8 @@ void cmComputeLinkDepends::AddLinkEntries(int depender_index,
}
// Store the inferred dependency sets discovered for this list.
for (std::map<int, DependSet>::iterator dsi = dependSets.begin();
dsi != dependSets.end(); ++dsi) {
this->InferredDependSets[dsi->first]->push_back(dsi->second);
for (auto const& dependSet : dependSets) {
this->InferredDependSets[dependSet.first]->push_back(dependSet.second);
}
}
@@ -608,14 +599,14 @@ void cmComputeLinkDepends::InferDependencies()
void cmComputeLinkDepends::CleanConstraintGraph()
{
for (Graph::iterator i = this->EntryConstraintGraph.begin();
i != this->EntryConstraintGraph.end(); ++i) {
for (cmGraphEdgeList& edgeList : this->EntryConstraintGraph) {
// Sort the outgoing edges for each graph node so that the
// original order will be preserved as much as possible.
std::sort(i->begin(), i->end());
std::sort(edgeList.begin(), edgeList.end());
// Make the edge list unique.
i->erase(std::unique(i->begin(), i->end()), i->end());
edgeList.erase(std::unique(edgeList.begin(), edgeList.end()),
edgeList.end());
}
}
@@ -660,9 +651,8 @@ void cmComputeLinkDepends::OrderLinkEntires()
}
// Start with the original link line.
for (std::vector<int>::const_iterator i = this->OriginalEntries.begin();
i != this->OriginalEntries.end(); ++i) {
this->VisitEntry(*i);
for (int originalEntry : this->OriginalEntries) {
this->VisitEntry(originalEntry);
}
// Now explore anything left pending. Since the component graph is
@@ -684,13 +674,12 @@ void cmComputeLinkDepends::DisplayComponents()
for (unsigned int c = 0; c < components.size(); ++c) {
fprintf(stderr, "Component (%u):\n", c);
NodeList const& nl = components[c];
for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int i = *ni;
for (int i : nl) {
fprintf(stderr, " item %d [%s]\n", i, this->EntryList[i].Item.c_str());
}
EdgeList const& ol = this->CCG->GetComponentGraphEdges(c);
for (EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi) {
int i = *oi;
for (cmGraphEdge const& oi : ol) {
int i = oi;
fprintf(stderr, " followed by Component (%d)\n", i);
}
fprintf(stderr, " topo order index %d\n", this->ComponentOrder[c]);
@@ -771,10 +760,10 @@ void cmComputeLinkDepends::VisitEntry(int index)
// are now pending.
if (completed) {
EdgeList const& ol = this->CCG->GetComponentGraphEdges(component);
for (EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi) {
for (cmGraphEdge const& oi : ol) {
// This entire component is now pending no matter whether it has
// been partially seen already.
this->MakePendingComponent(*oi);
this->MakePendingComponent(oi);
}
}
}
@@ -816,8 +805,8 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
{
unsigned int count = 2;
for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
if (cmGeneratorTarget const* target = this->EntryList[*ni].Target) {
for (int ni : nl) {
if (cmGeneratorTarget const* target = this->EntryList[ni].Target) {
if (cmLinkInterface const* iface =
target->GetLinkInterface(this->Config, this->Target)) {
if (iface->Multiplicity > count) {
@@ -832,13 +821,11 @@ int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
void cmComputeLinkDepends::DisplayFinalEntries()
{
fprintf(stderr, "target [%s] links to:\n", this->Target->GetName().c_str());
for (std::vector<LinkEntry>::const_iterator lei =
this->FinalLinkEntries.begin();
lei != this->FinalLinkEntries.end(); ++lei) {
if (lei->Target) {
fprintf(stderr, " target [%s]\n", lei->Target->GetName().c_str());
for (LinkEntry const& lei : this->FinalLinkEntries) {
if (lei.Target) {
fprintf(stderr, " target [%s]\n", lei.Target->GetName().c_str());
} else {
fprintf(stderr, " item [%s]\n", lei->Item.c_str());
fprintf(stderr, " item [%s]\n", lei.Item.c_str());
}
}
fprintf(stderr, "\n");
Source/cmComputeLinkInformation.cxx
+44 -67
View File
@@ -468,13 +468,11 @@ bool cmComputeLinkInformation::Compute()
cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();
// Add the link line items.
for (cmComputeLinkDepends::EntryVector::const_iterator lei =
linkEntries.begin();
lei != linkEntries.end(); ++lei) {
if (lei->IsSharedDep) {
this->AddSharedDepItem(lei->Item, lei->Target);
for (cmComputeLinkDepends::LinkEntry const& linkEntry : linkEntries) {
if (linkEntry.IsSharedDep) {
this->AddSharedDepItem(linkEntry.Item, linkEntry.Target);
} else {
this->AddItem(lei->Item, lei->Target);
this->AddItem(linkEntry.Item, linkEntry.Target);
}
}
@@ -494,10 +492,7 @@ bool cmComputeLinkInformation::Compute()
// directories.
std::set<cmGeneratorTarget const*> const& wrongItems =
cld.GetOldWrongConfigItems();
for (std::set<cmGeneratorTarget const*>::const_iterator i =
wrongItems.begin();
i != wrongItems.end(); ++i) {
cmGeneratorTarget const* tgt = *i;
for (cmGeneratorTarget const* tgt : wrongItems) {
bool implib = (this->UseImportLibrary &&
(tgt->GetType() == cmStateEnums::SHARED_LIBRARY));
cmStateEnums::ArtifactType artifact = implib
@@ -540,11 +535,10 @@ void cmComputeLinkInformation::AddImplicitLinkInfo()
// The link closure lists all languages whose implicit info is needed.
cmGeneratorTarget::LinkClosure const* lc =
this->Target->GetLinkClosure(this->Config);
for (std::vector<std::string>::const_iterator li = lc->Languages.begin();
li != lc->Languages.end(); ++li) {
for (std::string const& li : lc->Languages) {
// Skip those of the linker language. They are implicit.
if (*li != this->LinkLanguage) {
this->AddImplicitLinkInfo(*li);
if (li != this->LinkLanguage) {
this->AddImplicitLinkInfo(li);
}
}
}
@@ -559,10 +553,9 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
if (const char* libs = this->Makefile->GetDefinition(libVar)) {
std::vector<std::string> libsVec;
cmSystemTools::ExpandListArgument(libs, libsVec);
for (std::vector<std::string>::const_iterator i = libsVec.begin();
i != libsVec.end(); ++i) {
if (this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end()) {
this->AddItem(*i, nullptr);
for (std::string const& i : libsVec) {
if (this->ImplicitLinkLibs.find(i) == this->ImplicitLinkLibs.end()) {
this->AddItem(i, nullptr);
}
}
}
@@ -811,18 +804,16 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) {
std::vector<std::string> linkSuffixVec;
cmSystemTools::ExpandListArgument(linkSuffixes, linkSuffixVec);
for (std::vector<std::string>::iterator i = linkSuffixVec.begin();
i != linkSuffixVec.end(); ++i) {
this->AddLinkExtension(i->c_str(), LinkUnknown);
for (std::string const& i : linkSuffixVec) {
this->AddLinkExtension(i.c_str(), LinkUnknown);
}
}
if (const char* sharedSuffixes =
mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) {
std::vector<std::string> sharedSuffixVec;
cmSystemTools::ExpandListArgument(sharedSuffixes, sharedSuffixVec);
for (std::vector<std::string>::iterator i = sharedSuffixVec.begin();
i != sharedSuffixVec.end(); ++i) {
this->AddLinkExtension(i->c_str(), LinkShared);
for (std::string const& i : sharedSuffixVec) {
this->AddLinkExtension(i.c_str(), LinkShared);
}
}
@@ -840,9 +831,8 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
// be the library name. Match index 3 will be the library
// extension.
reg = "^(";
for (std::set<std::string>::iterator p = this->LinkPrefixes.begin();
p != this->LinkPrefixes.end(); ++p) {
reg += *p;
for (std::string const& p : this->LinkPrefixes) {
reg += p;
reg += "|";
}
reg += ")";
@@ -906,8 +896,7 @@ std::string cmComputeLinkInformation::CreateExtensionRegex(
// Build a list of extension choices.
std::string libext = "(";
const char* sep = "";
for (std::vector<std::string>::const_iterator i = exts.begin();
i != exts.end(); ++i) {
for (std::string const& i : exts) {
// Separate this choice from the previous one.
libext += sep;
sep = "|";
@@ -915,9 +904,9 @@ std::string cmComputeLinkInformation::CreateExtensionRegex(
// Store this extension choice with the "." escaped.
libext += "\\";
#if defined(_WIN32) && !defined(__CYGWIN__)
libext += this->NoCaseExpression(i->c_str());
libext += this->NoCaseExpression(i.c_str());
#else
libext += *i;
libext += i;
#endif
}
@@ -1457,10 +1446,8 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
}
// Add the link directories for full path items.
for (std::vector<std::string>::const_iterator i =
this->OldLinkDirItems.begin();
i != this->OldLinkDirItems.end(); ++i) {
this->OrderLinkerSearchPath->AddLinkLibrary(*i);
for (std::string const& i : this->OldLinkDirItems) {
this->OrderLinkerSearchPath->AddLinkLibrary(i);
}
return true;
}
@@ -1489,19 +1476,17 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
std::string::size_type max_size = 76;
std::string line;
const char* sep = " ";
for (std::vector<std::string>::const_iterator i =
this->OldUserFlagItems.begin();
i != this->OldUserFlagItems.end(); ++i) {
for (std::string const& i : this->OldUserFlagItems) {
// If the addition of another item will exceed the limit then
// output the current line and reset it. Note that the separator
// is either " " or ", " which is always 2 characters.
if (!line.empty() && (line.size() + i->size() + 2) > max_size) {
if (!line.empty() && (line.size() + i.size() + 2) > max_size) {
os << line << "\n";
sep = " ";
line = "";
}
line += sep;
line += *i;
line += i;
// Convert to the other separator.
sep = ", ";
}
@@ -1513,11 +1498,9 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
// List the paths old behavior is adding.
os << "and other libraries with known full path:\n";
std::set<std::string> emitted;
for (std::vector<std::string>::const_iterator i =
this->OldLinkDirItems.begin();
i != this->OldLinkDirItems.end(); ++i) {
if (emitted.insert(cmSystemTools::GetFilenamePath(*i)).second) {
os << " " << *i << "\n";
for (std::string const& i : this->OldLinkDirItems) {
if (emitted.insert(cmSystemTools::GetFilenamePath(i)).second) {
os << " " << i << "\n";
}
}
@@ -1544,9 +1527,8 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
// and add them to the set
if (const char* libraryArch =
this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
for (std::vector<std::string>::const_iterator i = implicitDirVec.begin();
i != implicitDirVec.end(); ++i) {
this->ImplicitLinkDirs.insert(*i + "/" + libraryArch);
for (std::string const& i : implicitDirVec) {
this->ImplicitLinkDirs.insert(i + "/" + libraryArch);
}
}
@@ -1573,11 +1555,9 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
}
// Store implicit link libraries.
for (std::vector<std::string>::const_iterator i = implicitLibVec.begin();
i != implicitLibVec.end(); ++i) {
for (std::string const& item : implicitLibVec) {
// Items starting in '-' but not '-l' are flags, not libraries,
// and should not be filtered by this implicit list.
std::string const& item = *i;
if (item[0] != '-' || item[1] == 'l') {
this->ImplicitLinkLibs.insert(item);
}
@@ -1694,10 +1674,9 @@ static void cmCLI_ExpandListUnique(const char* str,
{
std::vector<std::string> tmp;
cmSystemTools::ExpandListArgument(str, tmp);
for (std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end();
++i) {
if (emitted.insert(*i).second) {
out.push_back(*i);
for (std::string const& i : tmp) {
if (emitted.insert(i).second) {
out.push_back(i);
}
}
}
@@ -1750,12 +1729,11 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
cmSystemTools::ConvertToUnixSlashes(rootPath);
std::vector<std::string> const& rdirs = this->GetRuntimeSearchPath();
for (std::vector<std::string>::const_iterator ri = rdirs.begin();
ri != rdirs.end(); ++ri) {
for (std::string const& ri : rdirs) {
// Put this directory in the rpath if using build-tree rpath
// support or if using the link path as an rpath.
if (use_build_rpath) {
std::string d = *ri;
std::string d = ri;
if (!rootPath.empty() && d.find(rootPath) == 0) {
d = d.substr(rootPath.size());
} else if (stagePath && *stagePath && d.find(stagePath) == 0) {
@@ -1773,11 +1751,11 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
const char* topSourceDir = this->CMakeInstance->GetHomeDirectory();
const char* topBinaryDir =
this->CMakeInstance->GetHomeOutputDirectory();
if (!cmSystemTools::ComparePath(*ri, topSourceDir) &&
!cmSystemTools::ComparePath(*ri, topBinaryDir) &&
!cmSystemTools::IsSubDirectory(*ri, topSourceDir) &&
!cmSystemTools::IsSubDirectory(*ri, topBinaryDir)) {
std::string d = *ri;
if (!cmSystemTools::ComparePath(ri, topSourceDir) &&
!cmSystemTools::ComparePath(ri, topBinaryDir) &&
!cmSystemTools::IsSubDirectory(ri, topSourceDir) &&
!cmSystemTools::IsSubDirectory(ri, topBinaryDir)) {
std::string d = ri;
if (!rootPath.empty() && d.find(rootPath) == 0) {
d = d.substr(rootPath.size());
} else if (stagePath && *stagePath && d.find(stagePath) == 0) {
@@ -1800,12 +1778,11 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
{
cmGeneratorTarget::LinkClosure const* lc =
this->Target->GetLinkClosure(this->Config);
for (std::vector<std::string>::const_iterator li = lc->Languages.begin();
li != lc->Languages.end(); ++li) {
for (std::string const& li : lc->Languages) {
std::string useVar =
"CMAKE_" + *li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
"CMAKE_" + li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
if (this->Makefile->IsOn(useVar)) {
std::string dirVar = "CMAKE_" + *li + "_IMPLICIT_LINK_DIRECTORIES";
std::string dirVar = "CMAKE_" + li + "_IMPLICIT_LINK_DIRECTORIES";
if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted);
}
Source/cmComputeTargetDepends.cxx
+42 -55
View File
@@ -148,10 +148,10 @@ void cmComputeTargetDepends::GetTargetDirectDepends(cmGeneratorTarget const* t,
// Get its final dependencies.
EdgeList const& nl = this->FinalGraph[i];
for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
cmGeneratorTarget const* dep = this->Targets[*ni];
for (cmGraphEdge const& ni : nl) {
cmGeneratorTarget const* dep = this->Targets[ni];
cmTargetDependSet::iterator di = deps.insert(dep).first;
di->SetType(ni->IsStrong());
di->SetType(ni.IsStrong());
}
}
@@ -160,15 +160,13 @@ void cmComputeTargetDepends::CollectTargets()
// Collect all targets from all generators.
std::vector<cmLocalGenerator*> const& lgens =
this->GlobalGenerator->GetLocalGenerators();
for (unsigned int i = 0; i < lgens.size(); ++i) {
for (cmLocalGenerator* lgen : lgens) {
const std::vector<cmGeneratorTarget*>& targets =
lgens[i]->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti) {
cmGeneratorTarget* gt = *ti;
lgen->GetGeneratorTargets();
for (cmGeneratorTarget const* ti : targets) {
int index = static_cast<int>(this->Targets.size());
this->TargetIndex[gt] = index;
this->Targets.push_back(gt);
this->TargetIndex[ti] = index;
this->Targets.push_back(ti);
}
}
}
@@ -204,14 +202,11 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
if (configs.empty()) {
configs.push_back("");
}
for (std::vector<std::string>::const_iterator it = configs.begin();
it != configs.end(); ++it) {
for (std::string const& it : configs) {
std::vector<cmSourceFile const*> objectFiles;
depender->GetExternalObjects(objectFiles, *it);
for (std::vector<cmSourceFile const*>::const_iterator oi =
objectFiles.begin();
oi != objectFiles.end(); ++oi) {
std::string objLib = (*oi)->GetObjectLibrary();
depender->GetExternalObjects(objectFiles, it);
for (cmSourceFile const* o : objectFiles) {
std::string objLib = o->GetObjectLibrary();
if (!objLib.empty() && emitted.insert(objLib).second) {
if (depender->GetType() != cmStateEnums::EXECUTABLE &&
depender->GetType() != cmStateEnums::STATIC_LIBRARY &&
@@ -228,17 +223,15 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
}
}
cmLinkImplementation const* impl = depender->GetLinkImplementation(*it);
cmLinkImplementation const* impl = depender->GetLinkImplementation(it);
// A target should not depend on itself.
emitted.insert(depender->GetName());
for (std::vector<cmLinkImplItem>::const_iterator lib =
impl->Libraries.begin();
lib != impl->Libraries.end(); ++lib) {
for (cmLinkImplItem const& lib : impl->Libraries) {
// Don't emit the same library twice for this target.
if (emitted.insert(*lib).second) {
this->AddTargetDepend(depender_index, *lib, true);
this->AddInterfaceDepends(depender_index, *lib, *it, emitted);
if (emitted.insert(lib).second) {
this->AddTargetDepend(depender_index, lib, true);
this->AddInterfaceDepends(depender_index, lib, it, emitted);
}
}
}
@@ -250,11 +243,10 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
std::set<std::string> emitted;
// A target should not depend on itself.
emitted.insert(depender->GetName());
for (std::set<cmLinkItem>::const_iterator util = tutils.begin();
util != tutils.end(); ++util) {
for (cmLinkItem const& litem : tutils) {
// Don't emit the same utility twice for this target.
if (emitted.insert(*util).second) {
this->AddTargetDepend(depender_index, *util, false);
if (emitted.insert(litem).second) {
this->AddTargetDepend(depender_index, litem, false);
}
}
}
@@ -267,13 +259,11 @@ void cmComputeTargetDepends::AddInterfaceDepends(
cmGeneratorTarget const* depender = this->Targets[depender_index];
if (cmLinkInterface const* iface =
dependee->GetLinkInterface(config, depender)) {
for (std::vector<cmLinkItem>::const_iterator lib =
iface->Libraries.begin();
lib != iface->Libraries.end(); ++lib) {
for (cmLinkItem const& lib : iface->Libraries) {
// Don't emit the same library twice for this target.
if (emitted.insert(*lib).second) {
this->AddTargetDepend(depender_index, *lib, true);
this->AddInterfaceDepends(depender_index, *lib, config, emitted);
if (emitted.insert(lib).second) {
this->AddTargetDepend(depender_index, lib, true);
this->AddInterfaceDepends(depender_index, lib, config, emitted);
}
}
}
@@ -365,9 +355,8 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
// Skip IMPORTED and INTERFACE targets but follow their utility
// dependencies.
std::set<cmLinkItem> const& utils = dependee->GetUtilityItems();
for (std::set<cmLinkItem>::const_iterator i = utils.begin();
i != utils.end(); ++i) {
if (cmGeneratorTarget const* transitive_dependee = i->Target) {
for (cmLinkItem const& i : utils) {
if (cmGeneratorTarget const* transitive_dependee = i.Target) {
this->AddTargetDepend(depender_index, transitive_dependee, false);
}
}
@@ -395,11 +384,11 @@ void cmComputeTargetDepends::DisplayGraph(Graph const& graph,
cmGeneratorTarget const* depender = this->Targets[depender_index];
fprintf(stderr, "target %d is [%s]\n", depender_index,
depender->GetName().c_str());
for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int dependee_index = *ni;
for (cmGraphEdge const& ni : nl) {
int dependee_index = ni;
cmGeneratorTarget const* dependee = this->Targets[dependee_index];
fprintf(stderr, " depends on target %d [%s] (%s)\n", dependee_index,
dependee->GetName().c_str(), ni->IsStrong() ? "strong" : "weak");
dependee->GetName().c_str(), ni.IsStrong() ? "strong" : "weak");
}
}
fprintf(stderr, "\n");
@@ -414,8 +403,7 @@ void cmComputeTargetDepends::DisplayComponents(
for (int c = 0; c < n; ++c) {
NodeList const& nl = components[c];
fprintf(stderr, "Component (%d):\n", c);
for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int i = *ni;
for (int i : nl) {
fprintf(stderr, " contains target %d [%s]\n", i,
this->Targets[i]->GetName().c_str());
}
@@ -446,8 +434,8 @@ bool cmComputeTargetDepends::CheckComponents(
}
// Make sure the component is all STATIC_LIBRARY targets.
for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
if (this->Targets[*ni]->GetType() != cmStateEnums::STATIC_LIBRARY) {
for (int ni : nl) {
if (this->Targets[ni]->GetType() != cmStateEnums::STATIC_LIBRARY) {
this->ComplainAboutBadComponent(ccg, c);
return false;
}
@@ -466,9 +454,8 @@ void cmComputeTargetDepends::ComplainAboutBadComponent(
std::vector<NodeList> const& components = ccg.GetComponents();
std::vector<int> const& cmap = ccg.GetComponentMap();
NodeList const& cl = components[c];
for (NodeList::const_iterator ci = cl.begin(); ci != cl.end(); ++ci) {
for (int i : cl) {
// Get the depender.
int i = *ci;
cmGeneratorTarget const* depender = this->Targets[i];
// Describe the depender.
@@ -477,12 +464,12 @@ void cmComputeTargetDepends::ComplainAboutBadComponent(
// List its dependencies that are inside the component.
EdgeList const& nl = this->InitialGraph[i];
for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int j = *ni;
for (cmGraphEdge const& ni : nl) {
int j = ni;
if (cmap[j] == c) {
cmGeneratorTarget const* dependee = this->Targets[j];
e << " depends on \"" << dependee->GetName() << "\""
<< " (" << (ni->IsStrong() ? "strong" : "weak") << ")\n";
<< " (" << (ni.IsStrong() ? "strong" : "weak") << ")\n";
}
}
}
@@ -514,9 +501,9 @@ bool cmComputeTargetDepends::IntraComponent(std::vector<int> const& cmap,
if (emitted.insert(i).second) {
// Honor strong intra-component edges in the final order.
EdgeList const& el = this->InitialGraph[i];
for (EdgeList::const_iterator ei = el.begin(); ei != el.end(); ++ei) {
int j = *ei;
if (cmap[j] == c && ei->IsStrong()) {
for (cmGraphEdge const& edge : el) {
int j = edge;
if (cmap[j] == c && edge.IsStrong()) {
this->FinalGraph[i].push_back(cmGraphEdge(j, true));
if (!this->IntraComponent(cmap, c, j, head, emitted, visited)) {
return false;
@@ -573,11 +560,11 @@ bool cmComputeTargetDepends::ComputeFinalDepends(
++depender_component) {
int depender_component_tail = this->ComponentTail[depender_component];
EdgeList const& nl = cgraph[depender_component];
for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
int dependee_component = *ni;
for (cmGraphEdge const& ni : nl) {
int dependee_component = ni;
int dependee_component_head = this->ComponentHead[dependee_component];
this->FinalGraph[depender_component_tail].push_back(
cmGraphEdge(dependee_component_head, ni->IsStrong()));
cmGraphEdge(dependee_component_head, ni.IsStrong()));
}
}
return true;
Source/cmCoreTryCompile.cxx
+21 -30
View File
@@ -417,16 +417,15 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
// Detect languages to enable.
cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
std::set<std::string> testLangs;
for (std::vector<std::string>::iterator si = sources.begin();
si != sources.end(); ++si) {
std::string ext = cmSystemTools::GetFilenameLastExtension(*si);
for (std::string const& si : sources) {
std::string ext = cmSystemTools::GetFilenameLastExtension(si);
std::string lang = gg->GetLanguageFromExtension(ext.c_str());
if (!lang.empty()) {
testLangs.insert(lang);
} else {
std::ostringstream err;
err << "Unknown extension \"" << ext << "\" for file\n"
<< " " << *si << "\n"
<< " " << si << "\n"
<< "try_compile() works only for enabled languages. "
<< "Currently these are:\n ";
std::vector<std::string> langs;
@@ -467,11 +466,10 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
}
std::string projectLangs;
for (std::set<std::string>::iterator li = testLangs.begin();
li != testLangs.end(); ++li) {
projectLangs += " " + *li;
for (std::string const& li : testLangs) {
projectLangs += " " + li;
std::string rulesOverrideBase = "CMAKE_USER_MAKE_RULES_OVERRIDE";
std::string rulesOverrideLang = rulesOverrideBase + "_" + *li;
std::string rulesOverrideLang = rulesOverrideBase + "_" + li;
if (const char* rulesOverridePath =
this->Makefile->GetDefinition(rulesOverrideLang)) {
fprintf(fout, "set(%s \"%s\")\n", rulesOverrideLang.c_str(),
@@ -484,15 +482,14 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
}
fprintf(fout, "project(CMAKE_TRY_COMPILE%s)\n", projectLangs.c_str());
fprintf(fout, "set(CMAKE_VERBOSE_MAKEFILE 1)\n");
for (std::set<std::string>::iterator li = testLangs.begin();
li != testLangs.end(); ++li) {
std::string langFlags = "CMAKE_" + *li + "_FLAGS";
for (std::string const& li : testLangs) {
std::string langFlags = "CMAKE_" + li + "_FLAGS";
const char* flags = this->Makefile->GetDefinition(langFlags);
fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li->c_str(),
fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li.c_str(),
cmOutputConverter::EscapeForCMake(flags ? flags : "").c_str());
fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
" ${COMPILE_DEFINITIONS}\")\n",
li->c_str(), li->c_str());
li.c_str(), li.c_str());
}
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0066)) {
case cmPolicies::WARN:
@@ -522,9 +519,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
static std::string const cfgDefault = "DEBUG";
std::string const cfg =
!tcConfig.empty() ? cmSystemTools::UpperCase(tcConfig) : cfgDefault;
for (std::set<std::string>::iterator li = testLangs.begin();
li != testLangs.end(); ++li) {
std::string const langFlagsCfg = "CMAKE_" + *li + "_FLAGS_" + cfg;
for (std::string const& li : testLangs) {
std::string const langFlagsCfg = "CMAKE_" + li + "_FLAGS_" + cfg;
const char* flagsCfg = this->Makefile->GetDefinition(langFlagsCfg);
fprintf(fout, "set(%s %s)\n", langFlagsCfg.c_str(),
cmOutputConverter::EscapeForCMake(flagsCfg ? flagsCfg : "")
@@ -638,9 +634,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
cmakeFlags.push_back(flag);
}
for (std::set<std::string>::iterator vi = vars.begin(); vi != vars.end();
++vi) {
std::string const& var = *vi;
for (std::string const& var : vars) {
if (const char* val = this->Makefile->GetDefinition(var)) {
std::string flag = "-D" + var + "=" + val;
cmakeFlags.push_back(flag);
@@ -669,13 +663,12 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
/* Create the actual static library. */
fprintf(fout, "add_library(%s STATIC", targetName.c_str());
}
for (std::vector<std::string>::iterator si = sources.begin();
si != sources.end(); ++si) {
fprintf(fout, " \"%s\"", si->c_str());
for (std::string const& si : sources) {
fprintf(fout, " \"%s\"", si.c_str());
// Add dependencies on any non-temporary sources.
if (si->find("CMakeTmp") == std::string::npos) {
this->Makefile->AddCMakeDependFile(*si);
if (si.find("CMakeTmp") == std::string::npos) {
this->Makefile->AddCMakeDependFile(si);
}
}
fprintf(fout, ")\n");
@@ -762,9 +755,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
"is not honoring language standard variables in the test project:\n"
;
/* clang-format on */
for (std::vector<std::string>::iterator vi = this->WarnCMP0067.begin();
vi != this->WarnCMP0067.end(); ++vi) {
w << " " << *vi << "\n";
for (std::string const& vi : this->WarnCMP0067) {
w << " " << vi << "\n";
}
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
@@ -963,10 +955,9 @@ void cmCoreTryCompile::FindOutputFile(const std::string& targetName,
#endif
searchDirs.push_back("/Development");
for (std::vector<std::string>::const_iterator it = searchDirs.begin();
it != searchDirs.end(); ++it) {
for (std::string const& sdir : searchDirs) {
std::string command = this->BinaryDirectory;
command += *it;
command += sdir;
command += tmpOutputFile;
if (cmSystemTools::FileExists(command.c_str())) {
this->OutputFile = cmSystemTools::CollapseFullPath(command);
Source/cmCryptoHash.cxx
+3 -4
View File
@@ -103,10 +103,9 @@ std::string cmCryptoHash::ByteHashToString(
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
std::string res;
for (std::vector<unsigned char>::const_iterator vit = hash.begin();
vit != hash.end(); ++vit) {
res.push_back(hex[(*vit) >> 4]);
res.push_back(hex[(*vit) & 0xF]);
for (unsigned char v : hash) {
res.push_back(hex[v >> 4]);
res.push_back(hex[v & 0xF]);
}
return res;
}
Source/cmCustomCommandGenerator.cxx
+8 -12
View File
@@ -26,12 +26,10 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
, GE(new cmGeneratorExpression(cc.GetBacktrace()))
{
const cmCustomCommandLines& cmdlines = this->CC.GetCommandLines();
for (cmCustomCommandLines::const_iterator cmdline = cmdlines.begin();
cmdline != cmdlines.end(); ++cmdline) {
for (cmCustomCommandLine const& cmdline : cmdlines) {
cmCustomCommandLine argv;
for (cmCustomCommandLine::const_iterator clarg = cmdline->begin();
clarg != cmdline->end(); ++clarg) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(*clarg);
for (std::string const& clarg : cmdline) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(clarg);
std::string parsed_arg = cge->Evaluate(this->LG, this->Config);
if (this->CC.GetCommandExpandLists()) {
std::vector<std::string> ExpandedArg;
@@ -45,16 +43,14 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
}
std::vector<std::string> depends = this->CC.GetDepends();
for (std::vector<std::string>::const_iterator i = depends.begin();
i != depends.end(); ++i) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(*i);
for (std::string const& d : depends) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(d);
std::vector<std::string> result;
cmSystemTools::ExpandListArgument(cge->Evaluate(this->LG, this->Config),
result);
for (std::vector<std::string>::iterator it = result.begin();
it != result.end(); ++it) {
if (cmSystemTools::FileIsFullPath(it->c_str())) {
*it = cmSystemTools::CollapseFullPath(*it);
for (std::string& it : result) {
if (cmSystemTools::FileIsFullPath(it.c_str())) {
it = cmSystemTools::CollapseFullPath(it);
}
}
this->Depends.insert(this->Depends.end(), result.begin(), result.end());
Source/cmDefinitions.cxx
+12 -15
View File
@@ -66,10 +66,9 @@ std::vector<std::string> cmDefinitions::UnusedKeys() const
std::vector<std::string> keys;
keys.reserve(this->Map.size());
// Consider local definitions.
for (MapType::const_iterator mi = this->Map.begin(); mi != this->Map.end();
++mi) {
if (!mi->second.Used) {
keys.push_back(mi->first);
for (auto const& mi : this->Map) {
if (!mi.second.Used) {
keys.push_back(mi.first);
}
}
return keys;
@@ -81,15 +80,14 @@ cmDefinitions cmDefinitions::MakeClosure(StackIter begin, StackIter end)
std::set<std::string> undefined;
for (StackIter it = begin; it != end; ++it) {
// Consider local definitions.
for (MapType::const_iterator mi = it->Map.begin(); mi != it->Map.end();
++mi) {
for (auto const& mi : it->Map) {
// Use this key if it is not already set or unset.
if (closure.Map.find(mi->first) == closure.Map.end() &&
undefined.find(mi->first) == undefined.end()) {
if (mi->second.Exists) {
closure.Map.insert(*mi);
if (closure.Map.find(mi.first) == closure.Map.end() &&
undefined.find(mi.first) == undefined.end()) {
if (mi.second.Exists) {
closure.Map.insert(mi);
} else {
undefined.insert(mi->first);
undefined.insert(mi.first);
}
}
}
@@ -105,11 +103,10 @@ std::vector<std::string> cmDefinitions::ClosureKeys(StackIter begin,
for (StackIter it = begin; it != end; ++it) {
defined.reserve(defined.size() + it->Map.size());
for (MapType::const_iterator mi = it->Map.begin(); mi != it->Map.end();
++mi) {
for (auto const& mi : it->Map) {
// Use this key if it is not already set or unset.
if (bound.insert(mi->first).second && mi->second.Exists) {
defined.push_back(mi->first);
if (bound.insert(mi.first).second && mi.second.Exists) {
defined.push_back(mi.first);
}
}
}
Source/cmDepends.cxx
+2 -4
View File
@@ -53,12 +53,10 @@ bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
std::string const& obj = *si++;
dependencies[obj].insert(src);
}
for (std::map<std::string, std::set<std::string>>::const_iterator it =
dependencies.begin();
it != dependencies.end(); ++it) {
for (auto const& d : dependencies) {
// Write the dependencies for this pair.
if (!this->WriteDependencies(it->second, it->first, makeDepends,
if (!this->WriteDependencies(d.second, d.first, makeDepends,
internalDepends)) {
return false;
}
Source/cmDependsC.cxx
+26 -39
View File
@@ -110,12 +110,11 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
int srcFiles = static_cast<int>(sources.size());
this->Encountered.clear();
for (std::set<std::string>::const_iterator srcIt = sources.begin();
srcIt != sources.end(); ++srcIt) {
for (std::string const& src : sources) {
UnscannedEntry root;
root.FileName = *srcIt;
root.FileName = src;
this->Unscanned.push(root);
this->Encountered.insert(*srcIt);
this->Encountered.insert(src);
}
std::set<std::string> scanned;
@@ -150,14 +149,12 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
if (headerLocationIt != this->HeaderLocationCache.end()) {
fullName = headerLocationIt->second;
} else {
for (std::vector<std::string>::const_iterator i =
this->IncludePath.begin();
i != this->IncludePath.end(); ++i) {
for (std::string const& i : this->IncludePath) {
// Construct the name of the file as if it were in the current
// include directory. Avoid using a leading "./".
tempPathStr =
cmSystemTools::CollapseCombinedPath(*i, current.FileName);
cmSystemTools::CollapseCombinedPath(i, current.FileName);
// Look for the file in this location.
if (cmSystemTools::FileExists(tempPathStr.c_str(), true)) {
@@ -189,13 +186,11 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
if (fileIt != this->FileCache.end()) {
fileIt->second->Used = true;
dependencies.insert(fullName);
for (std::vector<UnscannedEntry>::const_iterator incIt =
fileIt->second->UnscannedEntries.begin();
incIt != fileIt->second->UnscannedEntries.end(); ++incIt) {
if (this->Encountered.find(incIt->FileName) ==
for (UnscannedEntry const& inc : fileIt->second->UnscannedEntries) {
if (this->Encountered.find(inc.FileName) ==
this->Encountered.end()) {
this->Encountered.insert(incIt->FileName);
this->Unscanned.push(*incIt);
this->Encountered.insert(inc.FileName);
this->Unscanned.push(inc);
}
}
} else {
@@ -234,14 +229,13 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i.c_str());
internalDepends << obj_i << std::endl;
for (std::set<std::string>::const_iterator i = dependencies.begin();
i != dependencies.end(); ++i) {
for (std::string const& dep : dependencies) {
makeDepends
<< obj_m << ": "
<< cmSystemTools::ConvertToOutputPath(
this->LocalGenerator->ConvertToRelativePath(binDir, *i).c_str())
this->LocalGenerator->ConvertToRelativePath(binDir, dep).c_str())
<< std::endl;
internalDepends << " " << *i << std::endl;
internalDepends << " " << dep << std::endl;
}
makeDepends << std::endl;
@@ -330,20 +324,16 @@ void cmDependsC::WriteCacheFile() const
cacheOut << this->IncludeRegexComplainString << "\n\n";
cacheOut << this->IncludeRegexTransformString << "\n\n";
for (std::map<std::string, cmIncludeLines*>::const_iterator fileIt =
this->FileCache.begin();
fileIt != this->FileCache.end(); ++fileIt) {
if (fileIt->second->Used) {
cacheOut << fileIt->first << std::endl;
for (auto const& fileIt : this->FileCache) {
if (fileIt.second->Used) {
cacheOut << fileIt.first << std::endl;
for (std::vector<UnscannedEntry>::const_iterator incIt =
fileIt->second->UnscannedEntries.begin();
incIt != fileIt->second->UnscannedEntries.end(); ++incIt) {
cacheOut << incIt->FileName << std::endl;
if (incIt->QuotedLocation.empty()) {
for (UnscannedEntry const& inc : fileIt.second->UnscannedEntries) {
cacheOut << inc.FileName << std::endl;
if (inc.QuotedLocation.empty()) {
cacheOut << "-" << std::endl;
} else {
cacheOut << incIt->QuotedLocation << std::endl;
cacheOut << inc.QuotedLocation << std::endl;
}
}
cacheOut << std::endl;
@@ -411,9 +401,8 @@ void cmDependsC::SetupTransforms()
if (const char* xform = mf->GetDefinition("CMAKE_INCLUDE_TRANSFORMS")) {
cmSystemTools::ExpandListArgument(xform, transformRules, true);
}
for (std::vector<std::string>::const_iterator tri = transformRules.begin();
tri != transformRules.end(); ++tri) {
this->ParseTransform(*tri);
for (std::string const& tr : transformRules) {
this->ParseTransform(tr);
}
this->IncludeRegexTransformString = INCLUDE_REGEX_TRANSFORM_MARKER;
@@ -422,10 +411,9 @@ void cmDependsC::SetupTransforms()
// transformed.
std::string xform = "^([ \t]*[#%][ \t]*(include|import)[ \t]*)(";
const char* sep = "";
for (TransformRulesType::const_iterator tri = this->TransformRules.begin();
tri != this->TransformRules.end(); ++tri) {
for (auto const& tr : this->TransformRules) {
xform += sep;
xform += tri->first;
xform += tr.first;
sep = "|";
}
xform += ")[ \t]*\\(([^),]*)\\)";
@@ -434,12 +422,11 @@ void cmDependsC::SetupTransforms()
// Build a string that encodes all transformation rules and will
// change when rules are changed.
this->IncludeRegexTransformString += xform;
for (TransformRulesType::const_iterator tri = this->TransformRules.begin();
tri != this->TransformRules.end(); ++tri) {
for (auto const& tr : this->TransformRules) {
this->IncludeRegexTransformString += " ";
this->IncludeRegexTransformString += tri->first;
this->IncludeRegexTransformString += tr.first;
this->IncludeRegexTransformString += "(%)=";
this->IncludeRegexTransformString += tri->second;
this->IncludeRegexTransformString += tr.second;
}
}
}
Source/cmDependsFortran.cxx
+37 -54
View File
@@ -73,12 +73,10 @@ cmDependsFortran::cmDependsFortran(cmLocalGenerator* lg)
// translate i.e. FOO=BAR to FOO and add it to the list of defined
// preprocessor symbols
for (std::vector<std::string>::const_iterator it = definitions.begin();
it != definitions.end(); ++it) {
std::string def = *it;
for (std::string def : definitions) {
std::string::size_type assignment = def.find('=');
if (assignment != std::string::npos) {
def = it->substr(0, assignment);
def = def.substr(0, assignment);
}
this->PPDefinitions.insert(def);
}
@@ -105,9 +103,7 @@ bool cmDependsFortran::WriteDependencies(const std::set<std::string>& sources,
}
bool okay = true;
for (std::set<std::string>::const_iterator it = sources.begin();
it != sources.end(); ++it) {
const std::string& src = *it;
for (std::string const& src : sources) {
// Get the information object for this source.
cmFortranSourceInfo& info =
this->Internal->CreateObjectInfo(obj.c_str(), src.c_str());
@@ -154,9 +150,8 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
// Actually write dependencies to the streams.
typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap;
ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
for (ObjectInfoMap::const_iterator i = objInfo.begin(); i != objInfo.end();
++i) {
if (!this->WriteDependenciesReal(i->first.c_str(), i->second, mod_dir,
for (auto const& i : objInfo) {
if (!this->WriteDependenciesReal(i.first.c_str(), i.second, mod_dir,
stamp_dir, makeDepends,
internalDepends)) {
return false;
@@ -170,9 +165,8 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
fiStream << "# The fortran modules provided by this target.\n";
fiStream << "provides\n";
std::set<std::string> const& provides = this->Internal->TargetProvides;
for (std::set<std::string>::const_iterator i = provides.begin();
i != provides.end(); ++i) {
fiStream << " " << *i << "\n";
for (std::string const& i : provides) {
fiStream << " " << i << "\n";
}
// Create a script to clean the modules.
@@ -184,19 +178,18 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
fcStream << "FILE(REMOVE";
std::string currentBinDir =
this->LocalGenerator->GetCurrentBinaryDirectory();
for (std::set<std::string>::const_iterator i = provides.begin();
i != provides.end(); ++i) {
for (std::string const& i : provides) {
std::string mod_upper = mod_dir;
mod_upper += "/";
mod_upper += cmSystemTools::UpperCase(*i);
mod_upper += cmSystemTools::UpperCase(i);
mod_upper += ".mod";
std::string mod_lower = mod_dir;
mod_lower += "/";
mod_lower += *i;
mod_lower += i;
mod_lower += ".mod";
std::string stamp = stamp_dir;
stamp += "/";
stamp += *i;
stamp += i;
stamp += ".mod.stamp";
fcStream << "\n";
fcStream << " \""
@@ -219,16 +212,14 @@ void cmDependsFortran::LocateModules()
// Collect the set of modules provided and required by all sources.
typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap;
ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
for (ObjectInfoMap::const_iterator infoI = objInfo.begin();
infoI != objInfo.end(); ++infoI) {
cmFortranSourceInfo const& info = infoI->second;
for (auto const& infoI : objInfo) {
cmFortranSourceInfo const& info = infoI.second;
// Include this module in the set provided by this target.
this->Internal->TargetProvides.insert(info.Provides.begin(),
info.Provides.end());
for (std::set<std::string>::const_iterator i = info.Requires.begin();
i != info.Requires.end(); ++i) {
this->Internal->TargetRequires[*i] = "";
for (std::string const& r : info.Requires) {
this->Internal->TargetRequires[r] = "";
}
}
@@ -247,9 +238,8 @@ void cmDependsFortran::LocateModules()
mf->GetDefinition("CMAKE_TARGET_LINKED_INFO_FILES")) {
cmSystemTools::ExpandListArgument(infoFilesValue, infoFiles);
}
for (std::vector<std::string>::const_iterator i = infoFiles.begin();
i != infoFiles.end(); ++i) {
std::string targetDir = cmSystemTools::GetFilenamePath(*i);
for (std::string const& i : infoFiles) {
std::string targetDir = cmSystemTools::GetFilenamePath(i);
std::string fname = targetDir + "/fortran.internal";
cmsys::ifstream fin(fname.c_str());
if (fin) {
@@ -262,9 +252,8 @@ void cmDependsFortran::MatchLocalModules()
{
const char* stampDir = this->TargetDirectory.c_str();
std::set<std::string> const& provides = this->Internal->TargetProvides;
for (std::set<std::string>::const_iterator i = provides.begin();
i != provides.end(); ++i) {
this->ConsiderModule(i->c_str(), stampDir);
for (std::string const& i : provides) {
this->ConsiderModule(i.c_str(), stampDir);
}
}
@@ -326,35 +315,32 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i.c_str());
internalDepends << obj_i << std::endl;
internalDepends << " " << src << std::endl;
for (std::set<std::string>::const_iterator i = info.Includes.begin();
i != info.Includes.end(); ++i) {
for (std::string const& i : info.Includes) {
makeDepends << obj_m << ": "
<< cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, *i).c_str())
this->MaybeConvertToRelativePath(binDir, i).c_str())
<< std::endl;
internalDepends << " " << *i << std::endl;
internalDepends << " " << i << std::endl;
}
makeDepends << std::endl;
// Write module requirements to the output stream.
for (std::set<std::string>::const_iterator i = info.Requires.begin();
i != info.Requires.end(); ++i) {
for (std::string const& i : info.Requires) {
// Require only modules not provided in the same source.
if (std::set<std::string>::const_iterator(info.Provides.find(*i)) !=
info.Provides.end()) {
if (info.Provides.find(i) != info.Provides.cend()) {
continue;
}
// If the module is provided in this target special handling is
// needed.
if (this->Internal->TargetProvides.find(*i) !=
if (this->Internal->TargetProvides.find(i) !=
this->Internal->TargetProvides.end()) {
// The module is provided by a different source in the same
// target. Add the proxy dependency to make sure the other
// source builds first.
std::string proxy = stamp_dir;
proxy += "/";
proxy += *i;
proxy += i;
proxy += ".mod.proxy";
proxy = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, proxy).c_str());
@@ -366,7 +352,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
// The object file should depend on timestamped files for the
// modules it uses.
TargetRequiresMap::const_iterator required =
this->Internal->TargetRequires.find(*i);
this->Internal->TargetRequires.find(i);
if (required == this->Internal->TargetRequires.end()) {
abort();
}
@@ -379,7 +365,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
// This module is not known to CMake. Try to locate it where
// the compiler will and depend on that.
std::string module;
if (this->FindModule(*i, module)) {
if (this->FindModule(i, module)) {
module = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, module).c_str());
makeDepends << obj_m << ": " << module << "\n";
@@ -388,11 +374,10 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
}
// Write provided modules to the output stream.
for (std::set<std::string>::const_iterator i = info.Provides.begin();
i != info.Provides.end(); ++i) {
for (std::string const& i : info.Provides) {
std::string proxy = stamp_dir;
proxy += "/";
proxy += *i;
proxy += i;
proxy += ".mod.proxy";
proxy = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, proxy).c_str());
@@ -404,18 +389,17 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
// Create a target to copy the module after the object file
// changes.
makeDepends << obj_m << ".provides.build:\n";
for (std::set<std::string>::const_iterator i = info.Provides.begin();
i != info.Provides.end(); ++i) {
for (std::string const& i : info.Provides) {
// Include this module in the set provided by this target.
this->Internal->TargetProvides.insert(*i);
this->Internal->TargetProvides.insert(i);
// Always use lower case for the mod stamp file name. The
// cmake_copy_f90_mod will call back to this class, which will
// try various cases for the real mod file name.
std::string m = cmSystemTools::LowerCase(*i);
std::string m = cmSystemTools::LowerCase(i);
std::string modFile = mod_dir;
modFile += "/";
modFile += *i;
modFile += i;
modFile = this->LocalGenerator->ConvertToOutputFormat(
this->MaybeConvertToRelativePath(binDir, modFile),
cmOutputConverter::SHELL);
@@ -462,10 +446,9 @@ bool cmDependsFortran::FindModule(std::string const& name, std::string& module)
// Search the include path for the module.
std::string fullName;
for (std::vector<std::string>::const_iterator i = this->IncludePath.begin();
i != this->IncludePath.end(); ++i) {
for (std::string const& ip : this->IncludePath) {
// Try the lower-case name.
fullName = *i;
fullName = ip;
fullName += "/";
fullName += mod_lower;
if (cmSystemTools::FileExists(fullName.c_str(), true)) {
@@ -474,7 +457,7 @@ bool cmDependsFortran::FindModule(std::string const& name, std::string& module)
}
// Try the upper-case name.
fullName = *i;
fullName = ip;
fullName += "/";
fullName += mod_upper;
if (cmSystemTools::FileExists(fullName.c_str(), true)) {
Source/cmDependsJavaParserHelper.cxx
+14 -26
View File
@@ -40,10 +40,8 @@ void cmDependsJavaParserHelper::CurrentClass::AddFileNamesForPrinting(
}
rname += this->Name;
files->push_back(rname);
std::vector<CurrentClass>::const_iterator it;
for (it = this->NestedClasses.begin(); it != this->NestedClasses.end();
++it) {
it->AddFileNamesForPrinting(files, rname.c_str(), sep);
for (CurrentClass const& nc : this->NestedClasses) {
nc.AddFileNamesForPrinting(files, rname.c_str(), sep);
}
}
@@ -64,9 +62,8 @@ void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
if (!sclass) {
return;
}
std::vector<std::string>::iterator it;
for (it = this->ClassesFound.begin(); it != this->ClassesFound.end(); it++) {
if (*it == sclass) {
for (std::string const& cf : this->ClassesFound) {
if (cf == sclass) {
return;
}
}
@@ -75,10 +72,8 @@ void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
void cmDependsJavaParserHelper::AddPackagesImport(const char* sclass)
{
std::vector<std::string>::iterator it;
for (it = this->PackagesImport.begin(); it != this->PackagesImport.end();
it++) {
if (*it == sclass) {
for (std::string const& pi : this->PackagesImport) {
if (pi == sclass) {
return;
}
}
@@ -208,10 +203,8 @@ void cmDependsJavaParserHelper::PrintClasses()
std::cerr << "Error when parsing. No classes on class stack" << std::endl;
abort();
}
std::vector<std::string> files = this->GetFilesProduced();
std::vector<std::string>::iterator sit;
for (sit = files.begin(); sit != files.end(); ++sit) {
std::cout << " " << *sit << ".class" << std::endl;
for (std::string const& f : this->GetFilesProduced()) {
std::cout << " " << f << ".class" << std::endl;
}
}
@@ -219,10 +212,8 @@ std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced()
{
std::vector<std::string> files;
CurrentClass const& toplevel = this->ClassStack.front();
std::vector<CurrentClass>::const_iterator it;
for (it = toplevel.NestedClasses.begin(); it != toplevel.NestedClasses.end();
++it) {
it->AddFileNamesForPrinting(&files, nullptr, "$");
for (CurrentClass const& nc : toplevel.NestedClasses) {
nc.AddFileNamesForPrinting(&files, nullptr, "$");
}
return files;
}
@@ -262,10 +253,8 @@ int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
std::cout << std::endl;
std::cout << "Depends on:";
if (!this->ClassesFound.empty()) {
std::vector<std::string>::iterator it;
for (it = this->ClassesFound.begin(); it != this->ClassesFound.end();
++it) {
std::cout << " " << *it;
for (std::string const& cf : this->ClassesFound) {
std::cout << " " << cf;
}
}
std::cout << std::endl;
@@ -282,9 +271,8 @@ int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
void cmDependsJavaParserHelper::CleanupParser()
{
std::vector<char*>::iterator it;
for (it = this->Allocates.begin(); it != this->Allocates.end(); ++it) {
delete[] * it;
for (char* allocate : this->Allocates) {
delete[] allocate;
}
this->Allocates.erase(this->Allocates.begin(), this->Allocates.end());
}
Source/cmDocumentation.cxx
+17 -26
View File
@@ -123,23 +123,21 @@ bool cmDocumentation::PrintRequestedDocumentation(std::ostream& os)
bool result = true;
// Loop over requested documentation types.
for (std::vector<RequestedHelpItem>::const_iterator i =
this->RequestedHelpItems.begin();
i != this->RequestedHelpItems.end(); ++i) {
this->CurrentArgument = i->Argument;
for (RequestedHelpItem const& rhi : this->RequestedHelpItems) {
this->CurrentArgument = rhi.Argument;
// If a file name was given, use it. Otherwise, default to the
// given stream.
cmsys::ofstream fout;
std::ostream* s = &os;
if (!i->Filename.empty()) {
fout.open(i->Filename.c_str());
if (!rhi.Filename.empty()) {
fout.open(rhi.Filename.c_str());
s = &fout;
} else if (++count > 1) {
os << "\n\n";
}
// Print this documentation type to the stream.
if (!this->PrintDocumentation(i->HelpType, *s) || s->fail()) {
if (!this->PrintDocumentation(rhi.HelpType, *s) || s->fail()) {
result = false;
}
}
@@ -394,10 +392,8 @@ void cmDocumentation::SetSection(const char* name, const char* docs[][2])
void cmDocumentation::SetSections(
std::map<std::string, cmDocumentationSection*>& sections)
{
for (std::map<std::string, cmDocumentationSection*>::const_iterator it =
sections.begin();
it != sections.end(); ++it) {
this->SetSection(it->first.c_str(), it->second);
for (auto const& s : sections) {
this->SetSection(s.first.c_str(), s.second);
}
}
@@ -489,10 +485,9 @@ void cmDocumentation::PrintNames(std::ostream& os, std::string const& pattern)
std::vector<std::string> files;
this->GlobHelp(files, pattern);
std::vector<std::string> names;
for (std::vector<std::string>::const_iterator i = files.begin();
i != files.end(); ++i) {
for (std::string const& f : files) {
std::string line;
cmsys::ifstream fin(i->c_str());
cmsys::ifstream fin(f.c_str());
while (fin && cmSystemTools::GetLineFromStream(fin, line)) {
if (!line.empty() && (isalnum(line[0]) || line[0] == '<')) {
names.push_back(line);
@@ -501,9 +496,8 @@ void cmDocumentation::PrintNames(std::ostream& os, std::string const& pattern)
}
}
std::sort(names.begin(), names.end());
for (std::vector<std::string>::iterator i = names.begin(); i != names.end();
++i) {
os << *i << "\n";
for (std::string const& n : names) {
os << n << "\n";
}
}
@@ -514,9 +508,8 @@ bool cmDocumentation::PrintFiles(std::ostream& os, std::string const& pattern)
this->GlobHelp(files, pattern);
std::sort(files.begin(), files.end());
cmRST r(os, cmSystemTools::GetCMakeRoot() + "/Help");
for (std::vector<std::string>::const_iterator i = files.begin();
i != files.end(); ++i) {
found = r.ProcessFile(*i) || found;
for (std::string const& f : files) {
found = r.ProcessFile(f) || found;
}
return found;
}
@@ -586,15 +579,13 @@ bool cmDocumentation::PrintHelpListModules(std::ostream& os)
std::vector<std::string> files;
this->GlobHelp(files, "module/*");
std::vector<std::string> modules;
for (std::vector<std::string>::iterator fi = files.begin();
fi != files.end(); ++fi) {
std::string module = cmSystemTools::GetFilenameName(*fi);
for (std::string const& f : files) {
std::string module = cmSystemTools::GetFilenameName(f);
modules.push_back(module.substr(0, module.size() - 4));
}
std::sort(modules.begin(), modules.end());
for (std::vector<std::string>::iterator i = modules.begin();
i != modules.end(); ++i) {
os << *i << "\n";
for (std::string const& m : modules) {
os << m << "\n";
}
return true;
}
Source/cmDocumentationFormatter.cxx
+7 -8
View File
@@ -168,26 +168,25 @@ void cmDocumentationFormatter::PrintSection(
os << section.GetName() << "\n";
const std::vector<cmDocumentationEntry>& entries = section.GetEntries();
for (std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
op != entries.end(); ++op) {
if (!op->Name.empty()) {
os << " " << op->Name;
for (cmDocumentationEntry const& entry : entries) {
if (!entry.Name.empty()) {
os << " " << entry.Name;
this->TextIndent = " ";
int align = static_cast<int>(strlen(this->TextIndent)) - 4;
for (int i = static_cast<int>(op->Name.size()); i < align; ++i) {
for (int i = static_cast<int>(entry.Name.size()); i < align; ++i) {
os << " ";
}
if (op->Name.size() > strlen(this->TextIndent) - 4) {
if (entry.Name.size() > strlen(this->TextIndent) - 4) {
os << "\n";
os.write(this->TextIndent, strlen(this->TextIndent) - 2);
}
os << "= ";
this->PrintColumn(os, op->Brief.c_str());
this->PrintColumn(os, entry.Brief.c_str());
os << "\n";
} else {
os << "\n";
this->TextIndent = "";
this->PrintFormatted(os, op->Brief.c_str());
this->PrintFormatted(os, entry.Brief.c_str());
}
}
os << "\n";
Source/cmDynamicLoader.cxx
+2 -4
View File
@@ -65,10 +65,8 @@ bool cmDynamicLoaderCache::FlushCache(const char* path)
void cmDynamicLoaderCache::FlushCache()
{
for (std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator
it = this->CacheMap.begin();
it != this->CacheMap.end(); it++) {
cmsys::DynamicLoader::CloseLibrary(it->second);
for (auto const& it : this->CacheMap) {
cmsys::DynamicLoader::CloseLibrary(it.second);
}
delete cmDynamicLoaderCache::Instance;
cmDynamicLoaderCache::Instance = nullptr;
Source/cmELF.cxx
+4 -8
View File
@@ -547,10 +547,7 @@ cmELF::DynamicEntryList cmELFInternalImpl<Types>::GetDynamicEntries()
// Copy into public array
result.reserve(this->DynamicSectionEntries.size());
for (typename std::vector<ELF_Dyn>::iterator di =
this->DynamicSectionEntries.begin();
di != this->DynamicSectionEntries.end(); ++di) {
ELF_Dyn& dyn = *di;
for (ELF_Dyn& dyn : this->DynamicSectionEntries) {
result.push_back(
std::pair<unsigned long, unsigned long>(dyn.d_tag, dyn.d_un.d_val));
}
@@ -565,12 +562,11 @@ std::vector<char> cmELFInternalImpl<Types>::EncodeDynamicEntries(
std::vector<char> result;
result.reserve(sizeof(ELF_Dyn) * entries.size());
for (cmELF::DynamicEntryList::const_iterator it = entries.begin();
it != entries.end(); it++) {
for (auto const& entry : entries) {
// Store the entry in an ELF_Dyn, byteswap it, then serialize to chars
ELF_Dyn dyn;
dyn.d_tag = static_cast<tagtype>(it->first);
dyn.d_un.d_val = static_cast<tagtype>(it->second);
dyn.d_tag = static_cast<tagtype>(entry.first);
dyn.d_un.d_val = static_cast<tagtype>(entry.second);
if (this->NeedSwap) {
ByteSwap(dyn);
Source/cmEnableLanguageCommand.cxx
+3 -4
View File
@@ -16,12 +16,11 @@ bool cmEnableLanguageCommand::InitialPass(std::vector<std::string> const& args,
this->SetError("called with incorrect number of arguments");
return false;
}
for (std::vector<std::string>::const_iterator it = args.begin();
it != args.end(); ++it) {
if ((*it) == "OPTIONAL") {
for (std::string const& it : args) {
if (it == "OPTIONAL") {
optional = true;
} else {
languages.push_back(*it);
languages.push_back(it);
}
}
Source/cmExecProgramCommand.cxx
+7 -7
View File
@@ -26,8 +26,8 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
bool haveoutput_variable = false;
std::string return_variable;
bool havereturn_variable = false;
for (size_t i = 0; i < args.size(); ++i) {
if (args[i] == "OUTPUT_VARIABLE") {
for (std::string const& arg : args) {
if (arg == "OUTPUT_VARIABLE") {
count++;
doingargs = false;
havereturn_variable = false;
@@ -37,10 +37,10 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
this->SetError("called with incorrect number of arguments");
return false;
}
output_variable = args[i];
output_variable = arg;
haveoutput_variable = false;
count++;
} else if (args[i] == "RETURN_VALUE") {
} else if (arg == "RETURN_VALUE") {
count++;
doingargs = false;
haveoutput_variable = false;
@@ -50,16 +50,16 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
this->SetError("called with incorrect number of arguments");
return false;
}
return_variable = args[i];
return_variable = arg;
havereturn_variable = false;
count++;
} else if (args[i] == "ARGS") {
} else if (arg == "ARGS") {
count++;
havereturn_variable = false;
haveoutput_variable = false;
doingargs = true;
} else if (doingargs) {
arguments += args[i];
arguments += arg;
arguments += " ";
count++;
}
Source/cmExecuteProcessCommand.cxx
+5 -5
View File
@@ -170,13 +170,13 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
this->SetError(" called with no COMMAND argument.");
return false;
}
for (unsigned int i = 0; i < cmds.size(); ++i) {
if (cmds[i].empty()) {
for (auto& cmd : cmds) {
if (cmd.empty()) {
this->SetError(" given COMMAND argument with no value.");
return false;
}
// Add the null terminating pointer to the command argument list.
cmds[i].push_back(nullptr);
cmd.push_back(nullptr);
}
// Parse the timeout string.
@@ -192,8 +192,8 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
cmsysProcess* cp = cmsysProcess_New();
// Set the command sequence.
for (unsigned int i = 0; i < cmds.size(); ++i) {
cmsysProcess_AddCommand(cp, &*cmds[i].begin());
for (auto const& cmd : cmds) {
cmsysProcess_AddCommand(cp, &*cmd.begin());
}
// Set the process working directory.
Source/cmExportBuildAndroidMKGenerator.cxx
+16 -20
View File
@@ -3,7 +3,6 @@
#include "cmExportBuildAndroidMKGenerator.h"
#include <algorithm>
#include <map>
#include <sstream>
#include <utility>
@@ -98,43 +97,41 @@ void cmExportBuildAndroidMKGenerator::GenerateInterfaceProperties(
}
if (!properties.empty()) {
os << "LOCAL_CPP_FEATURES := rtti exceptions\n";
for (ImportPropertyMap::const_iterator pi = properties.begin();
pi != properties.end(); ++pi) {
if (pi->first == "INTERFACE_COMPILE_OPTIONS") {
for (auto const& property : properties) {
if (property.first == "INTERFACE_COMPILE_OPTIONS") {
os << "LOCAL_CPP_FEATURES += ";
os << (pi->second) << "\n";
} else if (pi->first == "INTERFACE_LINK_LIBRARIES") {
os << (property.second) << "\n";
} else if (property.first == "INTERFACE_LINK_LIBRARIES") {
// need to look at list in pi->second and see if static or shared
// FindTargetToLink
// target->GetLocalGenerator()->FindGeneratorTargetToUse()
// then add to LOCAL_CPPFLAGS
std::vector<std::string> libraries;
cmSystemTools::ExpandListArgument(pi->second, libraries);
cmSystemTools::ExpandListArgument(property.second, libraries);
std::string staticLibs;
std::string sharedLibs;
std::string ldlibs;
for (std::vector<std::string>::iterator i = libraries.begin();
i != libraries.end(); ++i) {
for (std::string const& lib : libraries) {
cmGeneratorTarget* gt =
target->GetLocalGenerator()->FindGeneratorTargetToUse(*i);
target->GetLocalGenerator()->FindGeneratorTargetToUse(lib);
if (gt) {
if (gt->GetType() == cmStateEnums::SHARED_LIBRARY ||
gt->GetType() == cmStateEnums::MODULE_LIBRARY) {
sharedLibs += " " + *i;
sharedLibs += " " + lib;
} else {
staticLibs += " " + *i;
staticLibs += " " + lib;
}
} else {
// evaluate any generator expressions with the current
// build type of the makefile
cmGeneratorExpression ge;
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(lib);
std::string evaluated =
cge->Evaluate(target->GetLocalGenerator(), config);
bool relpath = false;
if (type == cmExportBuildAndroidMKGenerator::INSTALL) {
relpath = i->substr(0, 3) == "../";
relpath = lib.substr(0, 3) == "../";
}
// check for full path or if it already has a -l, or
// in the case of an install check for relative paths
@@ -157,20 +154,19 @@ void cmExportBuildAndroidMKGenerator::GenerateInterfaceProperties(
if (!ldlibs.empty()) {
os << "LOCAL_EXPORT_LDLIBS :=" << ldlibs << "\n";
}
} else if (pi->first == "INTERFACE_INCLUDE_DIRECTORIES") {
std::string includes = pi->second;
} else if (property.first == "INTERFACE_INCLUDE_DIRECTORIES") {
std::string includes = property.second;
std::vector<std::string> includeList;
cmSystemTools::ExpandListArgument(includes, includeList);
os << "LOCAL_EXPORT_C_INCLUDES := ";
std::string end;
for (std::vector<std::string>::iterator i = includeList.begin();
i != includeList.end(); ++i) {
os << end << *i;
for (std::string const& i : includeList) {
os << end << i;
end = "\\\n";
}
os << "\n";
} else {
os << "# " << pi->first << " " << (pi->second) << "\n";
os << "# " << property.first << " " << (property.second) << "\n";
}
}
}
Source/cmExportBuildFileGenerator.cxx
+12 -27
View File
@@ -45,9 +45,8 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
std::string sep;
std::vector<std::string> targets;
this->GetTargets(targets);
for (std::vector<std::string>::const_iterator tei = targets.begin();
tei != targets.end(); ++tei) {
cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(*tei);
for (std::string const& tei : targets) {
cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(tei);
expectedTargets += sep + this->Namespace + te->GetExportName();
sep = " ";
if (this->ExportedTargets.insert(te).second) {
@@ -71,10 +70,7 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
std::vector<std::string> missingTargets;
// Create all the imported targets.
for (std::vector<cmGeneratorTarget*>::const_iterator tei =
this->Exports.begin();
tei != this->Exports.end(); ++tei) {
cmGeneratorTarget* gte = *tei;
for (cmGeneratorTarget* gte : this->Exports) {
this->GenerateImportTargetCode(os, gte);
gte->Target->AppendBuildInterfaceIncludes();
@@ -115,10 +111,8 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
}
// Generate import file content for each configuration.
for (std::vector<std::string>::const_iterator ci =
this->Configurations.begin();
ci != this->Configurations.end(); ++ci) {
this->GenerateImportConfig(os, *ci, missingTargets);
for (std::string const& c : this->Configurations) {
this->GenerateImportConfig(os, c, missingTargets);
}
this->GenerateMissingTargetsCheckCode(os, missingTargets);
@@ -130,11 +124,8 @@ void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
std::ostream& os, const std::string& config, std::string const& suffix,
std::vector<std::string>& missingTargets)
{
for (std::vector<cmGeneratorTarget*>::const_iterator tei =
this->Exports.begin();
tei != this->Exports.end(); ++tei) {
for (cmGeneratorTarget* target : this->Exports) {
// Collect import properties for this target.
cmGeneratorTarget* target = *tei;
ImportPropertyMap properties;
if (target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
@@ -184,10 +175,8 @@ void cmExportBuildFileGenerator::SetImportLocationProperty(
target->GetObjectSources(objectSources, config);
std::string const obj_dir = target->GetObjectDirectory(config);
std::vector<std::string> objects;
for (std::vector<cmSourceFile const*>::const_iterator si =
objectSources.begin();
si != objectSources.end(); ++si) {
const std::string& obj = target->GetObjectName(*si);
for (cmSourceFile const* sf : objectSources) {
const std::string& obj = target->GetObjectName(sf);
objects.push_back(obj_dir + obj);
}
@@ -256,10 +245,8 @@ void cmExportBuildFileGenerator::GetTargets(
std::vector<std::string>& targets) const
{
if (this->ExportSet) {
for (std::vector<cmTargetExport*>::const_iterator tei =
this->ExportSet->GetTargetExports()->begin();
tei != this->ExportSet->GetTargetExports()->end(); ++tei) {
targets.push_back((*tei)->TargetName);
for (cmTargetExport* te : *this->ExportSet->GetTargetExports()) {
targets.push_back(te->TargetName);
}
return;
}
@@ -274,10 +261,8 @@ std::vector<std::string> cmExportBuildFileGenerator::FindNamespaces(
std::map<std::string, cmExportBuildFileGenerator*>& exportSets =
gg->GetBuildExportSets();
for (std::map<std::string, cmExportBuildFileGenerator*>::const_iterator
expIt = exportSets.begin();
expIt != exportSets.end(); ++expIt) {
const cmExportBuildFileGenerator* exportSet = expIt->second;
for (auto const& exp : exportSets) {
const cmExportBuildFileGenerator* exportSet = exp.second;
std::vector<std::string> targets;
exportSet->GetTargets(targets);
if (std::find(targets.begin(), targets.end(), name) != targets.end()) {
Source/cmExportCommand.cxx
+10 -14
View File
@@ -136,42 +136,40 @@ bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
}
this->ExportSet = setMap[setName];
} else if (this->Targets.WasFound()) {
for (std::vector<std::string>::const_iterator currentTarget =
this->Targets.GetVector().begin();
currentTarget != this->Targets.GetVector().end(); ++currentTarget) {
if (this->Makefile->IsAlias(*currentTarget)) {
for (std::string const& currentTarget : this->Targets.GetVector()) {
if (this->Makefile->IsAlias(currentTarget)) {
std::ostringstream e;
e << "given ALIAS target \"" << *currentTarget
e << "given ALIAS target \"" << currentTarget
<< "\" which may not be exported.";
this->SetError(e.str());
return false;
}
if (cmTarget* target = gg->FindTarget(*currentTarget)) {
if (cmTarget* target = gg->FindTarget(currentTarget)) {
if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
std::string reason;
if (!this->Makefile->GetGlobalGenerator()
->HasKnownObjectFileLocation(&reason)) {
std::ostringstream e;
e << "given OBJECT library \"" << *currentTarget
e << "given OBJECT library \"" << currentTarget
<< "\" which may not be exported" << reason << ".";
this->SetError(e.str());
return false;
}
}
if (target->GetType() == cmStateEnums::UTILITY) {
this->SetError("given custom target \"" + *currentTarget +
this->SetError("given custom target \"" + currentTarget +
"\" which may not be exported.");
return false;
}
} else {
std::ostringstream e;
e << "given target \"" << *currentTarget
e << "given target \"" << currentTarget
<< "\" which is not built by this project.";
this->SetError(e.str());
return false;
}
targets.push_back(*currentTarget);
targets.push_back(currentTarget);
}
if (this->Append.IsEnabled()) {
if (cmExportBuildFileGenerator* ebfg =
@@ -209,10 +207,8 @@ bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
if (configurationTypes.empty()) {
configurationTypes.push_back("");
}
for (std::vector<std::string>::const_iterator ci =
configurationTypes.begin();
ci != configurationTypes.end(); ++ci) {
ebfg->AddConfiguration(*ci);
for (std::string const& ct : configurationTypes) {
ebfg->AddConfiguration(ct);
}
if (this->ExportSet) {
gg->AddBuildExportExportSet(ebfg);
Source/cmExportFileGenerator.cxx
+43 -53
View File
@@ -206,9 +206,8 @@ static bool checkInterfaceDirs(const std::string& prepro,
bool hadFatalError = false;
for (std::vector<std::string>::iterator li = parts.begin();
li != parts.end(); ++li) {
size_t genexPos = cmGeneratorExpression::Find(*li);
for (std::string const& li : parts) {
size_t genexPos = cmGeneratorExpression::Find(li);
if (genexPos == 0) {
continue;
}
@@ -233,20 +232,20 @@ static bool checkInterfaceDirs(const std::string& prepro,
hadFatalError = true;
}
}
if (cmHasLiteralPrefix(li->c_str(), "${_IMPORT_PREFIX}")) {
if (cmHasLiteralPrefix(li.c_str(), "${_IMPORT_PREFIX}")) {
continue;
}
if (!cmSystemTools::FileIsFullPath(li->c_str())) {
if (!cmSystemTools::FileIsFullPath(li.c_str())) {
/* clang-format off */
e << "Target \"" << target->GetName() << "\" " << prop <<
" property contains relative path:\n"
" \"" << *li << "\"";
" \"" << li << "\"";
/* clang-format on */
target->GetLocalGenerator()->IssueMessage(messageType, e.str());
}
bool inBinary = isSubDirectory(li->c_str(), topBinaryDir);
bool inSource = isSubDirectory(li->c_str(), topSourceDir);
if (isSubDirectory(li->c_str(), installDir)) {
bool inBinary = isSubDirectory(li.c_str(), topBinaryDir);
bool inSource = isSubDirectory(li.c_str(), topSourceDir);
if (isSubDirectory(li.c_str(), installDir)) {
// The include directory is inside the install tree. If the
// install tree is not inside the source tree or build tree then
// fall through to the checks below that the include directory is not
@@ -261,7 +260,7 @@ static bool checkInterfaceDirs(const std::string& prepro,
case cmPolicies::WARN: {
std::ostringstream s;
s << cmPolicies::GetPolicyWarning(cmPolicies::CMP0052) << "\n";
s << "Directory:\n \"" << *li
s << "Directory:\n \"" << li
<< "\"\nin "
"INTERFACE_INCLUDE_DIRECTORIES of target \""
<< target->GetName() << "\" is a subdirectory of the install "
@@ -293,7 +292,7 @@ static bool checkInterfaceDirs(const std::string& prepro,
/* clang-format off */
e << "Target \"" << target->GetName() << "\" " << prop <<
" property contains path:\n"
" \"" << *li << "\"\nwhich is prefixed in the build directory.";
" \"" << li << "\"\nwhich is prefixed in the build directory.";
/* clang-format on */
target->GetLocalGenerator()->IssueMessage(messageType, e.str());
}
@@ -302,7 +301,7 @@ static bool checkInterfaceDirs(const std::string& prepro,
e << "Target \"" << target->GetName() << "\" " << prop
<< " property contains path:\n"
" \""
<< *li << "\"\nwhich is prefixed in the source directory.";
<< li << "\"\nwhich is prefixed in the source directory.";
target->GetLocalGenerator()->IssueMessage(messageType, e.str());
}
}
@@ -316,15 +315,14 @@ static void prefixItems(std::string& exportDirs)
cmGeneratorExpression::Split(exportDirs, entries);
exportDirs = "";
const char* sep = "";
for (std::vector<std::string>::const_iterator ei = entries.begin();
ei != entries.end(); ++ei) {
for (std::string const& e : entries) {
exportDirs += sep;
sep = ";";
if (!cmSystemTools::FileIsFullPath(ei->c_str()) &&
ei->find("${_IMPORT_PREFIX}") == std::string::npos) {
if (!cmSystemTools::FileIsFullPath(e.c_str()) &&
e.find("${_IMPORT_PREFIX}") == std::string::npos) {
exportDirs += "${_IMPORT_PREFIX}/";
}
exportDirs += *ei;
exportDirs += e;
}
}
@@ -461,18 +459,17 @@ void getCompatibleInterfaceProperties(cmGeneratorTarget* target,
const cmComputeLinkInformation::ItemVector& deps = info->GetItems();
for (cmComputeLinkInformation::ItemVector::const_iterator li = deps.begin();
li != deps.end(); ++li) {
if (!li->Target) {
for (auto const& dep : deps) {
if (!dep.Target) {
continue;
}
getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_BOOL",
getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_BOOL",
ifaceProperties);
getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_STRING",
getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_STRING",
ifaceProperties);
getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_NUMBER_MIN",
getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_NUMBER_MIN",
ifaceProperties);
getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_NUMBER_MAX",
getPropertyContents(dep.Target, "COMPATIBLE_INTERFACE_NUMBER_MAX",
ifaceProperties);
}
}
@@ -504,15 +501,13 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
std::vector<std::string> configNames;
gtarget->Target->GetMakefile()->GetConfigurations(configNames);
for (std::vector<std::string>::const_iterator ci = configNames.begin();
ci != configNames.end(); ++ci) {
getCompatibleInterfaceProperties(gtarget, ifaceProperties, *ci);
for (std::string const& cn : configNames) {
getCompatibleInterfaceProperties(gtarget, ifaceProperties, cn);
}
}
for (std::set<std::string>::const_iterator it = ifaceProperties.begin();
it != ifaceProperties.end(); ++it) {
this->PopulateInterfaceProperty("INTERFACE_" + *it, gtarget, properties);
for (std::string const& ip : ifaceProperties) {
this->PopulateInterfaceProperty("INTERFACE_" + ip, gtarget, properties);
}
}
@@ -524,10 +519,9 @@ void cmExportFileGenerator::GenerateInterfaceProperties(
std::string targetName = this->Namespace;
targetName += target->GetExportName();
os << "set_target_properties(" << targetName << " PROPERTIES\n";
for (ImportPropertyMap::const_iterator pi = properties.begin();
pi != properties.end(); ++pi) {
os << " " << pi->first << " " << cmExportFileGeneratorEscape(pi->second)
<< "\n";
for (auto const& property : properties) {
os << " " << property.first << " "
<< cmExportFileGeneratorEscape(property.second) << "\n";
}
os << ")\n\n";
}
@@ -572,14 +566,13 @@ void cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
std::string sep;
input = "";
for (std::vector<std::string>::iterator li = parts.begin();
li != parts.end(); ++li) {
if (cmGeneratorExpression::Find(*li) == std::string::npos) {
this->AddTargetNamespace(*li, target, missingTargets);
for (std::string& li : parts) {
if (cmGeneratorExpression::Find(li) == std::string::npos) {
this->AddTargetNamespace(li, target, missingTargets);
} else {
this->ResolveTargetsInGeneratorExpression(*li, target, missingTargets);
this->ResolveTargetsInGeneratorExpression(li, target, missingTargets);
}
input += sep + *li;
input += sep + li;
sep = ";";
}
}
@@ -797,13 +790,12 @@ void cmExportFileGenerator::SetImportLinkProperty(
// Construct the property value.
std::string link_entries;
const char* sep = "";
for (typename std::vector<T>::const_iterator li = entries.begin();
li != entries.end(); ++li) {
for (T const& l : entries) {
// Separate this from the previous entry.
link_entries += sep;
sep = ";";
std::string temp = *li;
std::string temp = l;
this->AddTargetNamespace(temp, target, missingTargets);
link_entries += temp;
}
@@ -988,10 +980,9 @@ void cmExportFileGenerator::GenerateImportPropertyCode(
}
os << ")\n";
os << "set_target_properties(" << targetName << " PROPERTIES\n";
for (ImportPropertyMap::const_iterator pi = properties.begin();
pi != properties.end(); ++pi) {
os << " " << pi->first << " " << cmExportFileGeneratorEscape(pi->second)
<< "\n";
for (auto const& property : properties) {
os << " " << property.first << " "
<< cmExportFileGeneratorEscape(property.second) << "\n";
}
os << " )\n"
<< "\n";
@@ -1015,9 +1006,9 @@ void cmExportFileGenerator::GenerateMissingTargetsCheckCode(
"foreach(_target ";
/* clang-format on */
std::set<std::string> emitted;
for (unsigned int i = 0; i < missingTargets.size(); ++i) {
if (emitted.insert(missingTargets[i]).second) {
os << "\"" << missingTargets[i] << "\" ";
for (std::string const& missingTarget : missingTargets) {
if (emitted.insert(missingTarget).second) {
os << "\"" << missingTarget << "\" ";
}
}
/* clang-format off */
@@ -1094,9 +1085,8 @@ void cmExportFileGenerator::GenerateImportedFileChecksCode(
"list(APPEND _IMPORT_CHECK_FILES_FOR_"
<< targetName << " ";
for (std::set<std::string>::const_iterator li = importedLocations.begin();
li != importedLocations.end(); ++li) {
ImportPropertyMap::const_iterator pi = properties.find(*li);
for (std::string const& li : importedLocations) {
ImportPropertyMap::const_iterator pi = properties.find(li);
if (pi != properties.end()) {
os << cmExportFileGeneratorEscape(pi->second) << " ";
}
Source/cmExportInstallAndroidMKGenerator.cxx
+1 -4
View File
@@ -34,11 +34,8 @@ void cmExportInstallAndroidMKGenerator::GenerateImportHeaderCode(
}
os << "_IMPORT_PREFIX := "
<< "$(LOCAL_PATH)" << path << "\n\n";
for (std::vector<cmTargetExport*>::const_iterator tei =
this->IEGen->GetExportSet()->GetTargetExports()->begin();
tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei) {
for (cmTargetExport* te : *this->IEGen->GetExportSet()->GetTargetExports()) {
// Collect import properties for this target.
cmTargetExport const* te = *tei;
if (te->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
Source/cmExportInstallFileGenerator.cxx
+20 -33
View File
@@ -4,7 +4,6 @@
#include "cmAlgorithms.h"
#include "cmExportSet.h"
#include "cmExportSetMap.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h"
@@ -22,6 +21,8 @@
#include <sstream>
#include <utility>
class cmExportSetMap;
cmExportInstallFileGenerator::cmExportInstallFileGenerator(
cmInstallExportGenerator* iegen)
: IEGen(iegen)
@@ -42,14 +43,10 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
{
std::string expectedTargets;
std::string sep;
for (std::vector<cmTargetExport*>::const_iterator tei =
this->IEGen->GetExportSet()->GetTargetExports()->begin();
tei != this->IEGen->GetExportSet()->GetTargetExports()->end();
++tei) {
expectedTargets +=
sep + this->Namespace + (*tei)->Target->GetExportName();
for (cmTargetExport* te :
*this->IEGen->GetExportSet()->GetTargetExports()) {
expectedTargets += sep + this->Namespace + te->Target->GetExportName();
sep = " ";
cmTargetExport* te = *tei;
if (this->ExportedTargets.insert(te->Target).second) {
allTargets.push_back(te);
} else {
@@ -76,9 +73,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
bool require3_1_0 = false;
bool requiresConfigFiles = false;
// Create all the imported targets.
for (std::vector<cmTargetExport*>::const_iterator tei = allTargets.begin();
tei != allTargets.end(); ++tei) {
cmGeneratorTarget* gt = (*tei)->Target;
for (cmTargetExport* te : allTargets) {
cmGeneratorTarget* gt = te->Target;
requiresConfigFiles =
requiresConfigFiles || gt->GetType() != cmStateEnums::INTERFACE_LIBRARY;
@@ -88,10 +84,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
ImportPropertyMap properties;
this->PopulateIncludeDirectoriesInterface(
*tei, cmGeneratorExpression::InstallInterface, properties,
missingTargets);
this->PopulateSourcesInterface(*tei,
cmGeneratorExpression::InstallInterface,
te, cmGeneratorExpression::InstallInterface, properties, missingTargets);
this->PopulateSourcesInterface(te, cmGeneratorExpression::InstallInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", gt,
cmGeneratorExpression::InstallInterface,
@@ -154,10 +148,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
// Generate an import file for each configuration.
// Don't do this if we only export INTERFACE_LIBRARY targets.
if (requiresConfigFiles) {
for (std::vector<std::string>::const_iterator ci =
this->Configurations.begin();
ci != this->Configurations.end(); ++ci) {
if (!this->GenerateImportFileConfig(*ci, missingTargets)) {
for (std::string const& c : this->Configurations) {
if (!this->GenerateImportFileConfig(c, missingTargets)) {
result = false;
}
}
@@ -314,11 +306,8 @@ void cmExportInstallFileGenerator::GenerateImportTargetsConfig(
std::vector<std::string>& missingTargets)
{
// Add each target in the set to the export.
for (std::vector<cmTargetExport*>::const_iterator tei =
this->IEGen->GetExportSet()->GetTargetExports()->begin();
tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei) {
for (cmTargetExport* te : *this->IEGen->GetExportSet()->GetTargetExports()) {
// Collect import properties for this target.
cmTargetExport const* te = *tei;
if (te->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
@@ -409,9 +398,8 @@ void cmExportInstallFileGenerator::SetImportLocationProperty(
// IMPORTED_OBJECTS as a list of object files
std::vector<std::string> objects;
itgen->GetInstallObjectNames(config, objects);
for (std::vector<std::string>::iterator i = objects.begin();
i != objects.end(); ++i) {
*i = value + *i;
for (std::string& obj : objects) {
obj = value + obj;
}
// Store the property.
@@ -465,15 +453,14 @@ std::vector<std::string> cmExportInstallFileGenerator::FindNamespaces(
std::vector<std::string> namespaces;
const cmExportSetMap& exportSets = gg->GetExportSets();
for (cmExportSetMap::const_iterator expIt = exportSets.begin();
expIt != exportSets.end(); ++expIt) {
const cmExportSet* exportSet = expIt->second;
for (auto const& expIt : exportSets) {
const cmExportSet* exportSet = expIt.second;
std::vector<cmTargetExport*> const* targets =
exportSet->GetTargetExports();
bool containsTarget = false;
for (unsigned int i = 0; i < targets->size(); i++) {
if (name == (*targets)[i]->TargetName) {
for (cmTargetExport* target : *targets) {
if (name == target->TargetName) {
containsTarget = true;
break;
}
@@ -482,8 +469,8 @@ std::vector<std::string> cmExportInstallFileGenerator::FindNamespaces(
if (containsTarget) {
std::vector<cmInstallExportGenerator const*> const* installs =
exportSet->GetInstallations();
for (unsigned int i = 0; i < installs->size(); i++) {
namespaces.push_back((*installs)[i]->GetNamespace());
for (cmInstallExportGenerator const* install : *installs) {
namespaces.push_back(install->GetNamespace());
}
}
}
Source/cmExportLibraryDependenciesCommand.cxx
+17 -25
View File
@@ -4,7 +4,6 @@
#include "cmsys/FStream.hxx"
#include <map>
#include <unordered_map>
#include <utility>
#include "cmGeneratedFileStream.h"
@@ -75,12 +74,11 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
std::map<std::string, std::string> libDepsOld;
std::map<std::string, std::string> libDepsNew;
std::map<std::string, std::string> libTypes;
for (std::vector<cmMakefile*>::const_iterator i = locals.begin();
i != locals.end(); ++i) {
const cmTargets& tgts = (*i)->GetTargets();
for (cmTargets::const_iterator l = tgts.begin(); l != tgts.end(); ++l) {
for (cmMakefile* local : locals) {
const cmTargets& tgts = local->GetTargets();
for (auto const& tgt : tgts) {
// Get the current target.
cmTarget const& target = l->second;
cmTarget const& target = tgt.second;
// Skip non-library targets.
if (target.GetType() < cmStateEnums::STATIC_LIBRARY ||
@@ -98,12 +96,11 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
std::string valueNew;
cmTarget::LinkLibraryVectorType const& libs =
target.GetOriginalLinkLibraries();
for (cmTarget::LinkLibraryVectorType::const_iterator li = libs.begin();
li != libs.end(); ++li) {
std::string ltVar = li->first;
for (cmTarget::LibraryID const& li : libs) {
std::string ltVar = li.first;
ltVar += "_LINK_TYPE";
std::string ltValue;
switch (li->second) {
switch (li.second) {
case GENERAL_LibraryType:
valueNew += "general;";
ltValue = "general";
@@ -117,7 +114,7 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
ltValue = "optimized";
break;
}
std::string lib = li->first;
std::string lib = li.first;
if (cmTarget* libtgt = global->FindTarget(lib)) {
// Handle simple output name changes. This command is
// deprecated so we do not support full target name
@@ -150,26 +147,21 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
fout << "# Generated by CMake\n\n";
fout << "if(" << vertest << ")\n";
fout << " # Information for CMake 2.6 and above.\n";
for (std::map<std::string, std::string>::const_iterator i =
libDepsNew.begin();
i != libDepsNew.end(); ++i) {
if (!i->second.empty()) {
fout << " set(\"" << i->first << "\" \"" << i->second << "\")\n";
for (auto const& i : libDepsNew) {
if (!i.second.empty()) {
fout << " set(\"" << i.first << "\" \"" << i.second << "\")\n";
}
}
fout << "else()\n";
fout << " # Information for CMake 2.4 and lower.\n";
for (std::map<std::string, std::string>::const_iterator i =
libDepsOld.begin();
i != libDepsOld.end(); ++i) {
if (!i->second.empty()) {
fout << " set(\"" << i->first << "\" \"" << i->second << "\")\n";
for (auto const& i : libDepsOld) {
if (!i.second.empty()) {
fout << " set(\"" << i.first << "\" \"" << i.second << "\")\n";
}
}
for (std::map<std::string, std::string>::const_iterator i = libTypes.begin();
i != libTypes.end(); ++i) {
if (i->second != "general") {
fout << " set(\"" << i->first << "\" \"" << i->second << "\")\n";
for (auto const& i : libTypes) {
if (i.second != "general") {
fout << " set(\"" << i.first << "\" \"" << i.second << "\")\n";
}
}
fout << "endif()\n";
Source/cmExportSet.cxx
+2 -3
View File
@@ -13,9 +13,8 @@ cmExportSet::~cmExportSet()
void cmExportSet::Compute(cmLocalGenerator* lg)
{
for (std::vector<cmTargetExport*>::iterator it = this->TargetExports.begin();
it != this->TargetExports.end(); ++it) {
(*it)->Target = lg->FindGeneratorTargetToUse((*it)->TargetName);
for (cmTargetExport* tgtExport : this->TargetExports) {
tgtExport->Target = lg->FindGeneratorTargetToUse(tgtExport->TargetName);
}
}
Source/cmExportTryCompileFileGenerator.cxx
+11 -15
View File
@@ -77,11 +77,9 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
const std::set<cmGeneratorTarget const*>& allTargets =
cge->GetAllTargetsSeen();
for (std::set<cmGeneratorTarget const*>::const_iterator li =
allTargets.begin();
li != allTargets.end(); ++li) {
if (emitted.insert(*li).second) {
this->Exports.push_back(*li);
for (cmGeneratorTarget const* target : allTargets) {
if (emitted.insert(target).second) {
this->Exports.push_back(target);
}
}
return result;
@@ -92,22 +90,20 @@ void cmExportTryCompileFileGenerator::PopulateProperties(
std::set<cmGeneratorTarget const*>& emitted)
{
std::vector<std::string> props = target->GetPropertyKeys();
for (std::vector<std::string>::const_iterator i = props.begin();
i != props.end(); ++i) {
for (std::string const& p : props) {
properties[*i] = target->GetProperty(*i);
properties[p] = target->GetProperty(p);
if (i->find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 ||
i->find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 ||
i->find("INTERFACE_LINK_LIBRARIES") == 0) {
std::string evalResult = this->FindTargets(*i, target, emitted);
if (p.find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 ||
p.find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 ||
p.find("INTERFACE_LINK_LIBRARIES") == 0) {
std::string evalResult = this->FindTargets(p, target, emitted);
std::vector<std::string> depends;
cmSystemTools::ExpandListArgument(evalResult, depends);
for (std::vector<std::string>::const_iterator li = depends.begin();
li != depends.end(); ++li) {
for (std::string const& li : depends) {
cmGeneratorTarget* tgt =
target->GetLocalGenerator()->FindGeneratorTargetToUse(*li);
target->GetLocalGenerator()->FindGeneratorTargetToUse(li);
if (tgt && emitted.insert(tgt).second) {
this->Exports.push_back(tgt);
}
Source/cmExtraCodeBlocksGenerator.cxx
+61 -91
View File
@@ -63,11 +63,9 @@ cmExtraCodeBlocksGenerator::GetFactory()
void cmExtraCodeBlocksGenerator::Generate()
{
// for each sub project in the project create a codeblocks project
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
// create a project file
this->CreateProjectFile(it->second);
this->CreateProjectFile(it.second);
}
}
@@ -116,15 +114,14 @@ void Tree::InsertPath(const std::vector<std::string>& splitted,
files.insert(fileName);
return;
}
for (std::vector<Tree>::iterator it = folders.begin(); it != folders.end();
++it) {
if ((*it).path == splitted[start]) {
for (Tree& folder : folders) {
if (folder.path == splitted[start]) {
if (start + 1 < splitted.size()) {
it->InsertPath(splitted, start + 1, fileName);
folder.InsertPath(splitted, start + 1, fileName);
return;
}
// last part of splitted
it->files.insert(fileName);
folder.files.insert(fileName);
return;
}
}
@@ -145,9 +142,8 @@ void Tree::BuildVirtualFolder(cmXMLWriter& xml) const
{
xml.StartElement("Option");
std::string virtualFolders = "CMake Files\\;";
for (std::vector<Tree>::const_iterator it = folders.begin();
it != folders.end(); ++it) {
it->BuildVirtualFolderImpl(virtualFolders, "");
for (Tree const& folder : folders) {
folder.BuildVirtualFolderImpl(virtualFolders, "");
}
xml.Attribute("virtualFolders", virtualFolders);
xml.EndElement();
@@ -157,18 +153,16 @@ void Tree::BuildVirtualFolderImpl(std::string& virtualFolders,
const std::string& prefix) const
{
virtualFolders += "CMake Files\\" + prefix + path + "\\;";
for (std::vector<Tree>::const_iterator it = folders.begin();
it != folders.end(); ++it) {
it->BuildVirtualFolderImpl(virtualFolders, prefix + path + "\\");
for (Tree const& folder : folders) {
folder.BuildVirtualFolderImpl(virtualFolders, prefix + path + "\\");
}
}
void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
{
for (std::set<std::string>::const_iterator it = files.begin();
it != files.end(); ++it) {
for (std::string const& f : files) {
xml.StartElement("Unit");
xml.Attribute("filename", fsPath + *it);
xml.Attribute("filename", fsPath + f);
xml.StartElement("Option");
xml.Attribute("virtualFolder", "CMake Files\\");
@@ -176,9 +170,8 @@ void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
xml.EndElement();
}
for (std::vector<Tree>::const_iterator it = folders.begin();
it != folders.end(); ++it) {
it->BuildUnitImpl(xml, "", fsPath);
for (Tree const& folder : folders) {
folder.BuildUnitImpl(xml, "", fsPath);
}
}
@@ -186,10 +179,9 @@ void Tree::BuildUnitImpl(cmXMLWriter& xml,
const std::string& virtualFolderPath,
const std::string& fsPath) const
{
for (std::set<std::string>::const_iterator it = files.begin();
it != files.end(); ++it) {
for (std::string const& f : files) {
xml.StartElement("Unit");
xml.Attribute("filename", fsPath + path + "/" + *it);
xml.Attribute("filename", fsPath + path + "/" + f);
xml.StartElement("Option");
xml.Attribute("virtualFolder",
@@ -198,10 +190,9 @@ void Tree::BuildUnitImpl(cmXMLWriter& xml,
xml.EndElement();
}
for (std::vector<Tree>::const_iterator it = folders.begin();
it != folders.end(); ++it) {
it->BuildUnitImpl(xml, virtualFolderPath + path + "\\",
fsPath + path + "/");
for (Tree const& folder : folders) {
folder.BuildUnitImpl(xml, virtualFolderPath + path + "\\",
fsPath + path + "/");
}
}
@@ -217,29 +208,24 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
Tree tree;
// build tree of virtual folders
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
// Collect all files
std::vector<std::string> listFiles;
for (std::vector<cmLocalGenerator*>::const_iterator jt =
it->second.begin();
jt != it->second.end(); ++jt) {
for (cmLocalGenerator* lg : it.second) {
const std::vector<std::string>& files =
(*jt)->GetMakefile()->GetListFiles();
lg->GetMakefile()->GetListFiles();
listFiles.insert(listFiles.end(), files.begin(), files.end());
}
// Convert
for (std::vector<std::string>::const_iterator jt = listFiles.begin();
jt != listFiles.end(); ++jt) {
for (std::string const& listFile : listFiles) {
// don't put cmake's own files into the project (#12110):
if (jt->find(cmSystemTools::GetCMakeRoot()) == 0) {
if (listFile.find(cmSystemTools::GetCMakeRoot()) == 0) {
continue;
}
const std::string& relative = cmSystemTools::RelativePath(
it->second[0]->GetSourceDirectory(), jt->c_str());
it.second[0]->GetSourceDirectory(), listFile.c_str());
std::vector<std::string> splitted;
cmSystemTools::SplitPath(relative, splitted, false);
// Split filename from path
@@ -295,20 +281,17 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
lg != lgs.end(); lg++) {
const std::vector<cmGeneratorTarget*>& targets =
(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ti++) {
std::string targetName = (*ti)->GetName();
switch ((*ti)->GetType()) {
for (cmLocalGenerator* lg : lgs) {
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
std::string targetName = target->GetName();
switch (target->GetType()) {
case cmStateEnums::GLOBAL_TARGET: {
// Only add the global targets from CMAKE_BINARY_DIR,
// not from the subdirs
if (strcmp((*lg)->GetCurrentBinaryDirectory(),
(*lg)->GetBinaryDirectory()) == 0) {
this->AppendTarget(xml, targetName, nullptr, make.c_str(), *lg,
if (strcmp(lg->GetCurrentBinaryDirectory(),
lg->GetBinaryDirectory()) == 0) {
this->AppendTarget(xml, targetName, nullptr, make.c_str(), lg,
compiler.c_str(), makeArgs);
}
} break;
@@ -324,7 +307,7 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
break;
}
this->AppendTarget(xml, targetName, nullptr, make.c_str(), *lg,
this->AppendTarget(xml, targetName, nullptr, make.c_str(), lg,
compiler.c_str(), makeArgs);
break;
case cmStateEnums::EXECUTABLE:
@@ -332,12 +315,12 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::OBJECT_LIBRARY: {
cmGeneratorTarget* gt = *ti;
this->AppendTarget(xml, targetName, gt, make.c_str(), *lg,
cmGeneratorTarget* gt = target;
this->AppendTarget(xml, targetName, gt, make.c_str(), lg,
compiler.c_str(), makeArgs);
std::string fastTarget = targetName;
fastTarget += "/fast";
this->AppendTarget(xml, fastTarget, gt, make.c_str(), *lg,
this->AppendTarget(xml, fastTarget, gt, make.c_str(), lg,
compiler.c_str(), makeArgs);
} break;
default:
@@ -358,14 +341,11 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
std::vector<std::string> const& srcExts =
this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
lg != lgs.end(); lg++) {
cmMakefile* makefile = (*lg)->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets =
(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ti++) {
switch ((*ti)->GetType()) {
for (cmLocalGenerator* lg : lgs) {
cmMakefile* makefile = lg->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
switch (target->GetType()) {
case cmStateEnums::EXECUTABLE:
case cmStateEnums::STATIC_LIBRARY:
case cmStateEnums::SHARED_LIBRARY:
@@ -374,41 +354,38 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
case cmStateEnums::UTILITY: // can have sources since 2.6.3
{
std::vector<cmSourceFile*> sources;
cmGeneratorTarget* gt = *ti;
cmGeneratorTarget* gt = target;
gt->GetSourceFiles(sources,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
si != sources.end(); si++) {
for (cmSourceFile* s : sources) {
// don't add source files from UTILITY target which have the
// GENERATED property set:
if (gt->GetType() == cmStateEnums::UTILITY &&
(*si)->GetPropertyAsBool("GENERATED")) {
s->GetPropertyAsBool("GENERATED")) {
continue;
}
// check whether it is a C/C++ implementation file
bool isCFile = false;
std::string lang = (*si)->GetLanguage();
std::string lang = s->GetLanguage();
if (lang == "C" || lang == "CXX") {
std::string const& srcext = (*si)->GetExtension();
for (std::vector<std::string>::const_iterator ext =
srcExts.begin();
ext != srcExts.end(); ++ext) {
if (srcext == *ext) {
std::string const& srcext = s->GetExtension();
for (std::string const& ext : srcExts) {
if (srcext == ext) {
isCFile = true;
break;
}
}
}
std::string const& fullPath = (*si)->GetFullPath();
std::string const& fullPath = s->GetFullPath();
if (isCFile) {
cFiles.push_back(fullPath);
}
CbpUnit& cbpUnit = allFiles[fullPath];
cbpUnit.Targets.push_back(*ti);
cbpUnit.Targets.push_back(target);
}
}
default: // intended fallthrough
@@ -427,19 +404,16 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
// file exists. If it does, it is inserted into the map of files.
// A very similar version of that code exists also in the kdevelop
// project generator.
for (std::vector<std::string>::const_iterator sit = cFiles.begin();
sit != cFiles.end(); ++sit) {
std::string const& fileName = *sit;
for (std::string const& fileName : cFiles) {
std::string headerBasename = cmSystemTools::GetFilenamePath(fileName);
headerBasename += "/";
headerBasename += cmSystemTools::GetFilenameWithoutExtension(fileName);
// check if there's a matching header around
for (std::vector<std::string>::const_iterator ext = headerExts.begin();
ext != headerExts.end(); ++ext) {
for (std::string const& ext : headerExts) {
std::string hname = headerBasename;
hname += ".";
hname += *ext;
hname += ext;
// if it's already in the set, don't check if it exists on disk
if (allFiles.find(hname) != allFiles.end()) {
break;
@@ -453,19 +427,16 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
}
// insert all source files in the CodeBlocks project
for (all_files_map_t::const_iterator sit = allFiles.begin();
sit != allFiles.end(); ++sit) {
std::string const& unitFilename = sit->first;
CbpUnit const& unit = sit->second;
for (auto const& s : allFiles) {
std::string const& unitFilename = s.first;
CbpUnit const& unit = s.second;
xml.StartElement("Unit");
xml.Attribute("filename", unitFilename);
for (std::vector<const cmGeneratorTarget*>::const_iterator ti =
unit.Targets.begin();
ti != unit.Targets.end(); ++ti) {
for (cmGeneratorTarget const* tgt : unit.Targets) {
xml.StartElement("Option");
xml.Attribute("target", (*ti)->GetName());
xml.Attribute("target", tgt->GetName());
xml.EndElement();
}
@@ -575,10 +546,9 @@ void cmExtraCodeBlocksGenerator::AppendTarget(
target->GetCompileDefinitions(cdefs, buildType, "C");
// Expand the list.
for (std::vector<std::string>::const_iterator di = cdefs.begin();
di != cdefs.end(); ++di) {
for (std::string const& d : cdefs) {
xml.StartElement("Add");
xml.Attribute("option", "-D" + *di);
xml.Attribute("option", "-D" + d);
xml.EndElement();
}
Source/cmExtraCodeLiteGenerator.cxx
+41 -60
View File
@@ -60,20 +60,18 @@ void cmExtraCodeLiteGenerator::Generate()
// loop projects and locate the root project.
// and extract the information for creating the worspace
// root makefile
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = projectMap.begin();
it != projectMap.end(); ++it) {
const cmMakefile* mf = it->second[0]->GetMakefile();
for (auto const& it : projectMap) {
const cmMakefile* mf = it.second[0]->GetMakefile();
this->ConfigName = GetConfigurationName(mf);
if (strcmp(it->second[0]->GetCurrentBinaryDirectory(),
it->second[0]->GetBinaryDirectory()) == 0) {
workspaceOutputDir = it->second[0]->GetCurrentBinaryDirectory();
workspaceProjectName = it->second[0]->GetProjectName();
workspaceSourcePath = it->second[0]->GetSourceDirectory();
if (strcmp(it.second[0]->GetCurrentBinaryDirectory(),
it.second[0]->GetBinaryDirectory()) == 0) {
workspaceOutputDir = it.second[0]->GetCurrentBinaryDirectory();
workspaceProjectName = it.second[0]->GetProjectName();
workspaceSourcePath = it.second[0]->GetSourceDirectory();
workspaceFileName = workspaceOutputDir + "/";
workspaceFileName += workspaceProjectName + ".workspace";
this->WorkspacePath = it->second[0]->GetCurrentBinaryDirectory();
this->WorkspacePath = it.second[0]->GetCurrentBinaryDirectory();
;
break;
}
@@ -101,10 +99,9 @@ void cmExtraCodeLiteGenerator::Generate()
xml.Attribute("Name", this->ConfigName);
xml.Attribute("Selected", "yes");
for (std::vector<std::string>::iterator it(ProjectNames.begin());
it != ProjectNames.end(); it++) {
for (std::string const& it : ProjectNames) {
xml.StartElement("Project");
xml.Attribute("Name", *it);
xml.Attribute("Name", it);
xml.Attribute("ConfigName", this->ConfigName);
xml.EndElement();
}
@@ -122,14 +119,11 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByTarget(
// for each target in the workspace create a codelite project
const std::vector<cmLocalGenerator*>& lgs =
this->GlobalGenerator->GetLocalGenerators();
for (std::vector<cmLocalGenerator*>::const_iterator lg(lgs.begin());
lg != lgs.end(); lg++) {
for (std::vector<cmGeneratorTarget*>::const_iterator lt =
(*lg)->GetGeneratorTargets().begin();
lt != (*lg)->GetGeneratorTargets().end(); lt++) {
cmStateEnums::TargetType type = (*lt)->GetType();
std::string outputDir = (*lg)->GetCurrentBinaryDirectory();
std::string targetName = (*lt)->GetName();
for (cmLocalGenerator* lg : lgs) {
for (cmGeneratorTarget* lt : lg->GetGeneratorTargets()) {
cmStateEnums::TargetType type = lt->GetType();
std::string outputDir = lg->GetCurrentBinaryDirectory();
std::string targetName = lt->GetName();
std::string filename = outputDir + "/" + targetName + ".project";
retval.push_back(targetName);
// Make the project file relative to the workspace
@@ -149,7 +143,7 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByTarget(
xml->Attribute("Active", "No");
xml->EndElement();
CreateNewProjectFile(*lt, filename);
CreateNewProjectFile(lt, filename);
break;
default:
break;
@@ -165,12 +159,10 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByProjectMaps(
{
std::vector<std::string> retval;
// for each sub project in the workspace create a codelite project
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it != this->GlobalGenerator->GetProjectMap().end(); it++) {
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
std::string outputDir = it->second[0]->GetCurrentBinaryDirectory();
std::string projectName = it->second[0]->GetProjectName();
std::string outputDir = it.second[0]->GetCurrentBinaryDirectory();
std::string projectName = it.second[0]->GetProjectName();
retval.push_back(projectName);
std::string filename = outputDir + "/" + projectName + ".project";
@@ -179,7 +171,7 @@ std::vector<std::string> cmExtraCodeLiteGenerator::CreateProjectsByProjectMaps(
filename.c_str());
// create a project file
this->CreateProjectFile(it->second);
this->CreateProjectFile(it.second);
xml->StartElement("Project");
xml->Attribute("Name", projectName);
xml->Attribute("Path", filename);
@@ -235,16 +227,14 @@ std::string cmExtraCodeLiteGenerator::CollectSourceFiles(
std::vector<cmSourceFile*> sources;
gt->GetSourceFiles(sources,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
si != sources.end(); si++) {
for (cmSourceFile* s : sources) {
// check whether it is a C/C++ implementation file
bool isCFile = false;
std::string lang = (*si)->GetLanguage();
std::string lang = s->GetLanguage();
if (lang == "C" || lang == "CXX") {
std::string const& srcext = (*si)->GetExtension();
for (std::vector<std::string>::const_iterator ext = srcExts.begin();
ext != srcExts.end(); ++ext) {
if (srcext == *ext) {
std::string const& srcext = s->GetExtension();
for (std::string const& ext : srcExts) {
if (srcext == ext) {
isCFile = true;
break;
}
@@ -253,9 +243,9 @@ std::string cmExtraCodeLiteGenerator::CollectSourceFiles(
// then put it accordingly into one of the two containers
if (isCFile) {
cFiles[(*si)->GetFullPath()] = *si;
cFiles[s->GetFullPath()] = s;
} else {
otherFiles.insert((*si)->GetFullPath());
otherFiles.insert(s->GetFullPath());
}
}
}
@@ -289,14 +279,11 @@ void cmExtraCodeLiteGenerator::CreateNewProjectFile(
std::map<std::string, cmSourceFile*> cFiles;
std::set<std::string> otherFiles;
for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
lg != lgs.end(); lg++) {
cmMakefile* makefile = (*lg)->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets =
(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ti++) {
projectType = CollectSourceFiles(makefile, *ti, cFiles, otherFiles);
for (cmLocalGenerator* lg : lgs) {
cmMakefile* makefile = lg->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
projectType = CollectSourceFiles(makefile, target, cFiles, otherFiles);
}
}
@@ -324,19 +311,16 @@ void cmExtraCodeLiteGenerator::FindMatchingHeaderfiles(
// file exists. If it does, it is inserted into the map of files.
// A very similar version of that code exists also in the kdevelop
// project generator.
for (std::map<std::string, cmSourceFile*>::const_iterator sit =
cFiles.begin();
sit != cFiles.end(); ++sit) {
std::string headerBasename = cmSystemTools::GetFilenamePath(sit->first);
for (auto const& sit : cFiles) {
std::string headerBasename = cmSystemTools::GetFilenamePath(sit.first);
headerBasename += "/";
headerBasename += cmSystemTools::GetFilenameWithoutExtension(sit->first);
headerBasename += cmSystemTools::GetFilenameWithoutExtension(sit.first);
// check if there's a matching header around
for (std::vector<std::string>::const_iterator ext = headerExts.begin();
ext != headerExts.end(); ++ext) {
for (std::string const& ext : headerExts) {
std::string hname = headerBasename;
hname += ".";
hname += *ext;
hname += ext;
// if it's already in the set, don't check if it exists on disk
std::set<std::string>::const_iterator headerIt = otherFiles.find(hname);
if (headerIt != otherFiles.end()) {
@@ -359,10 +343,9 @@ void cmExtraCodeLiteGenerator::CreateFoldersAndFiles(
std::vector<std::string> components;
size_t numOfEndEl = 0;
for (std::set<std::string>::const_iterator it = cFiles.begin();
it != cFiles.end(); ++it) {
for (std::string const& cFile : cFiles) {
std::string frelapath =
cmSystemTools::RelativePath(projectPath.c_str(), it->c_str());
cmSystemTools::RelativePath(projectPath.c_str(), cFile.c_str());
cmsys::SystemTools::SplitPath(frelapath, components, false);
components.pop_back(); // erase last member -> it is file, not folder
components.erase(components.begin()); // erase "root"
@@ -424,10 +407,8 @@ void cmExtraCodeLiteGenerator::CreateFoldersAndFiles(
const std::string& projectPath)
{
std::set<std::string> s;
for (std::map<std::string, cmSourceFile*>::const_iterator it =
cFiles.begin();
it != cFiles.end(); ++it) {
s.insert(it->first);
for (auto const& it : cFiles) {
s.insert(it.first);
}
this->CreateFoldersAndFiles(s, xml, projectPath);
}
Source/cmExtraEclipseCDT4Generator.cxx
+67 -95
View File
@@ -5,7 +5,6 @@
#include "cmsys/RegularExpression.hxx"
#include <algorithm>
#include <assert.h>
#include <map>
#include <sstream>
#include <stdio.h>
#include <utility>
@@ -78,16 +77,15 @@ void cmExtraEclipseCDT4Generator::EnableLanguage(
std::vector<std::string> const& languages, cmMakefile* /*unused*/,
bool /*optional*/)
{
for (std::vector<std::string>::const_iterator lit = languages.begin();
lit != languages.end(); ++lit) {
if (*lit == "CXX") {
for (std::string const& l : languages) {
if (l == "CXX") {
this->Natures.insert("org.eclipse.cdt.core.ccnature");
this->Natures.insert("org.eclipse.cdt.core.cnature");
this->CXXEnabled = true;
} else if (*lit == "C") {
} else if (l == "C") {
this->Natures.insert("org.eclipse.cdt.core.cnature");
this->CEnabled = true;
} else if (*lit == "Java") {
} else if (l == "Java") {
this->Natures.insert("org.eclipse.jdt.core.javanature");
}
}
@@ -382,18 +380,16 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
xml.Element("nature", "org.eclipse.cdt.make.core.ScannerConfigNature");
;
for (std::set<std::string>::const_iterator nit = this->Natures.begin();
nit != this->Natures.end(); ++nit) {
xml.Element("nature", *nit);
for (std::string const& n : this->Natures) {
xml.Element("nature", n);
}
if (const char* extraNaturesProp =
mf->GetState()->GetGlobalProperty("ECLIPSE_EXTRA_NATURES")) {
std::vector<std::string> extraNatures;
cmSystemTools::ExpandListArgument(extraNaturesProp, extraNatures);
for (std::vector<std::string>::const_iterator nit = extraNatures.begin();
nit != extraNatures.end(); ++nit) {
xml.Element("nature", *nit);
for (std::string const& n : extraNatures) {
xml.Element("nature", n);
}
}
@@ -435,25 +431,22 @@ void cmExtraEclipseCDT4Generator::WriteGroups(
std::vector<cmSourceGroup> const& sourceGroups, std::string& linkName,
cmXMLWriter& xml)
{
for (std::vector<cmSourceGroup>::const_iterator sgIt = sourceGroups.begin();
sgIt != sourceGroups.end(); ++sgIt) {
for (cmSourceGroup const& sg : sourceGroups) {
std::string linkName3 = linkName;
linkName3 += "/";
linkName3 += sgIt->GetFullName();
linkName3 += sg.GetFullName();
std::replace(linkName3.begin(), linkName3.end(), '\\', '/');
this->AppendLinkedResource(xml, linkName3, "virtual:/virtual",
VirtualFolder);
std::vector<cmSourceGroup> const& children = sgIt->GetGroupChildren();
std::vector<cmSourceGroup> const& children = sg.GetGroupChildren();
if (!children.empty()) {
this->WriteGroups(children, linkName, xml);
}
std::vector<const cmSourceFile*> sFiles = sgIt->GetSourceFiles();
for (std::vector<const cmSourceFile*>::const_iterator fileIt =
sFiles.begin();
fileIt != sFiles.end(); ++fileIt) {
std::string const& fullPath = (*fileIt)->GetFullPath();
std::vector<const cmSourceFile*> sFiles = sg.GetSourceFiles();
for (cmSourceFile const* file : sFiles) {
std::string const& fullPath = file->GetFullPath();
if (!cmSystemTools::FileIsDirectory(fullPath)) {
std::string linkName4 = linkName3;
@@ -471,28 +464,24 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
std::string linkName = "[Targets]";
this->AppendLinkedResource(xml, linkName, "virtual:/virtual", VirtualFolder);
for (std::vector<cmLocalGenerator*>::const_iterator lgIt =
this->GlobalGenerator->GetLocalGenerators().begin();
lgIt != this->GlobalGenerator->GetLocalGenerators().end(); ++lgIt) {
cmMakefile* makefile = (*lgIt)->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets =
(*lgIt)->GetGeneratorTargets();
for (cmLocalGenerator* lg : this->GlobalGenerator->GetLocalGenerators()) {
cmMakefile* makefile = lg->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti) {
for (cmGeneratorTarget* target : targets) {
std::string linkName2 = linkName;
linkName2 += "/";
switch ((*ti)->GetType()) {
switch (target->GetType()) {
case cmStateEnums::EXECUTABLE:
case cmStateEnums::STATIC_LIBRARY:
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::OBJECT_LIBRARY: {
const char* prefix =
((*ti)->GetType() == cmStateEnums::EXECUTABLE ? "[exe] "
: "[lib] ");
(target->GetType() == cmStateEnums::EXECUTABLE ? "[exe] "
: "[lib] ");
linkName2 += prefix;
linkName2 += (*ti)->GetName();
linkName2 += target->GetName();
this->AppendLinkedResource(xml, linkName2, "virtual:/virtual",
VirtualFolder);
if (!this->GenerateLinkedResources) {
@@ -501,17 +490,16 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
std::vector<cmSourceGroup> sourceGroups =
makefile->GetSourceGroups();
// get the files from the source lists then add them to the groups
cmGeneratorTarget* gt = const_cast<cmGeneratorTarget*>(*ti);
cmGeneratorTarget* gt = const_cast<cmGeneratorTarget*>(target);
std::vector<cmSourceFile*> files;
gt->GetSourceFiles(files,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator sfIt = files.begin();
sfIt != files.end(); sfIt++) {
for (cmSourceFile* sf : files) {
// Add the file to the list of sources.
std::string const& source = (*sfIt)->GetFullPath();
std::string const& source = sf->GetFullPath();
cmSourceGroup* sourceGroup =
makefile->FindSourceGroup(source.c_str(), sourceGroups);
sourceGroup->AssignSource(*sfIt);
sourceGroup->AssignSource(sf);
}
this->WriteGroups(sourceGroups, linkName2, xml);
@@ -536,17 +524,15 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
this->AppendLinkedResource(xml, "[Subprojects]", "virtual:/virtual",
VirtualFolder);
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
std::string linkSourceDirectory =
this->GetEclipsePath(it->second[0]->GetCurrentSourceDirectory());
this->GetEclipsePath(it.second[0]->GetCurrentSourceDirectory());
// a linked resource must not point to a parent directory of .project or
// .project itself
if ((baseDir != linkSourceDirectory) &&
!cmSystemTools::IsSubDirectory(baseDir, linkSourceDirectory)) {
std::string linkName = "[Subprojects]/";
linkName += it->first;
linkName += it.first;
this->AppendLinkedResource(xml, linkName,
this->GetEclipsePath(linkSourceDirectory),
LinkToFolder);
@@ -560,10 +546,9 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
cmXMLWriter& xml, const std::vector<std::string>& includeDirs,
std::set<std::string>& emittedDirs)
{
for (std::vector<std::string>::const_iterator inc = includeDirs.begin();
inc != includeDirs.end(); ++inc) {
if (!inc->empty()) {
std::string dir = cmSystemTools::CollapseFullPath(*inc);
for (std::string const& inc : includeDirs) {
if (!inc.empty()) {
std::string dir = cmSystemTools::CollapseFullPath(inc);
// handle framework include dirs on OSX, the remainder after the
// Frameworks/ part has to be stripped
@@ -712,19 +697,17 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
xml.EndElement();
}
for (std::vector<std::string>::const_iterator it =
this->SrcLinkedResources.begin();
it != this->SrcLinkedResources.end(); ++it) {
for (std::string const& p : this->SrcLinkedResources) {
xml.StartElement("pathentry");
xml.Attribute("kind", "src");
xml.Attribute("path", *it);
xml.Attribute("path", p);
xml.EndElement();
// exlude source directory from output search path
// - only if not named the same as an output directory
if (!cmSystemTools::FileIsDirectory(
std::string(this->HomeOutputDirectory + "/" + *it))) {
excludeFromOut += *it + "/|";
std::string(this->HomeOutputDirectory + "/" + p))) {
excludeFromOut += p + "/|";
}
}
@@ -738,34 +721,31 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// add pre-processor definitions to allow eclipse to gray out sections
emmited.clear();
for (std::vector<cmLocalGenerator*>::const_iterator it =
this->GlobalGenerator->GetLocalGenerators().begin();
it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
for (cmLocalGenerator* lgen : this->GlobalGenerator->GetLocalGenerators()) {
if (const char* cdefs =
(*it)->GetMakefile()->GetProperty("COMPILE_DEFINITIONS")) {
lgen->GetMakefile()->GetProperty("COMPILE_DEFINITIONS")) {
// Expand the list.
std::vector<std::string> defs;
cmGeneratorExpression::Split(cdefs, defs);
for (std::vector<std::string>::const_iterator di = defs.begin();
di != defs.end(); ++di) {
if (cmGeneratorExpression::Find(*di) != std::string::npos) {
for (std::string const& d : defs) {
if (cmGeneratorExpression::Find(d) != std::string::npos) {
continue;
}
std::string::size_type equals = di->find('=', 0);
std::string::size_type enddef = di->length();
std::string::size_type equals = d.find('=', 0);
std::string::size_type enddef = d.length();
std::string def;
std::string val;
if (equals != std::string::npos && equals < enddef) {
// we have -DFOO=BAR
def = di->substr(0, equals);
val = di->substr(equals + 1, enddef - equals + 1);
def = d.substr(0, equals);
val = d.substr(equals + 1, enddef - equals + 1);
} else {
// we have -DFOO
def = *di;
def = d;
}
// insert the definition if not already added.
@@ -850,16 +830,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// include dirs
emmited.clear();
for (std::vector<cmLocalGenerator*>::const_iterator it =
this->GlobalGenerator->GetLocalGenerators().begin();
it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
for (cmLocalGenerator* lgen : this->GlobalGenerator->GetLocalGenerators()) {
const std::vector<cmGeneratorTarget*>& targets =
(*it)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator l = targets.begin();
l != targets.end(); ++l) {
lgen->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
std::vector<std::string> includeDirs;
std::string config = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
(*it)->GetIncludeDirectories(includeDirs, *l, "C", config);
lgen->GetIncludeDirectories(includeDirs, target, "C", config);
this->AppendIncludeDirectories(xml, includeDirs, emmited);
}
}
@@ -908,21 +885,18 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator it =
this->GlobalGenerator->GetLocalGenerators().begin();
it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
for (cmLocalGenerator* lgen : this->GlobalGenerator->GetLocalGenerators()) {
const std::vector<cmGeneratorTarget*>& targets =
(*it)->GetGeneratorTargets();
std::string subdir = (*it)->ConvertToRelativePath(
this->HomeOutputDirectory, (*it)->GetCurrentBinaryDirectory());
lgen->GetGeneratorTargets();
std::string subdir = lgen->ConvertToRelativePath(
this->HomeOutputDirectory, lgen->GetCurrentBinaryDirectory());
if (subdir == ".") {
subdir = "";
}
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti) {
std::string targetName = (*ti)->GetName();
switch ((*ti)->GetType()) {
for (cmGeneratorTarget* target : targets) {
std::string targetName = target->GetName();
switch (target->GetType()) {
case cmStateEnums::GLOBAL_TARGET: {
// Only add the global targets from CMAKE_BINARY_DIR,
// not from the subdirs
@@ -950,8 +924,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::OBJECT_LIBRARY: {
const char* prefix =
((*ti)->GetType() == cmStateEnums::EXECUTABLE ? "[exe] "
: "[lib] ");
(target->GetType() == cmStateEnums::EXECUTABLE ? "[exe] "
: "[lib] ");
this->AppendTarget(xml, targetName, make, makeArgs, subdir, prefix);
std::string fastTarget = targetName;
fastTarget += "/fast";
@@ -963,19 +937,19 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
virtDir += prefix;
virtDir += targetName;
std::string buildArgs = "-C \"";
buildArgs += (*it)->GetBinaryDirectory();
buildArgs += lgen->GetBinaryDirectory();
buildArgs += "\" ";
buildArgs += makeArgs;
this->AppendTarget(xml, "Build", make, buildArgs, virtDir, "",
targetName.c_str());
std::string cleanArgs = "-E chdir \"";
cleanArgs += (*it)->GetCurrentBinaryDirectory();
cleanArgs += lgen->GetCurrentBinaryDirectory();
cleanArgs += "\" \"";
cleanArgs += cmSystemTools::GetCMakeCommand();
cleanArgs += "\" -P \"";
cmGeneratorTarget* gt = *ti;
cleanArgs += (*it)->GetTargetDirectory(gt);
cmGeneratorTarget* gt = target;
cleanArgs += lgen->GetTargetDirectory(gt);
cleanArgs += "/cmake_clean.cmake\"";
this->AppendTarget(xml, "Clean", cmSystemTools::GetCMakeCommand(),
cleanArgs, virtDir, "", "");
@@ -997,17 +971,15 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// insert rules for compiling, preprocessing and assembling individual
// files
std::vector<std::string> objectFileTargets;
(*it)->GetIndividualFileTargets(objectFileTargets);
for (std::vector<std::string>::const_iterator fit =
objectFileTargets.begin();
fit != objectFileTargets.end(); ++fit) {
lg->GetIndividualFileTargets(objectFileTargets);
for (std::string const& f : objectFileTargets) {
const char* prefix = "[obj] ";
if ((*fit)[fit->length() - 1] == 's') {
if (f[f.length() - 1] == 's') {
prefix = "[to asm] ";
} else if ((*fit)[fit->length() - 1] == 'i') {
} else if (f[f.length() - 1] == 'i') {
prefix = "[pre] ";
}
this->AppendTarget(xml, *fit, make, makeArgs, subdir, prefix);
this->AppendTarget(xml, f, make, makeArgs, subdir, prefix);
}
}
Source/cmExtraKateGenerator.cxx
+19 -29
View File
@@ -112,18 +112,16 @@ void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator it =
this->GlobalGenerator->GetLocalGenerators().begin();
it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
for (cmLocalGenerator* localGen :
this->GlobalGenerator->GetLocalGenerators()) {
const std::vector<cmGeneratorTarget*>& targets =
(*it)->GetGeneratorTargets();
std::string currentDir = (*it)->GetCurrentBinaryDirectory();
bool topLevel = (currentDir == (*it)->GetBinaryDirectory());
localGen->GetGeneratorTargets();
std::string currentDir = localGen->GetCurrentBinaryDirectory();
bool topLevel = (currentDir == localGen->GetBinaryDirectory());
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti) {
std::string targetName = (*ti)->GetName();
switch ((*ti)->GetType()) {
for (cmGeneratorTarget* target : targets) {
std::string const& targetName = target->GetName();
switch (target->GetType()) {
case cmStateEnums::GLOBAL_TARGET: {
bool insertTarget = false;
// Only add the global targets from CMAKE_BINARY_DIR,
@@ -134,7 +132,7 @@ void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
// this will not work within the IDE
if (targetName == "edit_cache") {
const char* editCommand =
(*it)->GetMakefile()->GetDefinition("CMAKE_EDIT_COMMAND");
localGen->GetMakefile()->GetDefinition("CMAKE_EDIT_COMMAND");
if (editCommand == nullptr) {
insertTarget = false;
} else if (strstr(editCommand, "ccmake") != nullptr) {
@@ -183,12 +181,9 @@ void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
// insert rules for compiling, preprocessing and assembling individual
// files
std::vector<std::string> objectFileTargets;
(*it)->GetIndividualFileTargets(objectFileTargets);
for (std::vector<std::string>::const_iterator fit =
objectFileTargets.begin();
fit != objectFileTargets.end(); ++fit) {
this->AppendTarget(fout, *fit, make, makeArgs, currentDir,
homeOutputDir);
localGen->GetIndividualFileTargets(objectFileTargets);
for (std::string const& f : objectFileTargets) {
this->AppendTarget(fout, f, make, makeArgs, currentDir, homeOutputDir);
}
}
@@ -251,22 +246,18 @@ std::string cmExtraKateGenerator::GenerateFilesString(
const std::vector<cmLocalGenerator*>& lgs =
this->GlobalGenerator->GetLocalGenerators();
for (std::vector<cmLocalGenerator*>::const_iterator it = lgs.begin();
it != lgs.end(); it++) {
cmMakefile* makefile = (*it)->GetMakefile();
for (cmLocalGenerator* lgen : lgs) {
cmMakefile* makefile = lgen->GetMakefile();
const std::vector<std::string>& listFiles = makefile->GetListFiles();
for (std::vector<std::string>::const_iterator lt = listFiles.begin();
lt != listFiles.end(); lt++) {
tmp = *lt;
for (std::string const& listFile : listFiles) {
tmp = listFile;
{
files.insert(tmp);
}
}
const std::vector<cmSourceFile*>& sources = makefile->GetSourceFiles();
for (std::vector<cmSourceFile*>::const_iterator sfIt = sources.begin();
sfIt != sources.end(); sfIt++) {
cmSourceFile* sf = *sfIt;
for (cmSourceFile* sf : sources) {
if (sf->GetPropertyAsBool("GENERATED")) {
continue;
}
@@ -278,11 +269,10 @@ std::string cmExtraKateGenerator::GenerateFilesString(
const char* sep = "";
tmp = "\"list\": [";
for (std::set<std::string>::const_iterator it = files.begin();
it != files.end(); ++it) {
for (std::string const& f : files) {
tmp += sep;
tmp += " \"";
tmp += *it;
tmp += f;
tmp += "\"";
sep = ",";
}
Source/cmExtraSublimeTextGenerator.cxx
+23 -32
View File
@@ -68,11 +68,9 @@ void cmExtraSublimeTextGenerator::Generate()
"CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS");
// for each sub project in the project create a sublime text 2 project
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
// create a project file
this->CreateProjectFile(it->second);
this->CreateProjectFile(it.second);
}
}
@@ -144,20 +142,19 @@ void cmExtraSublimeTextGenerator::CreateNewProjectFile(
fout << "\n\t{";
fout << "\n\t\t" << systemName << ":";
fout << "\n\t\t{";
for (std::vector<std::string>::iterator i = tokens.begin();
i != tokens.end(); ++i) {
size_t const pos = i->find_first_of('=');
for (std::string const& t : tokens) {
size_t const pos = t.find_first_of('=');
if (pos != std::string::npos) {
std::string varName = i->substr(0, pos);
std::string varValue = i->substr(pos + 1);
std::string varName = t.substr(0, pos);
std::string varValue = t.substr(pos + 1);
fout << "\n\t\t\t\"" << varName << "\":\"" << varValue << "\"";
} else {
std::ostringstream e;
e << "Could not parse Env Vars specified in "
"\"CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS\""
<< ", corrupted string " << *i;
<< ", corrupted string " << t;
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
}
}
@@ -182,21 +179,18 @@ void cmExtraSublimeTextGenerator::AppendAllTargets(
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
lg != lgs.end(); lg++) {
cmMakefile* makefile = (*lg)->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets =
(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ti++) {
std::string targetName = (*ti)->GetName();
switch ((*ti)->GetType()) {
for (cmLocalGenerator* lg : lgs) {
cmMakefile* makefile = lg->GetMakefile();
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
std::string targetName = target->GetName();
switch (target->GetType()) {
case cmStateEnums::GLOBAL_TARGET: {
// Only add the global targets from CMAKE_BINARY_DIR,
// not from the subdirs
if (strcmp((*lg)->GetCurrentBinaryDirectory(),
(*lg)->GetBinaryDirectory()) == 0) {
this->AppendTarget(fout, targetName, *lg, nullptr, make.c_str(),
if (strcmp(lg->GetCurrentBinaryDirectory(),
lg->GetBinaryDirectory()) == 0) {
this->AppendTarget(fout, targetName, lg, nullptr, make.c_str(),
makefile, compiler.c_str(), sourceFileFlags,
false);
}
@@ -213,7 +207,7 @@ void cmExtraSublimeTextGenerator::AppendAllTargets(
break;
}
this->AppendTarget(fout, targetName, *lg, nullptr, make.c_str(),
this->AppendTarget(fout, targetName, lg, nullptr, make.c_str(),
makefile, compiler.c_str(), sourceFileFlags,
false);
break;
@@ -222,12 +216,12 @@ void cmExtraSublimeTextGenerator::AppendAllTargets(
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::OBJECT_LIBRARY: {
this->AppendTarget(fout, targetName, *lg, *ti, make.c_str(),
this->AppendTarget(fout, targetName, lg, target, make.c_str(),
makefile, compiler.c_str(), sourceFileFlags,
false);
std::string fastTarget = targetName;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget, *lg, *ti, make.c_str(),
this->AppendTarget(fout, fastTarget, lg, target, make.c_str(),
makefile, compiler.c_str(), sourceFileFlags,
false);
} break;
@@ -249,11 +243,7 @@ void cmExtraSublimeTextGenerator::AppendTarget(
std::vector<cmSourceFile*> sourceFiles;
target->GetSourceFiles(sourceFiles,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
std::vector<cmSourceFile*>::const_iterator sourceFilesEnd =
sourceFiles.end();
for (std::vector<cmSourceFile*>::const_iterator iter = sourceFiles.begin();
iter != sourceFilesEnd; ++iter) {
cmSourceFile* sourceFile = *iter;
for (cmSourceFile* sourceFile : sourceFiles) {
MapSourceFileFlags::iterator sourceFileFlagsIter =
sourceFileFlags.find(sourceFile->GetFullPath());
if (sourceFileFlagsIter == sourceFileFlags.end()) {
@@ -264,8 +254,9 @@ void cmExtraSublimeTextGenerator::AppendTarget(
.first;
}
std::vector<std::string>& flags = sourceFileFlagsIter->second;
std::string flagsString = this->ComputeFlagsForObject(*iter, lg, target);
std::string definesString = this->ComputeDefines(*iter, lg, target);
std::string flagsString =
this->ComputeFlagsForObject(sourceFile, lg, target);
std::string definesString = this->ComputeDefines(sourceFile, lg, target);
flags.clear();
cmsys::RegularExpression flagRegex;
// Regular expression to extract compiler flags from a string
Source/cmFileCommand.cxx
+21 -28
View File
@@ -723,20 +723,18 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
// Encode the result in a CMake list.
const char* sep = "";
std::string output;
for (std::vector<std::string>::const_iterator si = strings.begin();
si != strings.end(); ++si) {
for (std::string const& sr : strings) {
// Separate the strings in the output to make it a list.
output += sep;
sep = ";";
// Store the string in the output, but escape semicolons to
// make sure it is a list.
std::string const& sr = *si;
for (unsigned int i = 0; i < sr.size(); ++i) {
if (sr[i] == ';') {
for (char i : sr) {
if (i == ';') {
output += '\\';
}
output += sr[i];
output += i;
}
}
@@ -841,17 +839,16 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
if (!globMessages.empty()) {
bool shouldExit = false;
for (cmsys::Glob::GlobMessagesIterator it = globMessages.begin();
it != globMessages.end(); ++it) {
if (it->type == cmsys::Glob::cyclicRecursion) {
for (cmsys::Glob::Message const& globMessage : globMessages) {
if (globMessage.type == cmsys::Glob::cyclicRecursion) {
this->Makefile->IssueMessage(
cmake::AUTHOR_WARNING,
"Cyclic recursion detected while globbing for '" + *i + "':\n" +
it->content);
globMessage.content);
} else {
this->Makefile->IssueMessage(
cmake::FATAL_ERROR, "Error has occurred while globbing for '" +
*i + "' - " + it->content);
*i + "' - " + globMessage.content);
shouldExit = true;
}
}
@@ -1060,12 +1057,11 @@ protected:
// Collect properties from all matching rules.
bool matched = false;
MatchProperties result;
for (std::vector<MatchRule>::iterator mr = this->MatchRules.begin();
mr != this->MatchRules.end(); ++mr) {
if (mr->Regex.find(file_to_match)) {
for (MatchRule& mr : this->MatchRules) {
if (mr.Regex.find(file_to_match)) {
matched = true;
result.Exclude |= mr->Properties.Exclude;
result.Permissions |= mr->Properties.Permissions;
result.Exclude |= mr.Properties.Exclude;
result.Permissions |= mr.Properties.Permissions;
}
}
if (!matched && !this->MatchlessFiles) {
@@ -1421,23 +1417,22 @@ bool cmFileCopier::Run(std::vector<std::string> const& args)
return false;
}
for (std::vector<std::string>::const_iterator i = this->Files.begin();
i != this->Files.end(); ++i) {
for (std::string const& f : this->Files) {
std::string file;
if (!i->empty() && !cmSystemTools::FileIsFullPath(*i)) {
if (!f.empty() && !cmSystemTools::FileIsFullPath(f)) {
if (!this->FilesFromDir.empty()) {
file = this->FilesFromDir;
} else {
file = this->Makefile->GetCurrentSourceDirectory();
}
file += "/";
file += *i;
file += f;
} else if (!this->FilesFromDir.empty()) {
this->FileCommand->SetError("option FILES_FROM_DIR requires all files "
"to be specified as relative paths.");
return false;
} else {
file = *i;
file = f;
}
// Split the input file into its directory and name components.
@@ -1450,7 +1445,7 @@ bool cmFileCopier::Run(std::vector<std::string> const& args)
// Compute the full path to the destination file.
std::string toFile = this->Destination;
if (!this->FilesFromDir.empty()) {
std::string dir = cmSystemTools::GetFilenamePath(*i);
std::string dir = cmSystemTools::GetFilenamePath(f);
if (!dir.empty()) {
toFile += "/";
toFile += dir;
@@ -2882,9 +2877,8 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
}
struct curl_slist* headers = nullptr;
for (std::vector<std::string>::const_iterator h = curl_headers.begin();
h != curl_headers.end(); ++h) {
headers = ::curl_slist_append(headers, h->c_str());
for (std::string const& h : curl_headers) {
headers = ::curl_slist_append(headers, h.c_str());
}
::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
@@ -3141,9 +3135,8 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
}
struct curl_slist* headers = nullptr;
for (std::vector<std::string>::const_iterator h = curl_headers.begin();
h != curl_headers.end(); ++h) {
headers = ::curl_slist_append(headers, h->c_str());
for (std::string const& h : curl_headers) {
headers = ::curl_slist_append(headers, h.c_str());
}
::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
Source/cmFileLockPool.cxx
+13 -15
View File
@@ -75,16 +75,15 @@ cmFileLockResult cmFileLockPool::LockProcessScope(const std::string& filename,
cmFileLockResult cmFileLockPool::Release(const std::string& filename)
{
for (It i = this->FunctionScopes.begin(); i != this->FunctionScopes.end();
++i) {
const cmFileLockResult result = (*i)->Release(filename);
for (auto& funcScope : this->FunctionScopes) {
const cmFileLockResult result = funcScope->Release(filename);
if (!result.IsOk()) {
return result;
}
}
for (It i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i) {
const cmFileLockResult result = (*i)->Release(filename);
for (auto& fileScope : this->FileScopes) {
const cmFileLockResult result = fileScope->Release(filename);
if (!result.IsOk()) {
return result;
}
@@ -95,16 +94,15 @@ cmFileLockResult cmFileLockPool::Release(const std::string& filename)
bool cmFileLockPool::IsAlreadyLocked(const std::string& filename) const
{
for (CIt i = this->FunctionScopes.begin(); i != this->FunctionScopes.end();
++i) {
const bool result = (*i)->IsAlreadyLocked(filename);
for (auto const& funcScope : this->FunctionScopes) {
const bool result = funcScope->IsAlreadyLocked(filename);
if (result) {
return true;
}
}
for (CIt i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i) {
const bool result = (*i)->IsAlreadyLocked(filename);
for (auto const& fileScope : this->FileScopes) {
const bool result = fileScope->IsAlreadyLocked(filename);
if (result) {
return true;
}
@@ -138,9 +136,9 @@ cmFileLockResult cmFileLockPool::ScopePool::Lock(const std::string& filename,
cmFileLockResult cmFileLockPool::ScopePool::Release(
const std::string& filename)
{
for (It i = this->Locks.begin(); i != this->Locks.end(); ++i) {
if ((*i)->IsLocked(filename)) {
return (*i)->Release();
for (auto& lock : this->Locks) {
if (lock->IsLocked(filename)) {
return lock->Release();
}
}
return cmFileLockResult::MakeOk();
@@ -149,8 +147,8 @@ cmFileLockResult cmFileLockPool::ScopePool::Release(
bool cmFileLockPool::ScopePool::IsAlreadyLocked(
const std::string& filename) const
{
for (CIt i = this->Locks.begin(); i != this->Locks.end(); ++i) {
if ((*i)->IsLocked(filename)) {
for (auto const& lock : this->Locks) {
if (lock->IsLocked(filename)) {
return true;
}
}
Source/cmFileMonitor.cxx
+17 -16
View File
@@ -49,8 +49,8 @@ public:
int status) const final
{
if (pathSegment.empty()) {
for (const auto& i : this->Children) {
i.second->Trigger(std::string(), events, status);
for (auto const& child : this->Children) {
child.second->Trigger(std::string(), events, status);
}
} else {
const auto i = this->Children.find(pathSegment);
@@ -62,24 +62,24 @@ public:
void StartWatching() override
{
for (const auto& i : this->Children) {
i.second->StartWatching();
for (auto const& child : this->Children) {
child.second->StartWatching();
}
}
void StopWatching() override
{
for (const auto& i : this->Children) {
i.second->StopWatching();
for (auto const& child : this->Children) {
child.second->StopWatching();
}
}
std::vector<std::string> WatchedFiles() const final
{
std::vector<std::string> result;
for (const auto& i : this->Children) {
for (const auto& j : i.second->WatchedFiles()) {
result.push_back(j);
for (auto const& child : this->Children) {
for (std::string const& f : child.second->WatchedFiles()) {
result.push_back(f);
}
}
return result;
@@ -88,9 +88,9 @@ public:
std::vector<std::string> WatchedDirectories() const override
{
std::vector<std::string> result;
for (const auto& i : this->Children) {
for (const auto& j : i.second->WatchedDirectories()) {
result.push_back(j);
for (auto const& child : this->Children) {
for (std::string const& dir : child.second->WatchedDirectories()) {
result.push_back(dir);
}
}
return result;
@@ -184,8 +184,9 @@ public:
std::vector<std::string> WatchedDirectories() const override
{
std::vector<std::string> result = { Path() };
for (const auto& j : cmVirtualDirectoryWatcher::WatchedDirectories()) {
result.push_back(j);
for (std::string const& dir :
cmVirtualDirectoryWatcher::WatchedDirectories()) {
result.push_back(dir);
}
return result;
}
@@ -267,7 +268,7 @@ public:
static_cast<void>(ps);
const std::string path = this->Path();
for (const auto& cb : this->CbList) {
for (cmFileMonitor::Callback const& cb : this->CbList) {
cb(path, events, status);
}
}
@@ -311,7 +312,7 @@ cmFileMonitor::~cmFileMonitor()
void cmFileMonitor::MonitorPaths(const std::vector<std::string>& paths,
Callback const& cb)
{
for (const auto& p : paths) {
for (std::string const& p : paths) {
std::vector<std::string> pathSegments;
cmsys::SystemTools::SplitPath(p, pathSegments, true);
Source/cmFindBase.cxx
+4 -8
View File
@@ -280,10 +280,8 @@ void cmFindBase::FillUserHintsPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints];
for (std::vector<std::string>::const_iterator p =
this->UserHintsArgs.begin();
p != this->UserHintsArgs.end(); ++p) {
paths.AddUserPath(*p);
for (std::string const& p : this->UserHintsArgs) {
paths.AddUserPath(p);
}
paths.AddSuffixes(this->SearchPathSuffixes);
}
@@ -292,10 +290,8 @@ void cmFindBase::FillUserGuessPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess];
for (std::vector<std::string>::const_iterator p =
this->UserGuessArgs.begin();
p != this->UserGuessArgs.end(); ++p) {
paths.AddUserPath(*p);
for (std::string const& p : this->UserGuessArgs) {
paths.AddUserPath(p);
}
paths.AddSuffixes(this->SearchPathSuffixes);
}
Source/cmFindCommon.cxx
+16 -22
View File
@@ -155,10 +155,9 @@ void cmFindCommon::SelectDefaultMacMode()
void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
{
#if 0
for(std::vector<std::string>::const_iterator i = paths.begin();
i != paths.end(); ++i)
for(std::string const& p : paths)
{
fprintf(stderr, "[%s]\n", i->c_str());
fprintf(stderr, "[%s]\n", p.c_str());
}
#endif
// Short-circuit if there is nothing to do.
@@ -194,9 +193,8 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
if (sysroot) {
roots.push_back(sysroot);
}
for (std::vector<std::string>::iterator ri = roots.begin();
ri != roots.end(); ++ri) {
cmSystemTools::ConvertToUnixSlashes(*ri);
for (std::string& r : roots) {
cmSystemTools::ConvertToUnixSlashes(r);
}
const char* stagePrefix =
@@ -206,24 +204,22 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
std::vector<std::string> unrootedPaths = paths;
paths.clear();
for (std::vector<std::string>::const_iterator ri = roots.begin();
ri != roots.end(); ++ri) {
for (std::vector<std::string>::const_iterator ui = unrootedPaths.begin();
ui != unrootedPaths.end(); ++ui) {
for (std::string const& r : roots) {
for (std::string const& up : unrootedPaths) {
// Place the unrooted path under the current root if it is not
// already inside. Skip the unrooted path if it is relative to
// a user home directory or is empty.
std::string rootedDir;
if (cmSystemTools::IsSubDirectory(*ui, *ri) ||
(stagePrefix && cmSystemTools::IsSubDirectory(*ui, stagePrefix))) {
rootedDir = *ui;
} else if (!ui->empty() && (*ui)[0] != '~') {
if (cmSystemTools::IsSubDirectory(up, r) ||
(stagePrefix && cmSystemTools::IsSubDirectory(up, stagePrefix))) {
rootedDir = up;
} else if (!up.empty() && up[0] != '~') {
// Start with the new root.
rootedDir = *ri;
rootedDir = r;
rootedDir += "/";
// Append the original path with its old root removed.
rootedDir += cmSystemTools::SplitPathRootComponent(*ui);
rootedDir += cmSystemTools::SplitPathRootComponent(up);
}
// Store the new path.
@@ -255,9 +251,8 @@ void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore)
cmSystemTools::ExpandListArgument(ignorePath, ignore);
}
for (std::vector<std::string>::iterator i = ignore.begin();
i != ignore.end(); ++i) {
cmSystemTools::ConvertToUnixSlashes(*i);
for (std::string& i : ignore) {
cmSystemTools::ConvertToUnixSlashes(i);
}
}
@@ -337,9 +332,8 @@ void cmFindCommon::ComputeFinalPaths()
// Combine the seperate path types, filtering out ignores
this->SearchPaths.clear();
std::vector<PathLabel>& allLabels = this->PathGroupLabelMap[PathGroup::All];
for (std::vector<PathLabel>::const_iterator l = allLabels.begin();
l != allLabels.end(); ++l) {
this->LabeledPaths[*l].ExtractWithout(ignored, this->SearchPaths);
for (PathLabel const& l : allLabels) {
this->LabeledPaths[l].ExtractWithout(ignored, this->SearchPaths);
}
// Expand list of paths inside all search roots.
Source/cmFindLibraryCommand.cxx
+25 -43
View File
@@ -87,9 +87,8 @@ void cmFindLibraryCommand::AddArchitecturePaths(const char* suffix)
{
std::vector<std::string> original;
original.swap(this->SearchPaths);
for (std::vector<std::string>::const_iterator i = original.begin();
i != original.end(); ++i) {
this->AddArchitecturePath(*i, 0, suffix);
for (std::string const& o : original) {
this->AddArchitecturePath(o, 0, suffix);
}
}
@@ -254,8 +253,7 @@ cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf)
void cmFindLibraryHelper::RegexFromLiteral(std::string& out,
std::string const& in)
{
for (std::string::const_iterator ci = in.begin(); ci != in.end(); ++ci) {
char ch = *ci;
for (char ch : in) {
if (ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == '\\' ||
ch == '.' || ch == '*' || ch == '+' || ch == '?' || ch == '-' ||
ch == '^' || ch == '$') {
@@ -276,23 +274,20 @@ void cmFindLibraryHelper::RegexFromList(std::string& out,
// else and the result can be checked after matching.
out += "(";
const char* sep = "";
for (std::vector<std::string>::const_iterator si = in.begin();
si != in.end(); ++si) {
for (std::string const& s : in) {
// Separate from previous item.
out += sep;
sep = "|";
// Append this item.
this->RegexFromLiteral(out, *si);
this->RegexFromLiteral(out, s);
}
out += ")";
}
bool cmFindLibraryHelper::HasValidSuffix(std::string const& name)
{
for (std::vector<std::string>::const_iterator si = this->Suffixes.begin();
si != this->Suffixes.end(); ++si) {
std::string suffix = *si;
for (std::string suffix : this->Suffixes) {
if (name.length() <= suffix.length()) {
continue;
}
@@ -339,9 +334,8 @@ void cmFindLibraryHelper::SetName(std::string const& name)
bool cmFindLibraryHelper::CheckDirectory(std::string const& path)
{
for (std::vector<Name>::iterator i = this->Names.begin();
i != this->Names.end(); ++i) {
if (this->CheckDirectoryForName(path, *i)) {
for (Name& i : this->Names) {
if (this->CheckDirectoryForName(path, i)) {
return true;
}
}
@@ -376,9 +370,7 @@ bool cmFindLibraryHelper::CheckDirectoryForName(std::string const& path,
std::string dir = path;
cmSystemTools::ConvertToUnixSlashes(dir);
std::set<std::string> const& files = this->GG->GetDirectoryContent(dir);
for (std::set<std::string>::const_iterator fi = files.begin();
fi != files.end(); ++fi) {
std::string const& origName = *fi;
for (std::string const& origName : files) {
#if defined(_WIN32) || defined(__APPLE__)
std::string testName = cmSystemTools::LowerCase(origName);
#else
@@ -430,14 +422,12 @@ std::string cmFindLibraryCommand::FindNormalLibraryNamesPerDir()
{
// Search for all names in each directory.
cmFindLibraryHelper helper(this->Makefile);
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
helper.AddName(*ni);
for (std::string const& n : this->Names) {
helper.AddName(n);
}
// Search every directory.
for (std::vector<std::string>::const_iterator p = this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
if (helper.CheckDirectory(*p)) {
for (std::string const& sp : this->SearchPaths) {
if (helper.CheckDirectory(sp)) {
return helper.BestPath;
}
}
@@ -449,16 +439,13 @@ std::string cmFindLibraryCommand::FindNormalLibraryDirsPerName()
{
// Search the entire path for each name.
cmFindLibraryHelper helper(this->Makefile);
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
for (std::string const& n : this->Names) {
// Switch to searching for this name.
helper.SetName(*ni);
helper.SetName(n);
// Search every directory.
for (std::vector<std::string>::const_iterator p =
this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
if (helper.CheckDirectory(*p)) {
for (std::string const& sp : this->SearchPaths) {
if (helper.CheckDirectory(sp)) {
return helper.BestPath;
}
}
@@ -479,12 +466,10 @@ std::string cmFindLibraryCommand::FindFrameworkLibraryNamesPerDir()
{
std::string fwPath;
// Search for all names in each search path.
for (std::vector<std::string>::const_iterator di = this->SearchPaths.begin();
di != this->SearchPaths.end(); ++di) {
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
fwPath = *di;
fwPath += *ni;
for (std::string const& d : this->SearchPaths) {
for (std::string const& n : this->Names) {
fwPath = d;
fwPath += n;
fwPath += ".framework";
if (cmSystemTools::FileIsDirectory(fwPath)) {
return cmSystemTools::CollapseFullPath(fwPath);
@@ -500,13 +485,10 @@ std::string cmFindLibraryCommand::FindFrameworkLibraryDirsPerName()
{
std::string fwPath;
// Search for each name in all search paths.
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
for (std::vector<std::string>::const_iterator di =
this->SearchPaths.begin();
di != this->SearchPaths.end(); ++di) {
fwPath = *di;
fwPath += *ni;
for (std::string const& n : this->Names) {
for (std::string const& d : this->SearchPaths) {
fwPath = d;
fwPath += n;
fwPath += ".framework";
if (cmSystemTools::FileIsDirectory(fwPath)) {
return cmSystemTools::CollapseFullPath(fwPath);
Source/cmFindPackageCommand.cxx
+47 -74
View File
@@ -367,14 +367,12 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args,
if (!this->UseFindModules && !this->UseConfigFiles) {
std::ostringstream e;
e << "given options exclusive to Module mode:\n";
for (std::set<unsigned int>::const_iterator si = moduleArgs.begin();
si != moduleArgs.end(); ++si) {
e << " " << args[*si] << "\n";
for (unsigned int si : moduleArgs) {
e << " " << args[si] << "\n";
}
e << "and options exclusive to Config mode:\n";
for (std::set<unsigned int>::const_iterator si = configArgs.begin();
si != configArgs.end(); ++si) {
e << " " << args[*si] << "\n";
for (unsigned int si : configArgs) {
e << " " << args[si] << "\n";
}
e << "The options are incompatible.";
this->SetError(e.str());
@@ -518,13 +516,12 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args,
// Add the default configs.
if (this->Configs.empty()) {
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
std::string config = *ni;
for (std::string const& n : this->Names) {
std::string config = n;
config += "Config.cmake";
this->Configs.push_back(config);
config = cmSystemTools::LowerCase(*ni);
config = cmSystemTools::LowerCase(n);
config += "-config.cmake";
this->Configs.push_back(config);
}
@@ -611,14 +608,12 @@ void cmFindPackageCommand::AddFindDefinition(const std::string& var,
void cmFindPackageCommand::RestoreFindDefinitions()
{
for (std::map<std::string, OriginalDef>::iterator i =
this->OriginalDefs.begin();
i != this->OriginalDefs.end(); ++i) {
OriginalDef const& od = i->second;
for (auto const& i : this->OriginalDefs) {
OriginalDef const& od = i.second;
if (od.exists) {
this->Makefile->AddDefinition(i->first, od.value.c_str());
this->Makefile->AddDefinition(i.first, od.value.c_str());
} else {
this->Makefile->RemoveDefinition(i->first);
this->Makefile->RemoveDefinition(i.first);
}
}
}
@@ -874,13 +869,11 @@ bool cmFindPackageCommand::HandlePackageMode()
std::string consideredVersions;
const char* sep = "";
for (std::vector<ConfigFileInfo>::const_iterator i =
this->ConsideredConfigs.begin();
i != this->ConsideredConfigs.end(); ++i) {
for (ConfigFileInfo const& i : this->ConsideredConfigs) {
consideredConfigFiles += sep;
consideredVersions += sep;
consideredConfigFiles += i->filename;
consideredVersions += i->version;
consideredConfigFiles += i.filename;
consideredVersions += i.version;
sep = ";";
}
@@ -946,9 +939,8 @@ bool cmFindPackageCommand::FindConfig()
bool cmFindPackageCommand::FindPrefixedConfig()
{
std::vector<std::string> const& prefixes = this->SearchPaths;
for (std::vector<std::string>::const_iterator pi = prefixes.begin();
pi != prefixes.end(); ++pi) {
if (this->SearchPrefix(*pi)) {
for (std::string const& p : prefixes) {
if (this->SearchPrefix(p)) {
return true;
}
}
@@ -958,9 +950,8 @@ bool cmFindPackageCommand::FindPrefixedConfig()
bool cmFindPackageCommand::FindFrameworkConfig()
{
std::vector<std::string> const& prefixes = this->SearchPaths;
for (std::vector<std::string>::const_iterator i = prefixes.begin();
i != prefixes.end(); ++i) {
if (this->SearchFrameworkPrefix(*i)) {
for (std::string const& p : prefixes) {
if (this->SearchFrameworkPrefix(p)) {
return true;
}
}
@@ -970,9 +961,8 @@ bool cmFindPackageCommand::FindFrameworkConfig()
bool cmFindPackageCommand::FindAppBundleConfig()
{
std::vector<std::string> const& prefixes = this->SearchPaths;
for (std::vector<std::string>::const_iterator i = prefixes.begin();
i != prefixes.end(); ++i) {
if (this->SearchAppBundlePrefix(*i)) {
for (std::string const& p : prefixes) {
if (this->SearchAppBundlePrefix(p)) {
return true;
}
}
@@ -1171,14 +1161,12 @@ void cmFindPackageCommand::FillPrefixesSystemEnvironment()
// working directory.
std::vector<std::string> tmp;
cmSystemTools::GetPath(tmp);
for (std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end();
++i) {
for (std::string const& i : tmp) {
// If the path is a PREFIX/bin case then add its parent instead.
if ((cmHasLiteralSuffix(*i, "/bin")) ||
(cmHasLiteralSuffix(*i, "/sbin"))) {
paths.AddPath(cmSystemTools::GetFilenamePath(*i));
if ((cmHasLiteralSuffix(i, "/bin")) || (cmHasLiteralSuffix(i, "/sbin"))) {
paths.AddPath(cmSystemTools::GetFilenamePath(i));
} else {
paths.AddPath(*i);
paths.AddPath(i);
}
}
}
@@ -1296,9 +1284,8 @@ void cmFindPackageCommand::LoadPackageRegistryWin(bool user, unsigned int view,
if (user && !bad.empty() &&
RegOpenKeyExW(HKEY_CURRENT_USER, key.c_str(), 0, KEY_SET_VALUE | view,
&hKey) == ERROR_SUCCESS) {
for (std::set<std::wstring>::const_iterator vi = bad.begin();
vi != bad.end(); ++vi) {
RegDeleteValueW(hKey, vi->c_str());
for (std::wstring const& v : bad) {
RegDeleteValueW(hKey, v.c_str());
}
RegCloseKey(hKey);
}
@@ -1395,10 +1382,8 @@ void cmFindPackageCommand::FillPrefixesUserGuess()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess];
for (std::vector<std::string>::const_iterator p =
this->UserGuessArgs.begin();
p != this->UserGuessArgs.end(); ++p) {
paths.AddUserPath(*p);
for (std::string const& p : this->UserGuessArgs) {
paths.AddUserPath(p);
}
}
@@ -1406,10 +1391,8 @@ void cmFindPackageCommand::FillPrefixesUserHints()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints];
for (std::vector<std::string>::const_iterator p =
this->UserHintsArgs.begin();
p != this->UserHintsArgs.end(); ++p) {
paths.AddUserPath(*p);
for (std::string const& p : this->UserHintsArgs) {
paths.AddUserPath(p);
}
}
@@ -1418,12 +1401,10 @@ bool cmFindPackageCommand::SearchDirectory(std::string const& dir)
assert(!dir.empty() && dir[dir.size() - 1] == '/');
// Check each path suffix on this directory.
for (std::vector<std::string>::const_iterator si =
this->SearchPathSuffixes.begin();
si != this->SearchPathSuffixes.end(); ++si) {
for (std::string const& s : this->SearchPathSuffixes) {
std::string d = dir;
if (!si->empty()) {
d += *si;
if (!s.empty()) {
d += s;
d += "/";
}
if (this->CheckDirectory(d)) {
@@ -1454,11 +1435,10 @@ bool cmFindPackageCommand::FindConfigFile(std::string const& dir,
return false;
}
for (std::vector<std::string>::const_iterator ci = this->Configs.begin();
ci != this->Configs.end(); ++ci) {
for (std::string const& c : this->Configs) {
file = dir;
file += "/";
file += *ci;
file += c;
if (this->DebugMode) {
fprintf(stderr, "Checking file [%s]\n", file.c_str());
}
@@ -1761,9 +1741,8 @@ private:
std::vector<std::string> const& Vector;
bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE
{
for (std::vector<std::string>::const_iterator i = this->Vector.begin();
i != this->Vector.end(); ++i) {
if (this->Consider(parent + *i, lister)) {
for (std::string const& i : this->Vector) {
if (this->Consider(parent + i, lister)) {
return true;
}
}
@@ -1820,9 +1799,8 @@ private:
if (strcmp(fname, ".") == 0 || strcmp(fname, "..") == 0) {
continue;
}
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
if (cmsysString_strncasecmp(fname, ni->c_str(), ni->length()) == 0) {
for (std::string const& n : this->Names) {
if (cmsysString_strncasecmp(fname, n.c_str(), n.length()) == 0) {
matches.push_back(fname);
}
}
@@ -1835,9 +1813,8 @@ private:
SortDirection);
}
for (std::vector<std::string>::const_iterator i = matches.begin();
i != matches.end(); ++i) {
if (this->Consider(parent + *i, lister)) {
for (std::string const& i : matches) {
if (this->Consider(parent + i, lister)) {
return true;
}
}
@@ -1882,9 +1859,7 @@ private:
if (strcmp(fname, ".") == 0 || strcmp(fname, "..") == 0) {
continue;
}
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
std::string name = *ni;
for (std::string name : this->Names) {
name += this->Extension;
if (cmsysString_strcasecmp(fname, name.c_str()) == 0) {
matches.push_back(fname);
@@ -1892,9 +1867,8 @@ private:
}
}
for (std::vector<std::string>::const_iterator i = matches.begin();
i != matches.end(); ++i) {
if (this->Consider(parent + *i, lister)) {
for (std::string const& i : matches) {
if (this->Consider(parent + i, lister)) {
return true;
}
}
@@ -1980,10 +1954,9 @@ private:
std::vector<std::string> const& files = g.GetFiles();
// Look for directories among the matches.
for (std::vector<std::string>::const_iterator fi = files.begin();
fi != files.end(); ++fi) {
if (cmSystemTools::FileIsDirectory(*fi)) {
if (this->Consider(*fi, lister)) {
for (std::string const& f : files) {
if (cmSystemTools::FileIsDirectory(f)) {
if (this->Consider(f, lister)) {
return true;
}
}
Source/cmFindPathCommand.cxx
+8 -14
View File
@@ -124,18 +124,15 @@ std::string cmFindPathCommand::FindHeaderInFramework(std::string const& file,
std::string cmFindPathCommand::FindNormalHeader()
{
std::string tryPath;
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
for (std::vector<std::string>::const_iterator p =
this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
tryPath = *p;
tryPath += *ni;
for (std::string const& n : this->Names) {
for (std::string const& sp : this->SearchPaths) {
tryPath = sp;
tryPath += n;
if (cmSystemTools::FileExists(tryPath.c_str())) {
if (this->IncludeFileInPath) {
return tryPath;
}
return *p;
return sp;
}
}
}
@@ -144,12 +141,9 @@ std::string cmFindPathCommand::FindNormalHeader()
std::string cmFindPathCommand::FindFrameworkHeader()
{
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
for (std::vector<std::string>::const_iterator p =
this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
std::string fwPath = this->FindHeaderInFramework(*ni, *p);
for (std::string const& n : this->Names) {
for (std::string const& sp : this->SearchPaths) {
std::string fwPath = this->FindHeaderInFramework(n, sp);
if (!fwPath.empty()) {
return fwPath;
}
Source/cmFindProgramCommand.cxx
+15 -23
View File
@@ -45,9 +45,8 @@ struct cmFindProgramHelper
}
bool CheckDirectory(std::string const& path)
{
for (std::vector<std::string>::iterator i = this->Names.begin();
i != this->Names.end(); ++i) {
if (this->CheckDirectoryForName(path, *i)) {
for (std::string const& n : this->Names) {
if (this->CheckDirectoryForName(path, n)) {
return true;
}
}
@@ -55,14 +54,13 @@ struct cmFindProgramHelper
}
bool CheckDirectoryForName(std::string const& path, std::string const& name)
{
for (std::vector<std::string>::iterator ext = this->Extensions.begin();
ext != this->Extensions.end(); ++ext) {
for (std::string const& ext : this->Extensions) {
this->TestPath = path;
this->TestPath += name;
if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str())) {
if (!ext.empty() && cmSystemTools::StringEndsWith(name, ext.c_str())) {
continue;
}
this->TestPath += *ext;
this->TestPath += ext;
if (cmSystemTools::FileExists(this->TestPath, true)) {
this->BestPath = cmSystemTools::CollapseFullPath(this->TestPath);
return true;
@@ -143,9 +141,8 @@ std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
{
// Search for all names in each directory.
cmFindProgramHelper helper;
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
helper.AddName(*ni);
for (std::string const& n : this->Names) {
helper.AddName(n);
}
// Check for the names themselves (e.g. absolute paths).
@@ -154,9 +151,8 @@ std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
}
// Search every directory.
for (std::vector<std::string>::const_iterator p = this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
if (helper.CheckDirectory(*p)) {
for (std::string const& sp : this->SearchPaths) {
if (helper.CheckDirectory(sp)) {
return helper.BestPath;
}
}
@@ -168,10 +164,9 @@ std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
{
// Search the entire path for each name.
cmFindProgramHelper helper;
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
for (std::string const& n : this->Names) {
// Switch to searching for this name.
helper.SetName(*ni);
helper.SetName(n);
// Check for the name by itself (e.g. an absolute path).
if (helper.CheckDirectory(std::string())) {
@@ -179,10 +174,8 @@ std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
}
// Search every directory.
for (std::vector<std::string>::const_iterator p =
this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
if (helper.CheckDirectory(*p)) {
for (std::string const& sp : this->SearchPaths) {
if (helper.CheckDirectory(sp)) {
return helper.BestPath;
}
}
@@ -193,10 +186,9 @@ std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
std::string cmFindProgramCommand::FindAppBundle()
{
for (std::vector<std::string>::const_iterator name = this->Names.begin();
name != this->Names.end(); ++name) {
for (std::string const& name : this->Names) {
std::string appName = *name + std::string(".app");
std::string appName = name + std::string(".app");
std::string appPath =
cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
Source/cmForEachCommand.cxx
+2 -2
View File
@@ -54,9 +54,9 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
mf.AddDefinition(this->Args[0], j->c_str());
// Invoke all the functions that were collected in the block.
cmExecutionStatus status;
for (unsigned int c = 0; c < this->Functions.size(); ++c) {
for (cmListFileFunction const& func : this->Functions) {
status.Clear();
mf.ExecuteCommand(this->Functions[c], status);
mf.ExecuteCommand(func, status);
if (status.GetReturnInvoked()) {
inStatus.SetReturnInvoked();
// restore the variable to its prior value
Source/cmFortranParserImpl.cxx
+2 -3
View File
@@ -30,9 +30,8 @@ bool cmFortranParser_s::FindIncludeFile(const char* dir,
}
// Search the include path for the file.
for (std::vector<std::string>::const_iterator i = this->IncludePath.begin();
i != this->IncludePath.end(); ++i) {
fullName = *i;
for (std::string const& i : this->IncludePath) {
fullName = i;
fullName += "/";
fullName += includeName;
if (cmSystemTools::FileExists(fullName.c_str(), true)) {
Source/cmFunctionCommand.cxx
+2 -2
View File
@@ -104,9 +104,9 @@ bool cmFunctionHelperCommand::InvokeInitialPass(
// Invoke all the functions that were collected in the block.
// for each function
for (unsigned int c = 0; c < this->Functions.size(); ++c) {
for (cmListFileFunction const& func : this->Functions) {
cmExecutionStatus status;
if (!this->Makefile->ExecuteCommand(this->Functions[c], status) ||
if (!this->Makefile->ExecuteCommand(func, status) ||
status.GetNestedError()) {
// The error message should have already included the call stack
// so we do not need to report an error here.
Source/cmGeneratorExpression.cxx
+4 -5
View File
@@ -199,15 +199,14 @@ static void prefixItems(const std::string& content, std::string& result,
std::vector<std::string> entries;
cmGeneratorExpression::Split(content, entries);
const char* sep = "";
for (std::vector<std::string>::const_iterator ei = entries.begin();
ei != entries.end(); ++ei) {
for (std::string const& e : entries) {
result += sep;
sep = ";";
if (!cmSystemTools::FileIsFullPath(ei->c_str()) &&
cmGeneratorExpression::Find(*ei) != 0) {
if (!cmSystemTools::FileIsFullPath(e.c_str()) &&
cmGeneratorExpression::Find(e) != 0) {
result += prefix;
}
result += *ei;
result += e;
}
}
Source/cmGeneratorExpressionEvaluationFile.cxx
+5 -8
View File
@@ -99,10 +99,9 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
cmGlobalGenerator* gg = lg->GetGlobalGenerator();
gg->GetEnabledLanguages(enabledLanguages);
for (std::vector<std::string>::const_iterator le = enabledLanguages.begin();
le != enabledLanguages.end(); ++le) {
for (std::string const& le : enabledLanguages) {
std::string name = this->OutputFileExpr->Evaluate(
lg, config, false, nullptr, nullptr, nullptr, *le);
lg, config, false, nullptr, nullptr, nullptr, le);
cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name);
sf->SetProperty("GENERATED", "1");
@@ -161,11 +160,9 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg)
cmGlobalGenerator* gg = lg->GetGlobalGenerator();
gg->GetEnabledLanguages(enabledLanguages);
for (std::vector<std::string>::const_iterator le = enabledLanguages.begin();
le != enabledLanguages.end(); ++le) {
for (std::vector<std::string>::const_iterator li = allConfigs.begin();
li != allConfigs.end(); ++li) {
this->Generate(lg, *li, *le, inputExpression.get(), outputFiles, perm);
for (std::string const& le : enabledLanguages) {
for (std::string const& li : allConfigs) {
this->Generate(lg, li, le, inputExpression.get(), outputFiles, perm);
if (cmSystemTools::GetFatalErrorOccured()) {
return;
}
Source/cmGeneratorExpressionNode.cxx
+18 -24
View File
@@ -877,13 +877,12 @@ std::string getLinkedTargetsContent(
std::string linkedTargetsContent;
std::string sep;
std::string depString;
for (typename std::vector<T>::const_iterator it = libraries.begin();
it != libraries.end(); ++it) {
for (T const& l : libraries) {
// Broken code can have a target in its own link interface.
// Don't follow such link interface entries so as not to create a
// self-referencing loop.
if (it->Target && it->Target != target) {
depString += sep + "$<TARGET_PROPERTY:" + it->Target->GetName() + "," +
if (l.Target && l.Target != target) {
depString += sep + "$<TARGET_PROPERTY:" + l.Target->GetName() + "," +
interfacePropertyName + ">";
sep = ";";
}
@@ -1281,17 +1280,15 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode
context->HadContextSensitiveCondition = true;
}
for (std::vector<std::string>::iterator oi = objects.begin();
oi != objects.end(); ++oi) {
*oi = obj_dir + *oi;
for (std::string& o : objects) {
o = obj_dir + o;
}
}
// Create the cmSourceFile instances in the referencing directory.
cmMakefile* mf = context->LG->GetMakefile();
for (std::vector<std::string>::iterator oi = objects.begin();
oi != objects.end(); ++oi) {
mf->AddTargetObject(tgtName, *oi);
for (std::string& o : objects) {
mf->AddTargetObject(tgtName, o);
}
return cmJoin(objects, ";");
@@ -1325,16 +1322,15 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
LangMap testedFeatures;
for (std::vector<std::string>::const_iterator it = parameters.begin();
it != parameters.end(); ++it) {
for (std::string const& p : parameters) {
std::string error;
std::string lang;
if (!context->LG->GetMakefile()->CompileFeatureKnown(
context->HeadTarget->Target, *it, lang, &error)) {
context->HeadTarget->Target, p, lang, &error)) {
reportError(context, content->GetOriginalExpression(), error);
return std::string();
}
testedFeatures[lang].push_back(*it);
testedFeatures[lang].push_back(p);
if (availableFeatures.find(lang) == availableFeatures.end()) {
const char* featuresKnown =
@@ -1350,15 +1346,13 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
bool evalLL = dagChecker && dagChecker->EvaluatingLinkLibraries();
for (LangMap::const_iterator lit = testedFeatures.begin();
lit != testedFeatures.end(); ++lit) {
for (auto const& lit : testedFeatures) {
std::vector<std::string> const& langAvailable =
availableFeatures[lit->first];
availableFeatures[lit.first];
const char* standardDefault = context->LG->GetMakefile()->GetDefinition(
"CMAKE_" + lit->first + "_STANDARD_DEFAULT");
for (std::vector<std::string>::const_iterator it = lit->second.begin();
it != lit->second.end(); ++it) {
if (std::find(langAvailable.begin(), langAvailable.end(), *it) ==
"CMAKE_" + lit.first + "_STANDARD_DEFAULT");
for (std::string const& it : lit.second) {
if (std::find(langAvailable.begin(), langAvailable.end(), it) ==
langAvailable.end()) {
return "0";
}
@@ -1368,14 +1362,14 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
continue;
}
if (!context->LG->GetMakefile()->HaveStandardAvailable(
target->Target, lit->first, *it)) {
target->Target, lit.first, it)) {
if (evalLL) {
const char* l = target->GetProperty(lit->first + "_STANDARD");
const char* l = target->GetProperty(lit.first + "_STANDARD");
if (!l) {
l = standardDefault;
}
assert(l);
context->MaxLanguageStandard[target][lit->first] = l;
context->MaxLanguageStandard[target][lit.first] = l;
} else {
return "0";
}
Source/cmGeneratorTarget.cxx
+175 -287
View File
@@ -150,11 +150,8 @@ cmGeneratorTarget::~cmGeneratorTarget()
const char* cmGeneratorTarget::GetSourcesProperty() const
{
std::vector<std::string> values;
for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
it = this->SourceEntries.begin(),
end = this->SourceEntries.end();
it != end; ++it) {
values.push_back((*it)->ge->GetInput());
for (TargetPropertyEntry* se : this->SourceEntries) {
values.push_back(se->ge->GetInput());
}
static std::string value;
value.clear();
@@ -299,9 +296,8 @@ std::string cmGeneratorTarget::GetOutputName(
props.push_back("OUTPUT_NAME");
std::string outName;
for (std::vector<std::string>::const_iterator it = props.begin();
it != props.end(); ++it) {
if (const char* outNameProp = this->GetProperty(*it)) {
for (std::string const& p : props) {
if (const char* outNameProp = this->GetProperty(p)) {
outName = outNameProp;
break;
}
@@ -414,10 +410,9 @@ static void handleSystemIncludesDep(
#define IMPLEMENT_VISIT(KIND) \
{ \
KindedSources const& kinded = this->GetKindedSources(config); \
for (std::vector<SourceAndKind>::const_iterator \
si = kinded.Sources.begin(); si != kinded.Sources.end(); ++si) { \
if (si->Kind == KIND) { \
data.push_back(si->Source); \
for (SourceAndKind const& s : kinded.Sources) { \
if (s.Kind == KIND) { \
data.push_back(s.Source); \
} \
} \
}
@@ -432,9 +427,8 @@ void cmGeneratorTarget::GetObjectSources(
return;
}
for (std::vector<cmSourceFile const*>::const_iterator it = data.begin();
it != data.end(); ++it) {
this->Objects[*it];
for (cmSourceFile const* it : data) {
this->Objects[it];
}
this->LocalGenerator->ComputeObjectFilenames(this->Objects, this);
@@ -451,10 +445,9 @@ void cmGeneratorTarget::ComputeObjectMapping()
if (configs.empty()) {
configs.push_back("");
}
for (std::vector<std::string>::const_iterator ci = configs.begin();
ci != configs.end(); ++ci) {
for (std::string const& c : configs) {
std::vector<cmSourceFile const*> sourceFiles;
this->GetObjectSources(sourceFiles, *ci);
this->GetObjectSources(sourceFiles, c);
}
}
@@ -655,11 +648,10 @@ std::set<cmLinkItem> const& cmGeneratorTarget::GetUtilityItems() const
if (!this->UtilityItemsDone) {
this->UtilityItemsDone = true;
std::set<std::string> const& utilities = this->GetUtilities();
for (std::set<std::string>::const_iterator i = utilities.begin();
i != utilities.end(); ++i) {
for (std::string const& i : utilities) {
cmGeneratorTarget* gt =
this->LocalGenerator->FindGeneratorTargetToUse(*i);
this->UtilityItems.insert(cmLinkItem(*i, gt));
this->LocalGenerator->FindGeneratorTargetToUse(i);
this->UtilityItems.insert(cmLinkItem(i, gt));
}
}
return this->UtilityItems;
@@ -760,23 +752,18 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(
bool excludeImported = this->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED");
std::vector<std::string> result;
for (std::set<std::string>::const_iterator it =
this->Target->GetSystemIncludeDirectories().begin();
it != this->Target->GetSystemIncludeDirectories().end(); ++it) {
for (std::string const& it : this->Target->GetSystemIncludeDirectories()) {
cmGeneratorExpression ge;
cmSystemTools::ExpandListArgument(
ge.Parse(*it)->Evaluate(this->LocalGenerator, config, false, this,
&dagChecker),
ge.Parse(it)->Evaluate(this->LocalGenerator, config, false, this,
&dagChecker),
result);
}
std::vector<cmGeneratorTarget const*> const& deps =
this->GetLinkImplementationClosure(config);
for (std::vector<cmGeneratorTarget const *>::const_iterator
li = deps.begin(),
le = deps.end();
li != le; ++li) {
handleSystemIncludesDep(this->LocalGenerator, *li, config, this,
for (cmGeneratorTarget const* dep : deps) {
handleSystemIncludesDep(this->LocalGenerator, dep, config, this,
&dagChecker, result, excludeImported);
}
@@ -804,17 +791,14 @@ static void AddInterfaceEntries(
{
if (cmLinkImplementationLibraries const* impl =
thisTarget->GetLinkImplementationLibraries(config)) {
for (std::vector<cmLinkImplItem>::const_iterator
it = impl->Libraries.begin(),
end = impl->Libraries.end();
it != end; ++it) {
if (it->Target) {
std::string genex = "$<TARGET_PROPERTY:" + *it + "," + prop + ">";
cmGeneratorExpression ge(it->Backtrace);
for (cmLinkImplItem const& lib : impl->Libraries) {
if (lib.Target) {
std::string genex = "$<TARGET_PROPERTY:" + lib + "," + prop + ">";
cmGeneratorExpression ge(lib.Backtrace);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(genex);
cge->SetEvaluateForBuildsystem(true);
entries.push_back(
new cmGeneratorTarget::TargetPropertyEntry(cge, *it));
new cmGeneratorTarget::TargetPropertyEntry(cge, lib));
}
}
}
@@ -831,25 +815,20 @@ static bool processSources(
bool contextDependent = false;
for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
it = entries.begin(),
end = entries.end();
it != end; ++it) {
cmLinkImplItem const& item = (*it)->LinkImplItem;
for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) {
cmLinkImplItem const& item = entry->LinkImplItem;
std::string const& targetName = item;
std::vector<std::string> entrySources;
cmSystemTools::ExpandListArgument(
(*it)->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt, tgt,
entry->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt, tgt,
dagChecker),
entrySources);
if ((*it)->ge->GetHadContextSensitiveCondition()) {
if (entry->ge->GetHadContextSensitiveCondition()) {
contextDependent = true;
}
for (std::vector<std::string>::iterator i = entrySources.begin();
i != entrySources.end(); ++i) {
std::string& src = *i;
for (std::string& src : entrySources) {
cmSourceFile* sf = mf->GetOrCreateSource(src);
std::string e;
std::string fullPath = sf->GetFullPath(&e);
@@ -880,10 +859,7 @@ static bool processSources(
src = fullPath;
}
std::string usedSources;
for (std::vector<std::string>::iterator li = entrySources.begin();
li != entrySources.end(); ++li) {
std::string src = *li;
for (std::string const& src : entrySources) {
if (uniqueSrcs.insert(src).second) {
srcs.push_back(src);
if (debugSources) {
@@ -895,7 +871,7 @@ static bool processSources(
tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
cmake::LOG, std::string("Used sources for target ") + tgt->GetName() +
":\n" + usedSources,
(*it)->ge->GetBacktrace());
entry->ge->GetBacktrace());
}
}
return contextDependent;
@@ -914,19 +890,15 @@ void cmGeneratorTarget::GetSourceFiles(std::vector<std::string>& files,
// behavior of CMP0024 and CMP0026 only.
cmStringRange sourceEntries = this->Target->GetSourceEntries();
for (cmStringRange::const_iterator i = sourceEntries.begin();
i != sourceEntries.end(); ++i) {
std::string const& entry = *i;
for (std::string const& entry : sourceEntries) {
std::vector<std::string> items;
cmSystemTools::ExpandListArgument(entry, items);
for (std::vector<std::string>::const_iterator li = items.begin();
li != items.end(); ++li) {
if (cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
(*li)[li->size() - 1] == '>') {
for (std::string const& item : items) {
if (cmHasLiteralPrefix(item, "$<TARGET_OBJECTS:") &&
item[item.size() - 1] == '>') {
continue;
}
files.push_back(*li);
files.push_back(item);
}
}
return;
@@ -987,9 +959,8 @@ void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*>& files,
std::vector<std::string> srcs;
this->GetSourceFiles(srcs, config);
std::set<cmSourceFile*> emitted;
for (std::vector<std::string>::const_iterator i = srcs.begin();
i != srcs.end(); ++i) {
cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i);
for (std::string const& s : srcs) {
cmSourceFile* sf = this->Makefile->GetOrCreateSource(s);
if (emitted.insert(sf).second) {
files.push_back(sf);
}
@@ -999,9 +970,8 @@ void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*>& files,
KindedSources const& kinded = this->GetKindedSources(config);
files.reserve(kinded.Sources.size());
for (std::vector<SourceAndKind>::const_iterator si = kinded.Sources.begin();
si != kinded.Sources.end(); ++si) {
files.push_back(si->Source);
for (SourceAndKind const& si : kinded.Sources) {
files.push_back(si.Source);
}
}
@@ -1010,10 +980,9 @@ void cmGeneratorTarget::GetSourceFilesWithoutObjectLibraries(
{
KindedSources const& kinded = this->GetKindedSources(config);
files.reserve(kinded.Sources.size());
for (std::vector<SourceAndKind>::const_iterator si = kinded.Sources.begin();
si != kinded.Sources.end(); ++si) {
if (si->Source->GetObjectLibrary().empty()) {
files.push_back(si->Source);
for (SourceAndKind const& si : kinded.Sources) {
if (si.Source->GetObjectLibrary().empty()) {
files.push_back(si.Source);
}
}
}
@@ -1062,10 +1031,9 @@ void cmGeneratorTarget::ComputeKindedSources(KindedSources& files,
std::vector<cmSourceFile*> badObjLib;
std::set<cmSourceFile*> emitted;
for (std::vector<std::string>::const_iterator i = srcs.begin();
i != srcs.end(); ++i) {
for (std::string const& s : srcs) {
// Create each source at most once.
cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i);
cmSourceFile* sf = this->Makefile->GetOrCreateSource(s);
if (!emitted.insert(sf).second) {
continue;
}
@@ -1138,9 +1106,8 @@ void cmGeneratorTarget::ComputeKindedSources(KindedSources& files,
if (!badObjLib.empty()) {
std::ostringstream e;
e << "OBJECT library \"" << this->GetName() << "\" contains:\n";
for (std::vector<cmSourceFile*>::const_iterator i = badObjLib.begin();
i != badObjLib.end(); ++i) {
e << " " << (*i)->GetLocation().GetName() << "\n";
for (cmSourceFile* i : badObjLib) {
e << " " << i->GetLocation().GetName() << "\n";
}
e << "but may contain only sources that compile, header files, and "
"other files that would not affect linking of a normal library.";
@@ -1167,18 +1134,16 @@ void cmGeneratorTarget::ComputeAllConfigSources() const
for (size_t ci = 0; ci < configs.size(); ++ci) {
KindedSources const& sources = this->GetKindedSources(configs[ci]);
for (std::vector<cmGeneratorTarget::SourceAndKind>::const_iterator si =
sources.Sources.begin();
si != sources.Sources.end(); ++si) {
for (SourceAndKind const& src : sources.Sources) {
std::map<cmSourceFile const*, size_t>::iterator mi =
index.find(si->Source);
index.find(src.Source);
if (mi == index.end()) {
AllConfigSource acs;
acs.Source = si->Source;
acs.Kind = si->Kind;
acs.Source = src.Source;
acs.Kind = src.Kind;
this->AllConfigSources.push_back(acs);
std::map<cmSourceFile const*, size_t>::value_type entry(
si->Source, this->AllConfigSources.size() - 1);
src.Source, this->AllConfigSources.size() - 1);
mi = index.insert(entry).first;
}
this->AllConfigSources[mi->second].Configs.push_back(ci);
@@ -1781,15 +1746,12 @@ public:
return;
}
for (std::vector<std::string>::const_iterator li =
iface->Languages.begin();
li != iface->Languages.end(); ++li) {
this->Languages.insert(*li);
for (std::string const& language : iface->Languages) {
this->Languages.insert(language);
}
for (std::vector<cmLinkItem>::const_iterator li = iface->Libraries.begin();
li != iface->Libraries.end(); ++li) {
this->Visit(*li);
for (cmLinkItem const& lib : iface->Libraries) {
this->Visit(lib);
}
}
@@ -1850,9 +1812,8 @@ public:
e << "Target " << this->Target->GetName()
<< " contains multiple languages with the highest linker preference"
<< " (" << this->Preference << "):\n";
for (std::set<std::string>::const_iterator li = this->Preferred.begin();
li != this->Preferred.end(); ++li) {
e << " " << *li << "\n";
for (std::string const& li : this->Preferred) {
e << " " << li << "\n";
}
e << "Set the LINKER_LANGUAGE property for this target.";
cmake* cm = this->Target->GetLocalGenerator()->GetCMakeInstance();
@@ -1870,23 +1831,19 @@ void cmGeneratorTarget::ComputeLinkClosure(const std::string& config,
std::unordered_set<std::string> languages;
cmLinkImplementation const* impl = this->GetLinkImplementation(config);
assert(impl);
for (std::vector<std::string>::const_iterator li = impl->Languages.begin();
li != impl->Languages.end(); ++li) {
languages.insert(*li);
for (std::string const& li : impl->Languages) {
languages.insert(li);
}
// Add interface languages from linked targets.
cmTargetCollectLinkLanguages cll(this, config, languages, this);
for (std::vector<cmLinkImplItem>::const_iterator li =
impl->Libraries.begin();
li != impl->Libraries.end(); ++li) {
cll.Visit(*li);
for (cmLinkImplItem const& lib : impl->Libraries) {
cll.Visit(lib);
}
// Store the transitive closure of languages.
for (std::unordered_set<std::string>::const_iterator li = languages.begin();
li != languages.end(); ++li) {
lc.Languages.push_back(*li);
for (std::string const& lang : languages) {
lc.Languages.push_back(lang);
}
// Choose the language whose linker should be used.
@@ -1899,19 +1856,16 @@ void cmGeneratorTarget::ComputeLinkClosure(const std::string& config,
cmTargetSelectLinker tsl(this);
// First select from the languages compiled directly in this target.
for (std::vector<std::string>::const_iterator li = impl->Languages.begin();
li != impl->Languages.end(); ++li) {
tsl.Consider(li->c_str());
for (std::string const& l : impl->Languages) {
tsl.Consider(l.c_str());
}
// Now consider languages that propagate from linked targets.
for (std::unordered_set<std::string>::const_iterator sit =
languages.begin();
sit != languages.end(); ++sit) {
for (std::string const& lang : languages) {
std::string propagates =
"CMAKE_" + *sit + "_LINKER_PREFERENCE_PROPAGATES";
"CMAKE_" + lang + "_LINKER_PREFERENCE_PROPAGATES";
if (this->Makefile->IsOn(propagates)) {
tsl.Consider(sit->c_str());
tsl.Consider(lang.c_str());
}
}
@@ -2083,10 +2037,8 @@ void processILibs(const std::string& config,
tgts.push_back(item.Target);
if (cmLinkInterfaceLibraries const* iface =
item.Target->GetLinkInterfaceLibraries(config, headTarget, true)) {
for (std::vector<cmLinkItem>::const_iterator it =
iface->Libraries.begin();
it != iface->Libraries.end(); ++it) {
processILibs(config, headTarget, *it, gg, tgts, emitted);
for (cmLinkItem const& lib : iface->Libraries) {
processILibs(config, headTarget, lib, gg, tgts, emitted);
}
}
}
@@ -2104,10 +2056,8 @@ cmGeneratorTarget::GetLinkImplementationClosure(
cmLinkImplementationLibraries const* impl =
this->GetLinkImplementationLibraries(config);
for (std::vector<cmLinkImplItem>::const_iterator it =
impl->Libraries.begin();
it != impl->Libraries.end(); ++it) {
processILibs(config, this, *it,
for (cmLinkImplItem const& lib : impl->Libraries) {
processILibs(config, this, lib,
this->LocalGenerator->GetGlobalGenerator(), tgts, emitted);
}
}
@@ -2161,13 +2111,10 @@ cmTargetTraceDependencies::cmTargetTraceDependencies(cmGeneratorTarget* target)
configs.push_back("");
}
std::set<cmSourceFile*> emitted;
for (std::vector<std::string>::const_iterator ci = configs.begin();
ci != configs.end(); ++ci) {
for (std::string const& c : configs) {
std::vector<cmSourceFile*> sources;
this->GeneratorTarget->GetSourceFiles(sources, *ci);
for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
si != sources.end(); ++si) {
cmSourceFile* sf = *si;
this->GeneratorTarget->GetSourceFiles(sources, c);
for (cmSourceFile* sf : sources) {
const std::set<cmGeneratorTarget const*> tgts =
this->GlobalGenerator->GetFilenameTargetDepends(sf);
if (tgts.find(this->GeneratorTarget) != tgts.end()) {
@@ -2206,10 +2153,9 @@ void cmTargetTraceDependencies::Trace()
if (const char* additionalDeps = sf->GetProperty("OBJECT_DEPENDS")) {
std::vector<std::string> objDeps;
cmSystemTools::ExpandListArgument(additionalDeps, objDeps);
for (std::vector<std::string>::iterator odi = objDeps.begin();
odi != objDeps.end(); ++odi) {
if (cmSystemTools::FileIsFullPath(*odi)) {
*odi = cmSystemTools::CollapseFullPath(*odi);
for (std::string& objDep : objDeps) {
if (cmSystemTools::FileIsFullPath(objDep)) {
objDep = cmSystemTools::CollapseFullPath(objDep);
}
}
this->FollowNames(objDeps);
@@ -2262,9 +2208,8 @@ void cmTargetTraceDependencies::FollowName(std::string const& name)
void cmTargetTraceDependencies::FollowNames(
std::vector<std::string> const& names)
{
for (std::vector<std::string>::const_iterator i = names.begin();
i != names.end(); ++i) {
this->FollowName(*i);
for (std::string const& name : names) {
this->FollowName(name);
}
}
@@ -2324,9 +2269,8 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
// Add target-level dependencies referenced by generator expressions.
std::set<cmGeneratorTarget*> targets;
for (cmCustomCommandLines::const_iterator cit = cc.GetCommandLines().begin();
cit != cc.GetCommandLines().end(); ++cit) {
std::string const& command = *cit->begin();
for (cmCustomCommandLine const& cCmdLine : cc.GetCommandLines()) {
std::string const& command = *cCmdLine.begin();
// Check for a target with this name.
if (cmGeneratorTarget* t =
this->LocalGenerator->FindGeneratorTargetToUse(command)) {
@@ -2340,18 +2284,16 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
}
// Check for target references in generator expressions.
for (cmCustomCommandLine::const_iterator cli = cit->begin();
cli != cit->end(); ++cli) {
const CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*cli);
for (std::string const& cl : cCmdLine) {
const CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(cl);
cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true);
std::set<cmGeneratorTarget*> geTargets = cge->GetTargets();
targets.insert(geTargets.begin(), geTargets.end());
}
}
for (std::set<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ++ti) {
this->GeneratorTarget->Target->AddUtility((*ti)->GetName());
for (cmGeneratorTarget* target : targets) {
this->GeneratorTarget->Target->AddUtility(target->GetName());
}
// Queue the custom command dependencies.
@@ -2361,9 +2303,8 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
if (configs.empty()) {
configs.push_back("");
}
for (std::vector<std::string>::const_iterator ci = configs.begin();
ci != configs.end(); ++ci) {
this->FollowCommandDepends(cc, *ci, emitted);
for (std::string const& conf : configs) {
this->FollowCommandDepends(cc, conf, emitted);
}
}
@@ -2376,9 +2317,7 @@ void cmTargetTraceDependencies::FollowCommandDepends(
const std::vector<std::string>& depends = ccg.GetDepends();
for (std::vector<std::string>::const_iterator di = depends.begin();
di != depends.end(); ++di) {
std::string const& dep = *di;
for (std::string const& dep : depends) {
if (emitted.insert(dep).second) {
if (!this->IsUtility(dep)) {
// The dependency does not name a target and may be a file we
@@ -2392,9 +2331,8 @@ void cmTargetTraceDependencies::FollowCommandDepends(
void cmTargetTraceDependencies::CheckCustomCommands(
const std::vector<cmCustomCommand>& commands)
{
for (std::vector<cmCustomCommand>::const_iterator cli = commands.begin();
cli != commands.end(); ++cli) {
this->CheckCustomCommand(*cli);
for (cmCustomCommand const& command : commands) {
this->CheckCustomCommand(command);
}
}
@@ -2482,24 +2420,20 @@ static void processIncludeDirectories(
cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
bool debugIncludes, const std::string& language)
{
for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
it = entries.begin(),
end = entries.end();
it != end; ++it) {
cmLinkImplItem const& item = (*it)->LinkImplItem;
for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) {
cmLinkImplItem const& item = entry->LinkImplItem;
std::string const& targetName = item;
bool const fromImported = item.Target && item.Target->IsImported();
bool const checkCMP0027 = item.FromGenex;
std::vector<std::string> entryIncludes;
cmSystemTools::ExpandListArgument(
(*it)->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt,
entry->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt,
dagChecker, language),
entryIncludes);
std::string usedIncludes;
for (std::vector<std::string>::iterator li = entryIncludes.begin();
li != entryIncludes.end(); ++li) {
if (fromImported && !cmSystemTools::FileExists(li->c_str())) {
for (std::string& entryInclude : entryIncludes) {
if (fromImported && !cmSystemTools::FileExists(entryInclude.c_str())) {
std::ostringstream e;
cmake::MessageType messageType = cmake::FATAL_ERROR;
if (checkCMP0027) {
@@ -2518,7 +2452,7 @@ static void processIncludeDirectories(
}
/* clang-format off */
e << "Imported target \"" << targetName << "\" includes "
"non-existent path\n \"" << *li << "\"\nin its "
"non-existent path\n \"" << entryInclude << "\"\nin its "
"INTERFACE_INCLUDE_DIRECTORIES. Possible reasons include:\n"
"* The path was deleted, renamed, or moved to another "
"location.\n"
@@ -2531,7 +2465,7 @@ static void processIncludeDirectories(
return;
}
if (!cmSystemTools::FileIsFullPath(li->c_str())) {
if (!cmSystemTools::FileIsFullPath(entryInclude.c_str())) {
std::ostringstream e;
bool noMessage = false;
cmake::MessageType messageType = cmake::FATAL_ERROR;
@@ -2539,7 +2473,7 @@ static void processIncludeDirectories(
/* clang-format off */
e << "Target \"" << targetName << "\" contains relative "
"path in its INTERFACE_INCLUDE_DIRECTORIES:\n"
" \"" << *li << "\"";
" \"" << entryInclude << "\"";
/* clang-format on */
} else {
switch (tgt->GetPolicyStatusCMP0021()) {
@@ -2557,7 +2491,7 @@ static void processIncludeDirectories(
}
e << "Found relative path while evaluating include directories of "
"\""
<< tgt->GetName() << "\":\n \"" << *li << "\"\n";
<< tgt->GetName() << "\":\n \"" << entryInclude << "\"\n";
}
if (!noMessage) {
tgt->GetLocalGenerator()->IssueMessage(messageType, e.str());
@@ -2567,10 +2501,10 @@ static void processIncludeDirectories(
}
}
if (!cmSystemTools::IsOff(li->c_str())) {
cmSystemTools::ConvertToUnixSlashes(*li);
if (!cmSystemTools::IsOff(entryInclude.c_str())) {
cmSystemTools::ConvertToUnixSlashes(entryInclude);
}
std::string inc = *li;
std::string inc = entryInclude;
if (uniqueIncludes.insert(inc).second) {
includes.push_back(inc);
@@ -2583,7 +2517,7 @@ static void processIncludeDirectories(
tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
cmake::LOG, std::string("Used includes for target ") + tgt->GetName() +
":\n" + usedIncludes,
(*it)->ge->GetBacktrace());
entry->ge->GetBacktrace());
}
}
}
@@ -2624,10 +2558,8 @@ std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories(
if (this->Makefile->IsOn("APPLE")) {
cmLinkImplementationLibraries const* impl =
this->GetLinkImplementationLibraries(config);
for (std::vector<cmLinkImplItem>::const_iterator it =
impl->Libraries.begin();
it != impl->Libraries.end(); ++it) {
std::string libDir = cmSystemTools::CollapseFullPath(*it);
for (cmLinkImplItem const& lib : impl->Libraries) {
std::string libDir = cmSystemTools::CollapseFullPath(lib);
static cmsys::RegularExpression frameworkCheck(
"(.*\\.framework)(/Versions/[^/]+)?/[^/]+$");
@@ -2662,20 +2594,14 @@ static void processCompileOptionsInternal(
cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
bool debugOptions, const char* logName, std::string const& language)
{
for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
it = entries.begin(),
end = entries.end();
it != end; ++it) {
for (cmGeneratorTarget::TargetPropertyEntry* entry : entries) {
std::vector<std::string> entryOptions;
cmSystemTools::ExpandListArgument(
(*it)->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt,
entry->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt,
dagChecker, language),
entryOptions);
std::string usedOptions;
for (std::vector<std::string>::iterator li = entryOptions.begin();
li != entryOptions.end(); ++li) {
std::string const& opt = *li;
for (std::string const& opt : entryOptions) {
if (uniqueOptions.insert(opt).second) {
options.push_back(opt);
if (debugOptions) {
@@ -2687,7 +2613,7 @@ static void processCompileOptionsInternal(
tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
cmake::LOG, std::string("Used compile ") + logName +
std::string(" for target ") + tgt->GetName() + ":\n" + usedOptions,
(*it)->ge->GetBacktrace());
entry->ge->GetBacktrace());
}
}
}
@@ -2940,9 +2866,8 @@ bool cmGeneratorTarget::ComputeCompileFeatures(std::string const& config) const
{
std::vector<std::string> features;
this->GetCompileFeatures(features, config);
for (std::vector<std::string>::const_iterator it = features.begin();
it != features.end(); ++it) {
if (!this->Makefile->AddRequiredTargetFeature(this->Target, *it)) {
for (std::string const& f : features) {
if (!this->Makefile->AddRequiredTargetFeature(this->Target, f)) {
return false;
}
}
@@ -3334,9 +3259,8 @@ std::string cmGeneratorTarget::GetPDBName(const std::string& config) const
// PDB_NAME
props.push_back("PDB_NAME");
for (std::vector<std::string>::const_iterator i = props.begin();
i != props.end(); ++i) {
if (const char* outName = this->GetProperty(*i)) {
for (std::string const& p : props) {
if (const char* outName = this->GetProperty(p)) {
base = outName;
break;
}
@@ -3364,20 +3288,16 @@ void cmGeneratorTarget::GetTargetObjectNames(
this->GetObjectSources(objectSources, config);
std::map<cmSourceFile const*, std::string> mapping;
for (std::vector<cmSourceFile const*>::const_iterator it =
objectSources.begin();
it != objectSources.end(); ++it) {
mapping[*it];
for (cmSourceFile const* sf : objectSources) {
mapping[sf];
}
this->LocalGenerator->ComputeObjectFilenames(mapping, this);
for (std::vector<cmSourceFile const*>::const_iterator it =
objectSources.begin();
it != objectSources.end(); ++it) {
for (cmSourceFile const* src : objectSources) {
// Find the object file name corresponding to this source file.
std::map<cmSourceFile const*, std::string>::const_iterator map_it =
mapping.find(*it);
mapping.find(src);
// It must exist because we populated the mapping just above.
assert(!map_it->second.empty());
objects.push_back(map_it->second);
@@ -3440,9 +3360,8 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const
if (const char* files = this->GetProperty("PUBLIC_HEADER")) {
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
for (std::vector<std::string>::iterator it = relFiles.begin();
it != relFiles.end(); ++it) {
if (cmSourceFile* sf = this->Makefile->GetSource(*it)) {
for (std::string const& relFile : relFiles) {
if (cmSourceFile* sf = this->Makefile->GetSource(relFile)) {
SourceFileFlags& flags = this->SourceFlagsMap[sf];
flags.MacFolder = "Headers";
flags.Type = cmGeneratorTarget::SourceFileTypePublicHeader;
@@ -3455,9 +3374,8 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const
if (const char* files = this->GetProperty("PRIVATE_HEADER")) {
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
for (std::vector<std::string>::iterator it = relFiles.begin();
it != relFiles.end(); ++it) {
if (cmSourceFile* sf = this->Makefile->GetSource(*it)) {
for (std::string const& relFile : relFiles) {
if (cmSourceFile* sf = this->Makefile->GetSource(relFile)) {
SourceFileFlags& flags = this->SourceFlagsMap[sf];
flags.MacFolder = "PrivateHeaders";
flags.Type = cmGeneratorTarget::SourceFileTypePrivateHeader;
@@ -3469,9 +3387,8 @@ void cmGeneratorTarget::ConstructSourceFileFlags() const
if (const char* files = this->GetProperty("RESOURCE")) {
std::vector<std::string> relFiles;
cmSystemTools::ExpandListArgument(files, relFiles);
for (std::vector<std::string>::iterator it = relFiles.begin();
it != relFiles.end(); ++it) {
if (cmSourceFile* sf = this->Makefile->GetSource(*it)) {
for (std::string const& relFile : relFiles) {
if (cmSourceFile* sf = this->Makefile->GetSource(relFile)) {
SourceFileFlags& flags = this->SourceFlagsMap[sf];
flags.MacFolder = "";
if (!this->GlobalGenerator->ShouldStripResourcePath(this->Makefile)) {
@@ -3494,11 +3411,9 @@ cmGeneratorTarget::GetCompatibleInterfaces(std::string const& config) const
compat.PropsString.insert("AUTOUIC_OPTIONS");
std::vector<cmGeneratorTarget const*> const& deps =
this->GetLinkImplementationClosure(config);
for (std::vector<cmGeneratorTarget const*>::const_iterator li =
deps.begin();
li != deps.end(); ++li) {
for (cmGeneratorTarget const* li : deps) {
#define CM_READ_COMPATIBLE_INTERFACE(X, x) \
if (const char* prop = (*li)->GetProperty("COMPATIBLE_INTERFACE_" #X)) { \
if (const char* prop = li->GetProperty("COMPATIBLE_INTERFACE_" #X)) { \
std::vector<std::string> props; \
cmSystemTools::ExpandListArgument(prop, props); \
compat.Props##x.insert(props.begin(), props.end()); \
@@ -3618,13 +3533,12 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender,
std::string pdir = cmSystemTools::GetCMakeRoot();
pdir += "/Help/prop_tgt/";
for (std::vector<std::string>::iterator pi = props.begin();
pi != props.end(); ++pi) {
std::string pname = cmSystemTools::HelpFileName(*pi);
for (std::string const& p : props) {
std::string pname = cmSystemTools::HelpFileName(p);
std::string pfile = pdir + pname + ".rst";
if (cmSystemTools::FileExists(pfile.c_str(), true)) {
std::ostringstream e;
e << "Target \"" << dependee->GetName() << "\" has property \"" << *pi
e << "Target \"" << dependee->GetName() << "\" has property \"" << p
<< "\" listed in its " << propName
<< " property. "
"This is not allowed. Only user-defined properties may appear "
@@ -3633,8 +3547,8 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender,
depender->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}
if (emitted.insert(*pi).second) {
getLinkInterfaceDependentProperty<PropertyType>(depender, *pi, config, t,
if (emitted.insert(p).second) {
getLinkInterfaceDependentProperty<PropertyType>(depender, p, config, t,
nullptr);
if (cmSystemTools::GetErrorOccuredFlag()) {
return;
@@ -3706,30 +3620,29 @@ void cmGeneratorTarget::CheckPropertyCompatibility(
std::set<std::string> emittedMaxNumbers;
static std::string strNumMax = "COMPATIBLE_INTERFACE_NUMBER_MAX";
for (cmComputeLinkInformation::ItemVector::const_iterator li = deps.begin();
li != deps.end(); ++li) {
if (!li->Target) {
for (auto const& dep : deps) {
if (!dep.Target) {
continue;
}
checkPropertyConsistency<bool>(this, li->Target, strBool, emittedBools,
checkPropertyConsistency<bool>(this, dep.Target, strBool, emittedBools,
config, BoolType, nullptr);
if (cmSystemTools::GetErrorOccuredFlag()) {
return;
}
checkPropertyConsistency<const char*>(this, li->Target, strString,
checkPropertyConsistency<const char*>(this, dep.Target, strString,
emittedStrings, config, StringType,
nullptr);
if (cmSystemTools::GetErrorOccuredFlag()) {
return;
}
checkPropertyConsistency<const char*>(this, li->Target, strNumMin,
checkPropertyConsistency<const char*>(this, dep.Target, strNumMin,
emittedMinNumbers, config,
NumberMinType, nullptr);
if (cmSystemTools::GetErrorOccuredFlag()) {
return;
}
checkPropertyConsistency<const char*>(this, li->Target, strNumMax,
checkPropertyConsistency<const char*>(this, dep.Target, strNumMax,
emittedMaxNumbers, config,
NumberMaxType, nullptr);
if (cmSystemTools::GetErrorOccuredFlag()) {
@@ -3961,16 +3874,13 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
}
std::string interfaceProperty = "INTERFACE_" + p;
for (std::vector<cmGeneratorTarget const*>::const_iterator li = deps.begin();
li != deps.end(); ++li) {
for (cmGeneratorTarget const* theTarget : deps) {
// An error should be reported if one dependency
// has INTERFACE_POSITION_INDEPENDENT_CODE ON and the other
// has INTERFACE_POSITION_INDEPENDENT_CODE OFF, or if the
// target itself has a POSITION_INDEPENDENT_CODE which disagrees
// with a dependency.
cmGeneratorTarget const* theTarget = *li;
std::vector<std::string> propKeys = theTarget->GetPropertyKeys();
const bool ifaceIsSet = std::find(propKeys.begin(), propKeys.end(),
@@ -4240,9 +4150,8 @@ std::vector<std::string> cmGeneratorTarget::GetPropertyKeys() const
cmPropertyMap const& propsObject = this->Target->GetProperties();
std::vector<std::string> props;
props.reserve(propsObject.size());
for (cmPropertyMap::const_iterator it = propsObject.begin();
it != propsObject.end(); ++it) {
props.push_back(it->first);
for (auto const& it : propsObject) {
props.push_back(it.first);
}
return props;
}
@@ -4282,9 +4191,8 @@ void cmGeneratorTarget::ReportPropertyOrigin(
void cmGeneratorTarget::LookupLinkItems(std::vector<std::string> const& names,
std::vector<cmLinkItem>& items) const
{
for (std::vector<std::string>::const_iterator i = names.begin();
i != names.end(); ++i) {
std::string name = this->CheckCMP0004(*i);
for (std::string const& n : names) {
std::string name = this->CheckCMP0004(n);
if (name == this->GetName() || name.empty()) {
continue;
}
@@ -4365,21 +4273,17 @@ void cmGeneratorTarget::ComputeLinkInterface(
// Shared libraries may have runtime implementation dependencies
// on other shared libraries that are not in the interface.
std::unordered_set<std::string> emitted;
for (std::vector<cmLinkItem>::const_iterator li =
iface.Libraries.begin();
li != iface.Libraries.end(); ++li) {
emitted.insert(*li);
for (cmLinkItem const& lib : iface.Libraries) {
emitted.insert(lib);
}
if (this->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
cmLinkImplementation const* impl = this->GetLinkImplementation(config);
for (std::vector<cmLinkImplItem>::const_iterator li =
impl->Libraries.begin();
li != impl->Libraries.end(); ++li) {
if (emitted.insert(*li).second) {
if (li->Target) {
for (cmLinkImplItem const& lib : impl->Libraries) {
if (emitted.insert(lib).second) {
if (lib.Target) {
// This is a runtime dependency on another shared library.
if (li->Target->GetType() == cmStateEnums::SHARED_LIBRARY) {
iface.SharedDeps.push_back(*li);
if (lib.Target->GetType() == cmStateEnums::SHARED_LIBRARY) {
iface.SharedDeps.push_back(lib);
}
} else {
// TODO: Recognize shared library file names. Perhaps this
@@ -5091,19 +4995,17 @@ bool cmGeneratorTarget::GetConfigCommonSourceFiles(
if (configFiles != files) {
std::string firstConfigFiles;
const char* sep = "";
for (std::vector<cmSourceFile*>::const_iterator fi = files.begin();
fi != files.end(); ++fi) {
for (cmSourceFile* f : files) {
firstConfigFiles += sep;
firstConfigFiles += (*fi)->GetFullPath();
firstConfigFiles += f->GetFullPath();
sep = "\n ";
}
std::string thisConfigFiles;
sep = "";
for (std::vector<cmSourceFile*>::const_iterator fi = configFiles.begin();
fi != configFiles.end(); ++fi) {
for (cmSourceFile* f : configFiles) {
thisConfigFiles += sep;
thisConfigFiles += (*fi)->GetFullPath();
thisConfigFiles += f->GetFullPath();
sep = "\n ";
}
std::ostringstream e;
@@ -5134,17 +5036,13 @@ void cmGeneratorTarget::GetObjectLibrariesCMP0026(
// for TARGET_OBJECTS instead for backwards compatibility with OLD
// behavior of CMP0024 and CMP0026 only.
cmStringRange rng = this->Target->GetSourceEntries();
for (std::vector<std::string>::const_iterator i = rng.begin();
i != rng.end(); ++i) {
std::string const& entry = *i;
for (std::string const& entry : rng) {
std::vector<std::string> files;
cmSystemTools::ExpandListArgument(entry, files);
for (std::vector<std::string>::const_iterator li = files.begin();
li != files.end(); ++li) {
if (cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
(*li)[li->size() - 1] == '>') {
std::string objLibName = li->substr(17, li->size() - 18);
for (std::string const& li : files) {
if (cmHasLiteralPrefix(li, "$<TARGET_OBJECTS:") &&
li[li.size() - 1] == '>') {
std::string objLibName = li.substr(17, li.size() - 18);
if (cmGeneratorExpression::Find(objLibName) != std::string::npos) {
continue;
@@ -5210,9 +5108,8 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages,
{
std::vector<cmSourceFile*> sourceFiles;
this->GetSourceFiles(sourceFiles, config);
for (std::vector<cmSourceFile*>::const_iterator i = sourceFiles.begin();
i != sourceFiles.end(); ++i) {
const std::string& lang = (*i)->GetLanguage();
for (cmSourceFile* src : sourceFiles) {
const std::string& lang = src->GetLanguage();
if (!lang.empty()) {
languages.insert(lang);
}
@@ -5224,27 +5121,21 @@ void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages,
std::vector<cmGeneratorTarget*> objectTargets;
this->GetObjectLibrariesCMP0026(objectTargets);
objectLibraries.reserve(objectTargets.size());
for (std::vector<cmGeneratorTarget*>::const_iterator it =
objectTargets.begin();
it != objectTargets.end(); ++it) {
objectLibraries.push_back(*it);
for (cmGeneratorTarget* gt : objectTargets) {
objectLibraries.push_back(gt);
}
} else {
this->GetExternalObjects(externalObjects, config);
for (std::vector<cmSourceFile const*>::const_iterator i =
externalObjects.begin();
i != externalObjects.end(); ++i) {
std::string objLib = (*i)->GetObjectLibrary();
for (cmSourceFile const* extObj : externalObjects) {
std::string objLib = extObj->GetObjectLibrary();
if (cmGeneratorTarget* tgt =
this->LocalGenerator->FindGeneratorTargetToUse(objLib)) {
objectLibraries.push_back(tgt);
}
}
}
for (std::vector<cmGeneratorTarget*>::const_iterator i =
objectLibraries.begin();
i != objectLibraries.end(); ++i) {
(*i)->GetLanguages(languages, config);
for (cmGeneratorTarget* objLib : objectLibraries) {
objLib->GetLanguages(languages, config);
}
}
@@ -5339,10 +5230,9 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
impl.HadHeadSensitiveCondition = true;
}
for (std::vector<std::string>::const_iterator li = llibs.begin();
li != llibs.end(); ++li) {
for (std::string const& lib : llibs) {
// Skip entries that resolve to the target itself or are empty.
std::string name = this->CheckCMP0004(*li);
std::string name = this->CheckCMP0004(lib);
if (name == this->GetName() || name.empty()) {
if (name == this->GetName()) {
bool noMessage = false;
@@ -5380,10 +5270,9 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
}
std::set<std::string> const& seenProps = cge->GetSeenTargetProperties();
for (std::set<std::string>::const_iterator it = seenProps.begin();
it != seenProps.end(); ++it) {
if (!this->GetProperty(*it)) {
this->LinkImplicitNullProperties.insert(*it);
for (std::string const& sp : seenProps) {
if (!this->GetProperty(sp)) {
this->LinkImplicitNullProperties.insert(sp);
}
}
cge->GetMaxLanguageStandard(this, this->MaxLanguageStandards);
@@ -5397,10 +5286,9 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
CMP0003_ComputeLinkType(config, debugConfigs);
cmTarget::LinkLibraryVectorType const& oldllibs =
this->Target->GetOriginalLinkLibraries();
for (cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin();
li != oldllibs.end(); ++li) {
if (li->second != GENERAL_LibraryType && li->second != linkType) {
std::string name = this->CheckCMP0004(li->first);
for (cmTarget::LibraryID const& oldllib : oldllibs) {
if (oldllib.second != GENERAL_LibraryType && oldllib.second != linkType) {
std::string name = this->CheckCMP0004(oldllib.first);
if (name == this->GetName() || name.empty()) {
continue;
}
Source/cmGlobalGenerator.cxx
+131 -188
View File
@@ -244,10 +244,8 @@ 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);
}
}
@@ -383,12 +381,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 +394,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
@@ -541,11 +537,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;
}
@@ -647,10 +642,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;
}
@@ -793,9 +787,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);
}
}
@@ -1020,9 +1013,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;
}
}
@@ -1034,9 +1026,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;
}
}
@@ -1082,9 +1073,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));
}
}
@@ -1118,13 +1108,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)));
}
}
@@ -1177,9 +1165,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);
}
@@ -1229,10 +1216,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]);
}
}
}
@@ -1266,11 +1251,9 @@ bool cmGlobalGenerator::Compute()
cmQtAutoGenDigestUPV autogenDigests = this->CreateQtAutoGeneratorsTargets();
#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.
@@ -1279,25 +1262,23 @@ 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 (const cmQtAutoGenDigestUP& digest : autogenDigests) {
for (cmQtAutoGenDigestUP const& digest : autogenDigests) {
cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(*digest);
}
autogenDigests.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);
}
}
@@ -1305,15 +1286,15 @@ 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();
}
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.
@@ -1321,8 +1302,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;
@@ -1356,10 +1337,8 @@ void cmGlobalGenerator::Generate()
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.");
@@ -1381,10 +1360,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());
}
@@ -1399,10 +1376,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());
}
@@ -1417,10 +1392,8 @@ 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;
}
@@ -1502,17 +1475,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 +1508,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 +1519,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 +1540,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 +1549,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 +1559,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 +1610,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 +1643,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 +1664,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, "
@@ -2035,16 +1998,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());
@@ -2064,12 +2026,10 @@ cmMakefile* cmGlobalGenerator::FindMakefile(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) {
std::string sd = (*it)->GetCurrentSourceDirectory();
for (cmLocalGenerator* lg : this->LocalGenerators) {
std::string sd = lg->GetCurrentSourceDirectory();
if (sd == start_dir) {
return *it;
return lg;
}
}
return nullptr;
@@ -2477,9 +2437,8 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(GlobalTargetInfo const& gti,
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:
@@ -2587,18 +2546,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
const std::vector<cmGeneratorTarget*>& tgts = (*i)->GetGeneratorTargets();
const std::vector<cmGeneratorTarget*>& tgts =
generator->GetGeneratorTargets();
// loop over all the targets
for (std::vector<cmGeneratorTarget*>::const_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 +2582,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 +2728,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 +2743,14 @@ void cmGlobalGenerator::WriteSummary()
fname += "/TargetDirectories.txt";
cmGeneratedFileStream fout(fname.c_str());
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
const std::vector<cmGeneratorTarget*>& tgts =
this->LocalGenerators[i]->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_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";
}
}
}
@@ -2835,10 +2788,9 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
cmSystemTools::ExpandListArgument(targetLabels, 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);
for (std::string const& l : labels) {
fout << " " << l << "\n";
lj_target_labels.append(l);
}
}
}
@@ -2860,18 +2812,14 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
fout << "# Directory labels\n";
}
for (std::vector<std::string>::const_iterator li =
directoryLabelsList.begin();
li != directoryLabelsList.end(); ++li) {
fout << " " << *li << "\n";
lj_target_labels.append(*li);
for (std::string const& li : directoryLabelsList) {
fout << " " << li << "\n";
lj_target_labels.append(li);
}
for (std::vector<std::string>::const_iterator li =
cmakeDirectoryLabelsList.begin();
li != cmakeDirectoryLabelsList.end(); ++li) {
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.
@@ -2882,9 +2830,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);
@@ -2899,10 +2846,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);
}
}
}
@@ -2920,11 +2866,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;
}
@@ -2944,18 +2890,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);
}
}
@@ -2986,9 +2930,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);
Source/cmGlobalKdevelopGenerator.cxx
+29 -47
View File
@@ -16,7 +16,6 @@
#include "cmsys/Directory.hxx"
#include "cmsys/FStream.hxx"
#include <map>
#include <set>
#include <string.h>
#include <utility>
@@ -49,15 +48,13 @@ void cmGlobalKdevelopGenerator::Generate()
{
// for each sub project in the project create
// a kdevelop project
for (std::map<std::string, std::vector<cmLocalGenerator*>>::const_iterator
it = this->GlobalGenerator->GetProjectMap().begin();
it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
std::string outputDir = it->second[0]->GetCurrentBinaryDirectory();
std::string projectDir = it->second[0]->GetSourceDirectory();
std::string projectName = it->second[0]->GetProjectName();
for (auto const& it : this->GlobalGenerator->GetProjectMap()) {
std::string outputDir = it.second[0]->GetCurrentBinaryDirectory();
std::string projectDir = it.second[0]->GetSourceDirectory();
std::string projectName = it.second[0]->GetProjectName();
std::string cmakeFilePattern("CMakeLists.txt;*.cmake;");
std::string fileToOpen;
const std::vector<cmLocalGenerator*>& lgs = it->second;
const std::vector<cmLocalGenerator*>& lgs = it.second;
// create the project.kdevelop.filelist file
if (!this->CreateFilelistFile(lgs, outputDir, projectDir, projectName,
cmakeFilePattern, fileToOpen)) {
@@ -67,15 +64,12 @@ void cmGlobalKdevelopGenerator::Generate()
// try to find the name of an executable so we have something to
// run from kdevelop for now just pick the first executable found
std::string executable;
for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
lg != lgs.end(); lg++) {
for (cmLocalGenerator* lg : lgs) {
std::vector<cmGeneratorTarget*> const& targets =
(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti =
targets.begin();
ti != targets.end(); ti++) {
if ((*ti)->GetType() == cmStateEnums::EXECUTABLE) {
executable = (*ti)->GetLocation("");
lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
if (target->GetType() == cmStateEnums::EXECUTABLE) {
executable = target->GetLocation("");
break;
}
}
@@ -104,13 +98,11 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile(
std::vector<std::string> const& hdrExts =
this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
for (std::vector<cmLocalGenerator*>::const_iterator it = lgs.begin();
it != lgs.end(); it++) {
cmMakefile* makefile = (*it)->GetMakefile();
for (cmLocalGenerator* lg : lgs) {
cmMakefile* makefile = lg->GetMakefile();
const std::vector<std::string>& listFiles = makefile->GetListFiles();
for (std::vector<std::string>::const_iterator lt = listFiles.begin();
lt != listFiles.end(); lt++) {
tmp = *lt;
for (std::string const& listFile : listFiles) {
tmp = listFile;
cmSystemTools::ReplaceString(tmp, projectDir.c_str(), "");
// make sure the file is part of this source tree
if ((tmp[0] != '/') &&
@@ -128,17 +120,13 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile(
}
// get all sources
const std::vector<cmGeneratorTarget*>& targets =
(*it)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ti++) {
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* gt : targets) {
std::vector<cmSourceFile*> sources;
cmGeneratorTarget* gt = *ti;
gt->GetSourceFiles(sources, gt->Target->GetMakefile()->GetSafeDefinition(
"CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
si != sources.end(); si++) {
tmp = (*si)->GetFullPath();
for (cmSourceFile* sf : sources) {
tmp = sf->GetFullPath();
std::string headerBasename = cmSystemTools::GetFilenamePath(tmp);
headerBasename += "/";
headerBasename += cmSystemTools::GetFilenameWithoutExtension(tmp);
@@ -152,11 +140,10 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile(
files.insert(tmp);
// check if there's a matching header around
for (std::vector<std::string>::const_iterator ext = hdrExts.begin();
ext != hdrExts.end(); ++ext) {
for (std::string const& hdrExt : hdrExts) {
std::string hname = headerBasename;
hname += ".";
hname += *ext;
hname += hdrExt;
if (cmSystemTools::FileExists(hname.c_str())) {
cmSystemTools::ReplaceString(hname, projectDir.c_str(), "");
files.insert(hname);
@@ -165,9 +152,8 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile(
}
}
}
for (std::vector<std::string>::const_iterator lt = listFiles.begin();
lt != listFiles.end(); lt++) {
tmp = *lt;
for (std::string const& listFile : listFiles) {
tmp = listFile;
cmSystemTools::ReplaceString(tmp, projectDir.c_str(), "");
if ((tmp[0] != '/') &&
(strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) ==
@@ -201,10 +187,9 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile(
}
fileToOpen = "";
for (std::set<std::string>::const_iterator it = files.begin();
it != files.end(); it++) {
for (std::string const& file : files) {
// get the full path to the file
tmp = cmSystemTools::CollapseFullPath(*it, projectDir.c_str());
tmp = cmSystemTools::CollapseFullPath(file, projectDir.c_str());
// just select the first source file
if (fileToOpen.empty()) {
std::string ext = cmSystemTools::GetFilenameExtension(tmp);
@@ -297,9 +282,8 @@ void cmGlobalKdevelopGenerator::MergeProjectFiles(
return;
}
for (std::vector<std::string>::const_iterator it = lines.begin();
it != lines.end(); it++) {
const char* line = (*it).c_str();
for (std::string const& l : lines) {
const char* line = l.c_str();
// skip these tags as they are always replaced
if ((strstr(line, "<projectdirectory>") != nullptr) ||
(strstr(line, "<projectmanagement>") != nullptr) ||
@@ -311,7 +295,7 @@ void cmGlobalKdevelopGenerator::MergeProjectFiles(
}
// output the line from the file if it is not one of the above tags
fout << *it << "\n";
fout << l << "\n";
// if this is the <general> tag output the stuff that goes in the
// general tag
if (strstr(line, "<general>")) {
@@ -434,10 +418,8 @@ void cmGlobalKdevelopGenerator::CreateNewProjectFile(
xml.EndElement(); // make
xml.StartElement("blacklist");
for (std::vector<std::string>::const_iterator dirIt =
this->Blacklist.begin();
dirIt != this->Blacklist.end(); ++dirIt) {
xml.Element("path", *dirIt);
for (std::string const& dir : this->Blacklist) {
xml.Element("path", dir);
}
xml.EndElement();
Source/cmGlobalNinjaGenerator.cxx
+113 -170
View File
@@ -90,12 +90,12 @@ std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name)
// Ninja rule names must match "[a-zA-Z0-9_.-]+". Use ".xx" to encode
// "." and all invalid characters as hexadecimal.
std::string encoded;
for (std::string::const_iterator i = name.begin(); i != name.end(); ++i) {
if (isalnum(*i) || *i == '_' || *i == '-') {
encoded += *i;
for (char i : name) {
if (isalnum(i) || i == '_' || i == '-') {
encoded += i;
} else {
char buf[16];
sprintf(buf, ".%02x", static_cast<unsigned int>(*i));
sprintf(buf, ".%02x", static_cast<unsigned int>(i));
encoded += buf;
}
}
@@ -177,26 +177,23 @@ void cmGlobalNinjaGenerator::WriteBuild(
// TODO: Better formatting for when there are multiple input/output files.
// Write explicit dependencies.
for (cmNinjaDeps::const_iterator i = explicitDeps.begin();
i != explicitDeps.end(); ++i) {
arguments += " " + EncodeIdent(EncodePath(*i), os);
for (std::string const& explicitDep : explicitDeps) {
arguments += " " + EncodeIdent(EncodePath(explicitDep), os);
}
// Write implicit dependencies.
if (!implicitDeps.empty()) {
arguments += " |";
for (cmNinjaDeps::const_iterator i = implicitDeps.begin();
i != implicitDeps.end(); ++i) {
arguments += " " + EncodeIdent(EncodePath(*i), os);
for (std::string const& implicitDep : implicitDeps) {
arguments += " " + EncodeIdent(EncodePath(implicitDep), os);
}
}
// Write order-only dependencies.
if (!orderOnlyDeps.empty()) {
arguments += " ||";
for (cmNinjaDeps::const_iterator i = orderOnlyDeps.begin();
i != orderOnlyDeps.end(); ++i) {
arguments += " " + EncodeIdent(EncodePath(*i), os);
for (std::string const& orderOnlyDep : orderOnlyDeps) {
arguments += " " + EncodeIdent(EncodePath(orderOnlyDep), os);
}
}
@@ -206,18 +203,16 @@ void cmGlobalNinjaGenerator::WriteBuild(
// Write outputs files.
build += "build";
for (cmNinjaDeps::const_iterator i = outputs.begin(); i != outputs.end();
++i) {
build += " " + EncodeIdent(EncodePath(*i), os);
for (std::string const& output : outputs) {
build += " " + EncodeIdent(EncodePath(output), os);
if (this->ComputingUnknownDependencies) {
this->CombinedBuildOutputs.insert(*i);
this->CombinedBuildOutputs.insert(output);
}
}
if (!implicitOuts.empty()) {
build += " |";
for (cmNinjaDeps::const_iterator i = implicitOuts.begin();
i != implicitOuts.end(); ++i) {
build += " " + EncodeIdent(EncodePath(*i), os);
for (std::string const& implicitOut : implicitOuts) {
build += " " + EncodeIdent(EncodePath(implicitOut), os);
}
}
build += ":";
@@ -227,20 +222,18 @@ void cmGlobalNinjaGenerator::WriteBuild(
// Write the variables bound to this build statement.
std::ostringstream variable_assignments;
for (cmNinjaVars::const_iterator i = variables.begin(); i != variables.end();
++i) {
cmGlobalNinjaGenerator::WriteVariable(variable_assignments, i->first,
i->second, "", 1);
for (auto const& variable : variables) {
cmGlobalNinjaGenerator::WriteVariable(variable_assignments, variable.first,
variable.second, "", 1);
}
// check if a response file rule should be used
std::string buildstr = build;
std::string assignments = variable_assignments.str();
const std::string& args = arguments;
bool useResponseFile = false;
if (cmdLineLimit < 0 ||
(cmdLineLimit > 0 &&
(args.size() + buildstr.size() + assignments.size() + 1000) >
(arguments.size() + buildstr.size() + assignments.size() + 1000) >
static_cast<size_t>(cmdLineLimit))) {
variable_assignments.str(std::string());
cmGlobalNinjaGenerator::WriteVariable(variable_assignments, "RSP_FILE",
@@ -252,7 +245,7 @@ void cmGlobalNinjaGenerator::WriteBuild(
*usedResponseFile = useResponseFile;
}
os << buildstr << args << assignments;
os << buildstr << arguments << assignments;
}
void cmGlobalNinjaGenerator::WritePhonyBuild(
@@ -311,8 +304,8 @@ void cmGlobalNinjaGenerator::WriteCustomCommandBuild(
if (this->ComputingUnknownDependencies) {
// we need to track every dependency that comes in, since we are trying
// to find dependencies that are side effects of build commands
for (cmNinjaDeps::const_iterator i = deps.begin(); i != deps.end(); ++i) {
this->CombinedCustomCommandExplicitDependencies.insert(*i);
for (std::string const& dep : deps) {
this->CombinedCustomCommandExplicitDependencies.insert(dep);
}
}
}
@@ -465,9 +458,8 @@ void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os,
{
cmGlobalNinjaGenerator::WriteComment(os, comment);
os << "default";
for (cmNinjaDeps::const_iterator i = targets.begin(); i != targets.end();
++i) {
os << " " << *i;
for (std::string const& target : targets) {
os << " " << target;
}
os << "\n";
}
@@ -670,12 +662,11 @@ void cmGlobalNinjaGenerator::EnableLanguage(
std::vector<std::string> const& langs, cmMakefile* mf, bool optional)
{
this->cmGlobalGenerator::EnableLanguage(langs, mf, optional);
for (std::vector<std::string>::const_iterator l = langs.begin();
l != langs.end(); ++l) {
if (*l == "NONE") {
for (std::string const& l : langs) {
if (l == "NONE") {
continue;
}
this->ResolveLanguageCompiler(*l, mf, optional);
this->ResolveLanguageCompiler(l, mf, optional);
}
#ifdef _WIN32
if (strcmp(mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID"), "MSVC") != 0 &&
@@ -952,15 +943,13 @@ void cmGlobalNinjaGenerator::AddDependencyToAll(const std::string& input)
void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
{
for (std::map<std::string, std::set<std::string>>::iterator i =
this->AssumedSourceDependencies.begin();
i != this->AssumedSourceDependencies.end(); ++i) {
for (auto const& asd : this->AssumedSourceDependencies) {
cmNinjaDeps deps;
std::copy(i->second.begin(), i->second.end(), std::back_inserter(deps));
std::copy(asd.second.begin(), asd.second.end(), std::back_inserter(deps));
WriteCustomCommandBuild(/*command=*/"", /*description=*/"",
"Assume dependencies for generated source file.",
/*depfile*/ "", /*uses_terminal*/ false,
/*restat*/ true, cmNinjaDeps(1, i->first), deps);
/*restat*/ true, cmNinjaDeps(1, asd.first), deps);
}
}
@@ -1025,22 +1014,20 @@ void cmGlobalNinjaGenerator::AppendTargetDepends(
if (target->GetType() == cmStateEnums::GLOBAL_TARGET) {
// These depend only on other CMake-provided targets, e.g. "all".
std::set<std::string> const& utils = target->GetUtilities();
for (std::set<std::string>::const_iterator i = utils.begin();
i != utils.end(); ++i) {
for (std::string const& util : utils) {
std::string d =
target->GetLocalGenerator()->GetCurrentBinaryDirectory() +
std::string("/") + *i;
std::string("/") + util;
outputs.push_back(this->ConvertToNinjaPath(d));
}
} else {
cmNinjaDeps outs;
cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);
for (cmTargetDependSet::const_iterator i = targetDeps.begin();
i != targetDeps.end(); ++i) {
if ((*i)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (cmTargetDepend const& targetDep : targetDeps) {
if (targetDep->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
this->AppendTargetOutputs(*i, outs, depends);
this->AppendTargetOutputs(targetDep, outs, depends);
}
std::sort(outs.begin(), outs.end());
outputs.insert(outputs.end(), outs.begin(), outs.end());
@@ -1060,9 +1047,8 @@ void cmGlobalNinjaGenerator::AppendTargetDependsClosure(
}
std::set<cmGeneratorTarget const*> const& targets = i->second;
cmNinjaDeps outs;
for (std::set<cmGeneratorTarget const*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti) {
this->AppendTargetOutputs(*ti, outs);
for (auto tgt : targets) {
this->AppendTargetOutputs(tgt, outs);
}
std::sort(outs.begin(), outs.end());
outputs.insert(outputs.end(), outs.begin(), outs.end());
@@ -1072,13 +1058,12 @@ void cmGlobalNinjaGenerator::ComputeTargetDependsClosure(
cmGeneratorTarget const* target, std::set<cmGeneratorTarget const*>& depends)
{
cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);
for (cmTargetDependSet::const_iterator i = targetDeps.begin();
i != targetDeps.end(); ++i) {
if ((*i)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (auto targetDep : targetDeps) {
if (targetDep->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
if (depends.insert(*i).second) {
this->ComputeTargetDependsClosure(*i, depends);
if (depends.insert(targetDep).second) {
this->ComputeTargetDependsClosure(targetDep, depends);
}
}
}
@@ -1091,8 +1076,8 @@ void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
this->AppendTargetOutputs(target, outputs);
// Mark the target's outputs as ambiguous to ensure that no other target uses
// the output as an alias.
for (cmNinjaDeps::iterator i = outputs.begin(); i != outputs.end(); ++i) {
TargetAliases[*i] = nullptr;
for (std::string const& output : outputs) {
TargetAliases[output] = nullptr;
}
// Insert the alias into the map. If the alias was already present in the
@@ -1109,17 +1094,16 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Target aliases.\n\n";
for (TargetAliasMap::const_iterator i = TargetAliases.begin();
i != TargetAliases.end(); ++i) {
for (auto const& ta : TargetAliases) {
// Don't write ambiguous aliases.
if (!i->second) {
if (!ta.second) {
continue;
}
cmNinjaDeps deps;
this->AppendTargetOutputs(i->second, deps);
this->AppendTargetOutputs(ta.second, deps);
this->WritePhonyBuild(os, "", cmNinjaDeps(1, i->first), deps);
this->WritePhonyBuild(os, "", cmNinjaDeps(1, ta.first), deps);
}
}
@@ -1129,19 +1113,13 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
os << "# Folder targets.\n\n";
std::map<std::string, cmNinjaDeps> targetsPerFolder;
for (std::vector<cmLocalGenerator*>::const_iterator lgi =
this->LocalGenerators.begin();
lgi != this->LocalGenerators.end(); ++lgi) {
cmLocalGenerator const* lg = *lgi;
for (cmLocalGenerator const* lg : this->LocalGenerators) {
const std::string currentBinaryFolder(
lg->GetStateSnapshot().GetDirectory().GetCurrentBinary());
// The directory-level rule should depend on the target-level rules
// for all targets in the directory.
targetsPerFolder[currentBinaryFolder] = cmNinjaDeps();
for (std::vector<cmGeneratorTarget*>::const_iterator ti =
lg->GetGeneratorTargets().begin();
ti != lg->GetGeneratorTargets().end(); ++ti) {
cmGeneratorTarget const* gt = *ti;
for (auto gt : lg->GetGeneratorTargets()) {
cmStateEnums::TargetType const type = gt->GetType();
if ((type == cmStateEnums::EXECUTABLE ||
type == cmStateEnums::STATIC_LIBRARY ||
@@ -1158,11 +1136,9 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
// rules of the subdirectories.
std::vector<cmStateSnapshot> const& children =
lg->GetStateSnapshot().GetChildren();
for (std::vector<cmStateSnapshot>::const_iterator stateIt =
children.begin();
stateIt != children.end(); ++stateIt) {
for (cmStateSnapshot const& state : children) {
std::string const currentBinaryDir =
stateIt->GetDirectory().GetCurrentBinary();
state.GetDirectory().GetCurrentBinary();
targetsPerFolder[currentBinaryFolder].push_back(
this->ConvertToNinjaPath(currentBinaryDir + "/all"));
@@ -1171,11 +1147,9 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
std::string const rootBinaryDir =
this->LocalGenerators[0]->GetBinaryDirectory();
for (std::map<std::string, cmNinjaDeps>::const_iterator it =
targetsPerFolder.begin();
it != targetsPerFolder.end(); ++it) {
for (auto const& it : targetsPerFolder) {
cmGlobalNinjaGenerator::WriteDivider(os);
std::string const& currentBinaryDir = it->first;
std::string const& currentBinaryDir = it.first;
// Do not generate a rule for the root binary dir.
if (rootBinaryDir.length() >= currentBinaryDir.length()) {
@@ -1186,7 +1160,7 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
cmNinjaDeps output(1);
output.push_back(this->ConvertToNinjaPath(currentBinaryDir + "/all"));
this->WritePhonyBuild(os, comment, output, it->second);
this->WritePhonyBuild(os, comment, output, it.second);
}
}
@@ -1220,50 +1194,40 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
// get the list of files that cmake itself has generated as a
// product of configuration.
for (std::vector<cmLocalGenerator*>::const_iterator i =
this->LocalGenerators.begin();
i != this->LocalGenerators.end(); ++i) {
for (cmLocalGenerator* lg : this->LocalGenerators) {
// get the vector of files created by this makefile and convert them
// to ninja paths, which are all relative in respect to the build directory
const std::vector<std::string>& files =
(*i)->GetMakefile()->GetOutputFiles();
typedef std::vector<std::string>::const_iterator vect_it;
for (vect_it j = files.begin(); j != files.end(); ++j) {
knownDependencies.insert(this->ConvertToNinjaPath(*j));
lg->GetMakefile()->GetOutputFiles();
for (std::string const& file : files) {
knownDependencies.insert(this->ConvertToNinjaPath(file));
}
// get list files which are implicit dependencies as well and will be phony
// for rebuild manifest
std::vector<std::string> const& lf = (*i)->GetMakefile()->GetListFiles();
typedef std::vector<std::string>::const_iterator vect_it;
for (vect_it j = lf.begin(); j != lf.end(); ++j) {
knownDependencies.insert(this->ConvertToNinjaPath(*j));
std::vector<std::string> const& lf = lg->GetMakefile()->GetListFiles();
for (std::string const& j : lf) {
knownDependencies.insert(this->ConvertToNinjaPath(j));
}
std::vector<cmGeneratorExpressionEvaluationFile*> const& ef =
(*i)->GetMakefile()->GetEvaluationFiles();
for (std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator li =
ef.begin();
li != ef.end(); ++li) {
lg->GetMakefile()->GetEvaluationFiles();
for (cmGeneratorExpressionEvaluationFile* li : ef) {
// get all the files created by generator expressions and convert them
// to ninja paths
std::vector<std::string> evaluationFiles = (*li)->GetFiles();
for (vect_it j = evaluationFiles.begin(); j != evaluationFiles.end();
++j) {
knownDependencies.insert(this->ConvertToNinjaPath(*j));
std::vector<std::string> evaluationFiles = li->GetFiles();
for (std::string const& evaluationFile : evaluationFiles) {
knownDependencies.insert(this->ConvertToNinjaPath(evaluationFile));
}
}
}
knownDependencies.insert(this->CMakeCacheFile);
for (TargetAliasMap::const_iterator i = this->TargetAliases.begin();
i != this->TargetAliases.end(); ++i) {
knownDependencies.insert(this->ConvertToNinjaPath(i->first));
for (auto const& ta : this->TargetAliases) {
knownDependencies.insert(this->ConvertToNinjaPath(ta.first));
}
// remove all source files we know will exist.
typedef std::map<std::string, std::set<std::string>>::const_iterator map_it;
for (map_it i = this->AssumedSourceDependencies.begin();
i != this->AssumedSourceDependencies.end(); ++i) {
knownDependencies.insert(this->ConvertToNinjaPath(i->first));
for (auto const& i : this->AssumedSourceDependencies) {
knownDependencies.insert(this->ConvertToNinjaPath(i.first));
}
// now we difference with CombinedCustomCommandExplicitDependencies to find
@@ -1285,20 +1249,18 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
bool const inSourceBuild =
(rootBuildDirectory == this->GetCMakeInstance()->GetHomeDirectory());
std::vector<std::string> warnExplicitDepends;
for (std::vector<std::string>::const_iterator i =
unknownExplicitDepends.begin();
i != unknownExplicitDepends.end(); ++i) {
for (std::string const& i : unknownExplicitDepends) {
// verify the file is in the build directory
std::string const absDepPath =
cmSystemTools::CollapseFullPath(*i, rootBuildDirectory.c_str());
cmSystemTools::CollapseFullPath(i, rootBuildDirectory.c_str());
bool const inBuildDir =
cmSystemTools::IsSubDirectory(absDepPath, rootBuildDirectory);
if (inBuildDir) {
cmNinjaDeps deps(1, *i);
cmNinjaDeps deps(1, i);
this->WritePhonyBuild(os, "", deps, cmNinjaDeps());
if (this->PolicyCMP0058 == cmPolicies::WARN && !inSourceBuild &&
warnExplicitDepends.size() < 10) {
warnExplicitDepends.push_back(*i);
warnExplicitDepends.push_back(i);
}
}
}
@@ -1373,13 +1335,11 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
/*generator=*/true);
cmNinjaDeps implicitDeps;
for (std::vector<cmLocalGenerator*>::const_iterator i =
this->LocalGenerators.begin();
i != this->LocalGenerators.end(); ++i) {
std::vector<std::string> const& lf = (*i)->GetMakefile()->GetListFiles();
for (std::vector<std::string>::const_iterator fi = lf.begin();
fi != lf.end(); ++fi) {
implicitDeps.push_back(this->ConvertToNinjaPath(*fi));
for (cmLocalGenerator* localGen : this->LocalGenerators) {
std::vector<std::string> const& lf =
localGen->GetMakefile()->GetListFiles();
for (std::string const& fi : lf) {
implicitDeps.push_back(this->ConvertToNinjaPath(fi));
}
}
implicitDeps.push_back(this->CMakeCacheFile);
@@ -1636,9 +1596,8 @@ int cmcmd_cmake_ninja_depends(std::vector<std::string>::const_iterator argBeg,
Json::Value const& tdi_include_dirs = tdi["include-dirs"];
if (tdi_include_dirs.isArray()) {
for (Json::Value::const_iterator i = tdi_include_dirs.begin();
i != tdi_include_dirs.end(); ++i) {
includes.push_back(i->asString());
for (auto const& tdi_include_dir : tdi_include_dirs) {
includes.push_back(tdi_include_dir.asString());
}
}
}
@@ -1659,9 +1618,8 @@ int cmcmd_cmake_ninja_depends(std::vector<std::string>::const_iterator argBeg,
{
cmGeneratedFileStream depfile(arg_dep.c_str());
depfile << cmSystemTools::ConvertToUnixOutputPath(arg_pp) << ":";
for (std::set<std::string>::iterator i = info.Includes.begin();
i != info.Includes.end(); ++i) {
depfile << " \\\n " << cmSystemTools::ConvertToUnixOutputPath(*i);
for (std::string const& include : info.Includes) {
depfile << " \\\n " << cmSystemTools::ConvertToUnixOutputPath(include);
}
depfile << "\n";
}
@@ -1670,16 +1628,14 @@ int cmcmd_cmake_ninja_depends(std::vector<std::string>::const_iterator argBeg,
ddi["object"] = arg_obj;
Json::Value& ddi_provides = ddi["provides"] = Json::arrayValue;
for (std::set<std::string>::iterator i = info.Provides.begin();
i != info.Provides.end(); ++i) {
ddi_provides.append(*i);
for (std::string const& provide : info.Provides) {
ddi_provides.append(provide);
}
Json::Value& ddi_requires = ddi["requires"] = Json::arrayValue;
for (std::set<std::string>::iterator i = info.Requires.begin();
i != info.Requires.end(); ++i) {
for (std::string const& r : info.Requires) {
// Require modules not provided in the same source.
if (!info.Provides.count(*i)) {
ddi_requires.append(*i);
if (!info.Provides.count(r)) {
ddi_requires.append(r);
}
}
@@ -1722,16 +1678,15 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
}
std::vector<cmFortranObjectInfo> objects;
for (std::vector<std::string>::const_iterator ddii = arg_ddis.begin();
ddii != arg_ddis.end(); ++ddii) {
for (std::string const& arg_ddi : arg_ddis) {
// Load the ddi file and compute the module file paths it provides.
Json::Value ddio;
Json::Value const& ddi = ddio;
cmsys::ifstream ddif(ddii->c_str(), std::ios::in | std::ios::binary);
cmsys::ifstream ddif(arg_ddi.c_str(), std::ios::in | std::ios::binary);
Json::Reader reader;
if (!reader.parse(ddif, ddio, false)) {
cmSystemTools::Error("-E cmake_ninja_dyndep failed to parse ",
ddii->c_str(),
arg_ddi.c_str(),
reader.getFormattedErrorMessages().c_str());
return false;
}
@@ -1740,16 +1695,14 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
info.Object = ddi["object"].asString();
Json::Value const& ddi_provides = ddi["provides"];
if (ddi_provides.isArray()) {
for (Json::Value::const_iterator i = ddi_provides.begin();
i != ddi_provides.end(); ++i) {
info.Provides.push_back(i->asString());
for (auto const& ddi_provide : ddi_provides) {
info.Provides.push_back(ddi_provide.asString());
}
}
Json::Value const& ddi_requires = ddi["requires"];
if (ddi_requires.isArray()) {
for (Json::Value::const_iterator i = ddi_requires.begin();
i != ddi_requires.end(); ++i) {
info.Requires.push_back(i->asString());
for (auto const& ddi_require : ddi_requires) {
info.Requires.push_back(ddi_require.asString());
}
}
objects.push_back(info);
@@ -1759,16 +1712,14 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
std::map<std::string, std::string> mod_files;
// Populate the module map with those provided by linked targets first.
for (std::vector<std::string>::const_iterator di =
linked_target_dirs.begin();
di != linked_target_dirs.end(); ++di) {
std::string const ltmn = *di + "/FortranModules.json";
for (std::string const& linked_target_dir : linked_target_dirs) {
std::string const ltmn = linked_target_dir + "/FortranModules.json";
Json::Value ltm;
cmsys::ifstream ltmf(ltmn.c_str(), std::ios::in | std::ios::binary);
Json::Reader reader;
if (ltmf && !reader.parse(ltmf, ltm, false)) {
cmSystemTools::Error("-E cmake_ninja_dyndep failed to parse ",
di->c_str(),
linked_target_dir.c_str(),
reader.getFormattedErrorMessages().c_str());
return false;
}
@@ -1783,21 +1734,18 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
// We do this after loading the modules provided by linked targets
// in case we have one of the same name that must be preferred.
Json::Value tm = Json::objectValue;
for (std::vector<cmFortranObjectInfo>::iterator oi = objects.begin();
oi != objects.end(); ++oi) {
for (std::vector<std::string>::iterator i = oi->Provides.begin();
i != oi->Provides.end(); ++i) {
std::string const mod = module_dir + *i + ".mod";
mod_files[*i] = mod;
tm[*i] = mod;
for (cmFortranObjectInfo const& object : objects) {
for (std::string const& p : object.Provides) {
std::string const mod = module_dir + p + ".mod";
mod_files[p] = mod;
tm[p] = mod;
}
}
cmGeneratedFileStream ddf(arg_dd.c_str());
ddf << "ninja_dyndep_version = 1.0\n";
for (std::vector<cmFortranObjectInfo>::iterator oi = objects.begin();
oi != objects.end(); ++oi) {
for (cmFortranObjectInfo const& object : objects) {
std::string const ddComment;
std::string const ddRule = "dyndep";
cmNinjaDeps ddOutputs;
@@ -1807,19 +1755,17 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
cmNinjaDeps ddOrderOnlyDeps;
cmNinjaVars ddVars;
ddOutputs.push_back(oi->Object);
for (std::vector<std::string>::iterator i = oi->Provides.begin();
i != oi->Provides.end(); ++i) {
ddImplicitOuts.push_back(this->ConvertToNinjaPath(mod_files[*i]));
ddOutputs.push_back(object.Object);
for (std::string const& p : object.Provides) {
ddImplicitOuts.push_back(this->ConvertToNinjaPath(mod_files[p]));
}
for (std::vector<std::string>::iterator i = oi->Requires.begin();
i != oi->Requires.end(); ++i) {
std::map<std::string, std::string>::iterator m = mod_files.find(*i);
for (std::string const& r : object.Requires) {
std::map<std::string, std::string>::iterator m = mod_files.find(r);
if (m != mod_files.end()) {
ddImplicitDeps.push_back(this->ConvertToNinjaPath(m->second));
}
}
if (!oi->Provides.empty()) {
if (!object.Provides.empty()) {
ddVars["restat"] = "1";
}
@@ -1846,9 +1792,7 @@ int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
std::string arg_dd;
std::string arg_tdi;
std::vector<std::string> arg_ddis;
for (std::vector<std::string>::const_iterator a = arg_full.begin();
a != arg_full.end(); ++a) {
std::string const& arg = *a;
for (std::string const& arg : arg_full) {
if (cmHasLiteralPrefix(arg, "--tdi=")) {
arg_tdi = arg.substr(6);
} else if (cmHasLiteralPrefix(arg, "--dd=")) {
@@ -1895,9 +1839,8 @@ int cmcmd_cmake_ninja_dyndep(std::vector<std::string>::const_iterator argBeg,
std::vector<std::string> linked_target_dirs;
Json::Value const& tdi_linked_target_dirs = tdi["linked-target-dirs"];
if (tdi_linked_target_dirs.isArray()) {
for (Json::Value::const_iterator i = tdi_linked_target_dirs.begin();
i != tdi_linked_target_dirs.end(); ++i) {
linked_target_dirs.push_back(i->asString());
for (auto const& tdi_linked_target_dir : tdi_linked_target_dirs) {
linked_target_dirs.push_back(tdi_linked_target_dir.asString());
}
}
Source/cmGlobalUnixMakefileGenerator3.cxx
+58 -93
View File
@@ -50,12 +50,11 @@ void cmGlobalUnixMakefileGenerator3::EnableLanguage(
std::vector<std::string> const& languages, cmMakefile* mf, bool optional)
{
this->cmGlobalGenerator::EnableLanguage(languages, mf, optional);
for (std::vector<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l) {
if (*l == "NONE") {
for (std::string const& language : languages) {
if (language == "NONE") {
continue;
}
this->ResolveLanguageCompiler(*l, mf, optional);
this->ResolveLanguageCompiler(language, mf, optional);
}
}
@@ -130,9 +129,8 @@ void cmGlobalUnixMakefileGenerator3::Generate()
// initialize progress
unsigned long total = 0;
for (ProgressMapType::const_iterator pmi = this->ProgressMap.begin();
pmi != this->ProgressMap.end(); ++pmi) {
total += pmi->second.NumberOfActions;
for (auto const& pmi : this->ProgressMap) {
total += pmi.second.NumberOfActions;
}
// write each target's progress.make this loop is done twice. Bascially the
@@ -143,12 +141,10 @@ void cmGlobalUnixMakefileGenerator3::Generate()
// well. This is because the all targets require more information that is
// computed in the first loop.
unsigned long current = 0;
for (ProgressMapType::iterator pmi = this->ProgressMap.begin();
pmi != this->ProgressMap.end(); ++pmi) {
pmi->second.WriteProgressVariables(total, current);
for (auto& pmi : this->ProgressMap) {
pmi.second.WriteProgressVariables(total, current);
}
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
cmLocalGenerator* lg = this->LocalGenerators[i];
for (cmLocalGenerator* lg : this->LocalGenerators) {
std::string markFileName = lg->GetCurrentBinaryDirectory();
markFileName += "/";
markFileName += cmake::GetCMakeFilesDirectory();
@@ -250,9 +246,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
lg->WriteSpecialTargetsTop(makefileStream);
// write the target convenience rules
unsigned int i;
for (i = 0; i < this->LocalGenerators.size(); ++i) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
for (cmLocalGenerator* localGen : this->LocalGenerators) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
this->WriteConvenienceRules2(makefileStream, lg);
}
@@ -292,8 +287,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
// for each cmMakefile get its list of dependencies
std::vector<std::string> lfiles;
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
for (cmLocalGenerator* localGen : this->LocalGenerators) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
// Get the list of files contributing to this generation step.
lfiles.insert(lfiles.end(), lg->GetMakefile()->GetListFiles().begin(),
@@ -316,9 +311,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
<< "# The top level Makefile was generated from the following files:\n"
<< "set(CMAKE_MAKEFILE_DEPENDS\n"
<< " \"CMakeCache.txt\"\n";
for (std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i) {
cmakefileStream << " \"" << lg->ConvertToRelativePath(currentBinDir, *i)
for (std::string const& f : lfiles) {
cmakefileStream << " \"" << lg->ConvertToRelativePath(currentBinDir, f)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@@ -346,17 +340,15 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
<< "set(CMAKE_MAKEFILE_PRODUCTS\n";
const std::vector<std::string>& outfiles =
lg->GetMakefile()->GetOutputFiles();
for (std::vector<std::string>::const_iterator k = outfiles.begin();
k != outfiles.end(); ++k) {
cmakefileStream << " \"" << lg->ConvertToRelativePath(binDir, *k)
for (std::string const& outfile : outfiles) {
cmakefileStream << " \"" << lg->ConvertToRelativePath(binDir, outfile)
<< "\"\n";
}
// add in all the directory information files
std::string tmpStr;
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
lg =
static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
for (cmLocalGenerator* localGen : this->LocalGenerators) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
tmpStr = lg->GetCurrentBinaryDirectory();
tmpStr += cmake::GetCMakeFilesDirectory();
tmpStr += "/CMakeDirectoryInformation.cmake";
@@ -379,19 +371,18 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefileLanguageRules(
// now list all the target info files
cmakefileStream << "# Dependency information for all targets:\n";
cmakefileStream << "set(CMAKE_DEPEND_INFO_FILES\n";
for (unsigned int i = 0; i < lGenerators.size(); ++i) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(lGenerators[i]);
for (cmLocalGenerator* lGenerator : lGenerators) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(lGenerator);
// for all of out targets
const std::vector<cmGeneratorTarget*>& tgts = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator l = tgts.begin();
l != tgts.end(); l++) {
if (((*l)->GetType() == cmStateEnums::EXECUTABLE) ||
((*l)->GetType() == cmStateEnums::STATIC_LIBRARY) ||
((*l)->GetType() == cmStateEnums::SHARED_LIBRARY) ||
((*l)->GetType() == cmStateEnums::MODULE_LIBRARY) ||
((*l)->GetType() == cmStateEnums::OBJECT_LIBRARY) ||
((*l)->GetType() == cmStateEnums::UTILITY)) {
cmGeneratorTarget* gt = *l;
for (cmGeneratorTarget* tgt : tgts) {
if ((tgt->GetType() == cmStateEnums::EXECUTABLE) ||
(tgt->GetType() == cmStateEnums::STATIC_LIBRARY) ||
(tgt->GetType() == cmStateEnums::SHARED_LIBRARY) ||
(tgt->GetType() == cmStateEnums::MODULE_LIBRARY) ||
(tgt->GetType() == cmStateEnums::OBJECT_LIBRARY) ||
(tgt->GetType() == cmStateEnums::UTILITY)) {
cmGeneratorTarget* gt = tgt;
std::string tname = lg->GetRelativeTargetDirectory(gt);
tname += "/DependInfo.cmake";
cmSystemTools::ConvertToUnixSlashes(tname);
@@ -415,9 +406,7 @@ void cmGlobalUnixMakefileGenerator3::WriteDirectoryRule2(
// for all targets in the directory.
std::vector<std::string> depends;
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator l = targets.begin();
l != targets.end(); ++l) {
cmGeneratorTarget* gtarget = *l;
for (cmGeneratorTarget* gtarget : targets) {
int type = gtarget->GetType();
if ((type == cmStateEnums::EXECUTABLE) ||
(type == cmStateEnums::STATIC_LIBRARY) ||
@@ -440,9 +429,8 @@ void cmGlobalUnixMakefileGenerator3::WriteDirectoryRule2(
// The directory-level rule should depend on the directory-level
// rules of the subdirectories.
std::vector<cmStateSnapshot> children = lg->GetStateSnapshot().GetChildren();
for (std::vector<cmStateSnapshot>::const_iterator ci = children.begin();
ci != children.end(); ++ci) {
std::string subdir = ci->GetDirectory().GetCurrentBinary();
for (cmStateSnapshot const& c : children) {
std::string subdir = c.GetDirectory().GetCurrentBinary();
subdir += "/";
subdir += pass;
depends.push_back(subdir);
@@ -542,15 +530,12 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(
depends.push_back("cmake_check_build_system");
// write the target convenience rules
unsigned int i;
cmLocalUnixMakefileGenerator3* lg;
for (i = 0; i < this->LocalGenerators.size(); ++i) {
lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
for (cmLocalGenerator* localGen : this->LocalGenerators) {
cmLocalUnixMakefileGenerator3* lg =
static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
// for each target Generate the rule files for each target.
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
cmGeneratorTarget* gtarget = *t;
for (cmGeneratorTarget* gtarget : targets) {
// Don't emit the same rule twice (e.g. two targets with the same
// simple name)
int type = gtarget->GetType();
@@ -630,9 +615,7 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
// for each target Generate the rule files for each target.
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
cmGeneratorTarget* gtarget = *t;
for (cmGeneratorTarget* gtarget : targets) {
int type = gtarget->GetType();
std::string name = gtarget->GetName();
if (!name.empty() && ((type == cmStateEnums::EXECUTABLE) ||
@@ -680,11 +663,10 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
{
std::ostringstream progressArg;
const char* sep = "";
std::vector<unsigned long>& progFiles =
std::vector<unsigned long> const& progFiles =
this->ProgressMap[gtarget].Marks;
for (std::vector<unsigned long>::iterator i = progFiles.begin();
i != progFiles.end(); ++i) {
progressArg << sep << *i;
for (unsigned long progFile : progFiles) {
progressArg << sep << progFile;
sep = ",";
}
progress.Arg = progressArg.str();
@@ -803,15 +785,9 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
{
this->DirectoryTargetsMap.clear();
// Loop over all targets in all local generators.
for (std::vector<cmLocalGenerator*>::const_iterator lgi =
this->LocalGenerators.begin();
lgi != this->LocalGenerators.end(); ++lgi) {
cmLocalGenerator* lg = *lgi;
for (cmLocalGenerator* lg : this->LocalGenerators) {
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
cmGeneratorTarget* gt = *t;
for (cmGeneratorTarget* gt : targets) {
cmLocalGenerator* tlg = gt->GetLocalGenerator();
if (gt->GetType() == cmStateEnums::INTERFACE_LIBRARY ||
@@ -835,9 +811,8 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
// target may still be included if it is a dependency of a
// non-excluded target.
TargetDependSet const& tgtdeps = this->GetTargetDirectDepends(gt);
for (TargetDependSet::const_iterator ti = tgtdeps.begin();
ti != tgtdeps.end(); ++ti) {
targetSet.insert(*ti);
for (cmTargetDepend const& tgtdep : tgtdeps) {
targetSet.insert(tgtdep);
}
}
}
@@ -851,12 +826,11 @@ size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInTarget(
if (emitted.insert(target).second) {
count = this->ProgressMap[target].Marks.size();
TargetDependSet const& depends = this->GetTargetDirectDepends(target);
for (TargetDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di) {
if ((*di)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (cmTargetDepend const& depend : depends) {
if (depend->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
count += this->CountProgressMarksInTarget(*di, emitted);
count += this->CountProgressMarksInTarget(depend, emitted);
}
}
return count;
@@ -869,9 +843,8 @@ size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInAll(
std::set<cmGeneratorTarget const*> emitted;
std::set<cmGeneratorTarget const*> const& targets =
this->DirectoryTargetsMap[lg->GetStateSnapshot()];
for (std::set<cmGeneratorTarget const*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
count += this->CountProgressMarksInTarget(*t, emitted);
for (cmGeneratorTarget const* target : targets) {
count += this->CountProgressMarksInTarget(target, emitted);
}
return count;
}
@@ -910,10 +883,9 @@ void cmGlobalUnixMakefileGenerator3::AppendGlobalTargetDepends(
std::vector<std::string>& depends, cmGeneratorTarget* target)
{
TargetDependSet const& depends_set = this->GetTargetDirectDepends(target);
for (TargetDependSet::const_iterator i = depends_set.begin();
i != depends_set.end(); ++i) {
for (cmTargetDepend const& i : depends_set) {
// Create the target-level dependency.
cmGeneratorTarget const* dep = *i;
cmGeneratorTarget const* dep = i;
if (dep->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
@@ -943,20 +915,16 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule(
std::set<std::string> emittedTargets;
// for each local generator
unsigned int i;
cmLocalUnixMakefileGenerator3* lg2;
for (i = 0; i < this->LocalGenerators.size(); ++i) {
lg2 =
static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
for (cmLocalGenerator* localGen : this->LocalGenerators) {
cmLocalUnixMakefileGenerator3* lg2 =
static_cast<cmLocalUnixMakefileGenerator3*>(localGen);
// for the passed in makefile or if this is the top Makefile wripte out
// the targets
if (lg2 == lg || lg->IsRootMakefile()) {
// for each target Generate the rule files for each target.
const std::vector<cmGeneratorTarget*>& targets =
lg2->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
cmGeneratorTarget* target = *t;
for (cmGeneratorTarget* target : targets) {
cmStateEnums::TargetType type = target->GetType();
if ((type == cmStateEnums::EXECUTABLE) ||
(type == cmStateEnums::STATIC_LIBRARY) ||
@@ -975,11 +943,9 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule(
}
}
}
std::vector<std::string> const& localHelp = lg->GetLocalHelp();
for (std::vector<std::string>::const_iterator o = localHelp.begin();
o != localHelp.end(); ++o) {
for (std::string const& o : lg->GetLocalHelp()) {
path = "... ";
path += *o;
path += o;
lg->AppendEcho(commands, path);
}
lg->WriteMakeRule(ruleFileStream, "Help Target", "help", no_depends,
@@ -994,10 +960,9 @@ bool cmGlobalUnixMakefileGenerator3::NeedRequiresStep(
target->GetLanguages(
languages,
target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::set<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l) {
for (std::string const& l : languages) {
std::string var = "CMAKE_NEEDS_REQUIRES_STEP_";
var += *l;
var += l;
var += "_FLAG";
if (target->Target->GetMakefile()->GetDefinition(var)) {
return true;
Source/cmGraphVizWriter.cxx
+40 -69
View File
@@ -122,10 +122,7 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
std::vector<std::string> ignoreTargetsRegExVector;
cmSystemTools::ExpandListArgument(ignoreTargetsRegexes,
ignoreTargetsRegExVector);
for (std::vector<std::string>::const_iterator itvIt =
ignoreTargetsRegExVector.begin();
itvIt != ignoreTargetsRegExVector.end(); ++itvIt) {
std::string currentRegexString(*itvIt);
for (std::string const& currentRegexString : ignoreTargetsRegExVector) {
cmsys::RegularExpression currentRegex;
if (!currentRegex.compile(currentRegexString.c_str())) {
std::cerr << "Could not compile bad regex \"" << currentRegexString
@@ -146,20 +143,18 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
this->CollectTargetsAndLibs();
for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
this->TargetPtrs.begin();
ptrIt != this->TargetPtrs.end(); ++ptrIt) {
if (ptrIt->second == nullptr) {
for (auto const& ptr : this->TargetPtrs) {
if (ptr.second == nullptr) {
continue;
}
if (!this->GenerateForTargetType(ptrIt->second->GetType())) {
if (!this->GenerateForTargetType(ptr.second->GetType())) {
continue;
}
std::string currentFilename = fileName;
currentFilename += ".";
currentFilename += ptrIt->first;
currentFilename += ptr.first;
currentFilename += ".dependers";
cmGeneratedFileStream str(currentFilename.c_str());
@@ -173,7 +168,7 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
std::cout << "Writing " << currentFilename << "..." << std::endl;
this->WriteHeader(str);
this->WriteDependerConnections(ptrIt->first, insertedNodes,
this->WriteDependerConnections(ptr.first, insertedNodes,
insertedConnections, str);
this->WriteFooter(str);
@@ -190,14 +185,12 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
this->CollectTargetsAndLibs();
for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
this->TargetPtrs.begin();
ptrIt != this->TargetPtrs.end(); ++ptrIt) {
if (ptrIt->second == nullptr) {
for (auto const& ptr : this->TargetPtrs) {
if (ptr.second == nullptr) {
continue;
}
if (!this->GenerateForTargetType(ptrIt->second->GetType())) {
if (!this->GenerateForTargetType(ptr.second->GetType())) {
continue;
}
@@ -206,7 +199,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
std::string currentFilename = fileName;
currentFilename += ".";
currentFilename += ptrIt->first;
currentFilename += ptr.first;
cmGeneratedFileStream str(currentFilename.c_str());
if (!str) {
return;
@@ -215,8 +208,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
std::cout << "Writing " << currentFilename << "..." << std::endl;
this->WriteHeader(str);
this->WriteConnections(ptrIt->first, insertedNodes, insertedConnections,
str);
this->WriteConnections(ptr.first, insertedNodes, insertedConnections, str);
this->WriteFooter(str);
}
}
@@ -236,19 +228,16 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName)
std::set<std::string> insertedConnections;
std::set<std::string> insertedNodes;
for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
this->TargetPtrs.begin();
ptrIt != this->TargetPtrs.end(); ++ptrIt) {
if (ptrIt->second == nullptr) {
for (auto const& ptr : this->TargetPtrs) {
if (ptr.second == nullptr) {
continue;
}
if (!this->GenerateForTargetType(ptrIt->second->GetType())) {
if (!this->GenerateForTargetType(ptr.second->GetType())) {
continue;
}
this->WriteConnections(ptrIt->first, insertedNodes, insertedConnections,
str);
this->WriteConnections(ptr.first, insertedNodes, insertedConnections, str);
}
this->WriteFooter(str);
}
@@ -288,9 +277,8 @@ void cmGraphVizWriter::WriteConnections(
const cmTarget::LinkLibraryVectorType* ll =
&(targetPtrIt->second->Target->GetOriginalLinkLibraries());
for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
llit != ll->end(); ++llit) {
const char* libName = llit->first.c_str();
for (auto const& llit : *ll) {
const char* libName = llit.first.c_str();
std::map<std::string, std::string>::const_iterator libNameIt =
this->TargetNamesNodes.find(libName);
@@ -337,29 +325,26 @@ void cmGraphVizWriter::WriteDependerConnections(
std::string myNodeName = this->TargetNamesNodes.find(targetName)->second;
// now search who links against me
for (std::map<std::string, const cmGeneratorTarget*>::const_iterator
dependerIt = this->TargetPtrs.begin();
dependerIt != this->TargetPtrs.end(); ++dependerIt) {
if (dependerIt->second == nullptr) {
for (auto const& tptr : this->TargetPtrs) {
if (tptr.second == nullptr) {
continue;
}
if (!this->GenerateForTargetType(dependerIt->second->GetType())) {
if (!this->GenerateForTargetType(tptr.second->GetType())) {
continue;
}
// Now we have a target, check whether it links against targetName.
// If so, draw a connection, and then continue with dependers on that one.
const cmTarget::LinkLibraryVectorType* ll =
&(dependerIt->second->Target->GetOriginalLinkLibraries());
&(tptr.second->Target->GetOriginalLinkLibraries());
for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
llit != ll->end(); ++llit) {
std::string libName = llit->first;
for (auto const& llit : *ll) {
std::string libName = llit.first;
if (libName == targetName) {
// So this target links against targetName.
std::map<std::string, std::string>::const_iterator dependerNodeNameIt =
this->TargetNamesNodes.find(dependerIt->first);
this->TargetNamesNodes.find(tptr.first);
if (dependerNodeNameIt != this->TargetNamesNodes.end()) {
std::string connectionName = dependerNodeNameIt->second;
@@ -369,14 +354,12 @@ void cmGraphVizWriter::WriteDependerConnections(
if (insertedConnections.find(connectionName) ==
insertedConnections.end()) {
insertedConnections.insert(connectionName);
this->WriteNode(dependerIt->first, dependerIt->second,
insertedNodes, str);
this->WriteNode(tptr.first, tptr.second, insertedNodes, str);
str << " \"" << dependerNodeNameIt->second << "\" -> \""
<< myNodeName << "\"";
str << " // " << targetName << " -> " << dependerIt->first
<< std::endl;
this->WriteDependerConnections(dependerIt->first, insertedNodes,
str << " // " << targetName << " -> " << tptr.first << std::endl;
this->WriteDependerConnections(tptr.first, insertedNodes,
insertedConnections, str);
}
}
@@ -416,14 +399,10 @@ int cmGraphVizWriter::CollectAllTargets()
{
int cnt = 0;
// First pass get the list of all cmake targets
for (std::vector<cmLocalGenerator*>::const_iterator lit =
this->LocalGenerators.begin();
lit != this->LocalGenerators.end(); ++lit) {
const std::vector<cmGeneratorTarget*>& targets =
(*lit)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator it = targets.begin();
it != targets.end(); ++it) {
const char* realTargetName = (*it)->GetName().c_str();
for (cmLocalGenerator* lg : this->LocalGenerators) {
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
const char* realTargetName = target->GetName().c_str();
if (this->IgnoreThisTarget(realTargetName)) {
// Skip ignored targets
continue;
@@ -432,7 +411,7 @@ int cmGraphVizWriter::CollectAllTargets()
std::ostringstream ostr;
ostr << this->GraphNodePrefix << cnt++;
this->TargetNamesNodes[realTargetName] = ostr.str();
this->TargetPtrs[realTargetName] = *it;
this->TargetPtrs[realTargetName] = target;
}
}
@@ -442,23 +421,18 @@ int cmGraphVizWriter::CollectAllTargets()
int cmGraphVizWriter::CollectAllExternalLibs(int cnt)
{
// Ok, now find all the stuff we link to that is not in cmake
for (std::vector<cmLocalGenerator*>::const_iterator lit =
this->LocalGenerators.begin();
lit != this->LocalGenerators.end(); ++lit) {
const std::vector<cmGeneratorTarget*>& targets =
(*lit)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator it = targets.begin();
it != targets.end(); ++it) {
const char* realTargetName = (*it)->GetName().c_str();
for (cmLocalGenerator* lg : this->LocalGenerators) {
const std::vector<cmGeneratorTarget*>& targets = lg->GetGeneratorTargets();
for (cmGeneratorTarget* target : targets) {
const char* realTargetName = target->GetName().c_str();
if (this->IgnoreThisTarget(realTargetName)) {
// Skip ignored targets
continue;
}
const cmTarget::LinkLibraryVectorType* ll =
&((*it)->Target->GetOriginalLinkLibraries());
for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
llit != ll->end(); ++llit) {
const char* libName = llit->first.c_str();
&(target->Target->GetOriginalLinkLibraries());
for (auto const& llit : *ll) {
const char* libName = llit.first.c_str();
if (this->IgnoreThisTarget(libName)) {
// Skip ignored targets
continue;
@@ -482,10 +456,7 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt)
bool cmGraphVizWriter::IgnoreThisTarget(const std::string& name)
{
for (std::vector<cmsys::RegularExpression>::iterator itvIt =
this->TargetsToIgnoreRegex.begin();
itvIt != this->TargetsToIgnoreRegex.end(); ++itvIt) {
cmsys::RegularExpression& regEx = *itvIt;
for (cmsys::RegularExpression& regEx : this->TargetsToIgnoreRegex) {
if (regEx.is_valid()) {
if (regEx.find(name)) {
return true;
Source/cmIfCommand.cxx
+17 -21
View File
@@ -15,10 +15,9 @@ static std::string cmIfCommandError(
std::vector<cmExpandedCommandArgument> const& args)
{
std::string err = "given arguments:\n ";
for (std::vector<cmExpandedCommandArgument>::const_iterator i = args.begin();
i != args.end(); ++i) {
for (cmExpandedCommandArgument const& i : args) {
err += " ";
err += cmOutputConverter::EscapeForCMake(i->GetValue());
err += cmOutputConverter::EscapeForCMake(i.GetValue());
}
err += "\n";
return err;
@@ -45,21 +44,20 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// execute the functions for the true parts of the if statement
cmExecutionStatus status;
int scopeDepth = 0;
for (unsigned int c = 0; c < this->Functions.size(); ++c) {
for (cmListFileFunction const& func : this->Functions) {
// keep track of scope depth
if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(), "if")) {
if (!cmSystemTools::Strucmp(func.Name.c_str(), "if")) {
scopeDepth++;
}
if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),
"endif")) {
if (!cmSystemTools::Strucmp(func.Name.c_str(), "endif")) {
scopeDepth--;
}
// watch for our state change
if (scopeDepth == 0 &&
!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(), "else")) {
!cmSystemTools::Strucmp(func.Name.c_str(), "else")) {
if (this->ElseSeen) {
cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
cmListFileBacktrace bt = mf.GetBacktrace(func);
mf.GetCMakeInstance()->IssueMessage(
cmake::FATAL_ERROR,
"A duplicate ELSE command was found inside an IF block.", bt);
@@ -74,13 +72,12 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// if trace is enabled, print a (trivially) evaluated "else"
// statement
if (!this->IsBlocking && mf.GetCMakeInstance()->GetTrace()) {
mf.PrintCommandTrace(this->Functions[c]);
mf.PrintCommandTrace(func);
}
} else if (scopeDepth == 0 &&
!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),
"elseif")) {
!cmSystemTools::Strucmp(func.Name.c_str(), "elseif")) {
if (this->ElseSeen) {
cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
cmListFileBacktrace bt = mf.GetBacktrace(func);
mf.GetCMakeInstance()->IssueMessage(
cmake::FATAL_ERROR,
"An ELSEIF command was found after an ELSE command.", bt);
@@ -93,23 +90,22 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
} else {
// if trace is enabled, print the evaluated "elseif" statement
if (mf.GetCMakeInstance()->GetTrace()) {
mf.PrintCommandTrace(this->Functions[c]);
mf.PrintCommandTrace(func);
}
std::string errorString;
std::vector<cmExpandedCommandArgument> expandedArguments;
mf.ExpandArguments(this->Functions[c].Arguments,
expandedArguments);
mf.ExpandArguments(func.Arguments, expandedArguments);
cmake::MessageType messType;
cmListFileContext conditionContext =
cmListFileContext::FromCommandContext(
this->Functions[c], this->GetStartingContext().FilePath);
func, this->GetStartingContext().FilePath);
cmConditionEvaluator conditionEvaluator(
mf, conditionContext, mf.GetBacktrace(this->Functions[c]));
cmConditionEvaluator conditionEvaluator(mf, conditionContext,
mf.GetBacktrace(func));
bool isTrue = conditionEvaluator.IsTrue(expandedArguments,
errorString, messType);
@@ -117,7 +113,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
if (!errorString.empty()) {
std::string err = cmIfCommandError(expandedArguments);
err += errorString;
cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
cmListFileBacktrace bt = mf.GetBacktrace(func);
mf.GetCMakeInstance()->IssueMessage(messType, err, bt);
if (messType == cmake::FATAL_ERROR) {
cmSystemTools::SetFatalErrorOccured();
@@ -135,7 +131,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// should we execute?
else if (!this->IsBlocking) {
status.Clear();
mf.ExecuteCommand(this->Functions[c], status);
mf.ExecuteCommand(func, status);
if (status.GetReturnInvoked()) {
inStatus.SetReturnInvoked();
return true;
Source/cmIncludeExternalMSProjectCommand.cxx
+2 -3
View File
@@ -91,9 +91,8 @@ bool cmIncludeExternalMSProjectCommand::InitialPass(
if (!platformMapping.empty())
target->SetProperty("VS_PLATFORM_MAPPING", platformMapping.c_str());
for (std::vector<std::string>::const_iterator it = depends.begin();
it != depends.end(); ++it) {
target->AddUtility(it->c_str());
for (std::string const& d : depends) {
target->AddUtility(d.c_str());
}
}
#endif
Source/cmInstallCommand.cxx
+25 -34
View File
@@ -141,23 +141,23 @@ bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
// Scan the args again, this time adding install generators each time we
// encounter a SCRIPT or CODE arg:
//
for (size_t i = 0; i < args.size(); ++i) {
if (args[i] == "SCRIPT") {
for (std::string const& arg : args) {
if (arg == "SCRIPT") {
doing_script = true;
doing_code = false;
} else if (args[i] == "CODE") {
} else if (arg == "CODE") {
doing_script = false;
doing_code = true;
} else if (args[i] == "COMPONENT") {
} else if (arg == "COMPONENT") {
doing_script = false;
doing_code = false;
} else if (doing_script) {
doing_script = false;
std::string script = args[i];
std::string script = arg;
if (!cmSystemTools::FileIsFullPath(script.c_str())) {
script = this->Makefile->GetCurrentSourceDirectory();
script += "/";
script += args[i];
script += arg;
}
if (cmSystemTools::FileIsDirectory(script)) {
this->SetError("given a directory as value of SCRIPT argument.");
@@ -167,7 +167,7 @@ bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
script.c_str(), false, component.c_str(), exclude_from_all));
} else if (doing_code) {
doing_code = false;
std::string const& code = args[i];
std::string const& code = arg;
this->Makefile->AddInstallGenerator(new cmInstallScriptGenerator(
code.c_str(), true, component.c_str(), exclude_from_all));
}
@@ -336,19 +336,16 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
(this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
this->Makefile->IsOn("MINGW"));
for (std::vector<std::string>::const_iterator targetIt =
targetList.GetVector().begin();
targetIt != targetList.GetVector().end(); ++targetIt) {
for (std::string const& tgt : targetList.GetVector()) {
if (this->Makefile->IsAlias(*targetIt)) {
if (this->Makefile->IsAlias(tgt)) {
std::ostringstream e;
e << "TARGETS given target \"" << (*targetIt) << "\" which is an alias.";
e << "TARGETS given target \"" << tgt << "\" which is an alias.";
this->SetError(e.str());
return false;
}
// Lookup this target in the current directory.
if (cmTarget* target =
this->Makefile->FindLocalNonAliasTarget(*targetIt)) {
if (cmTarget* target = this->Makefile->FindLocalNonAliasTarget(tgt)) {
// Found the target. Check its type.
if (target->GetType() != cmStateEnums::EXECUTABLE &&
target->GetType() != cmStateEnums::STATIC_LIBRARY &&
@@ -357,7 +354,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
target->GetType() != cmStateEnums::OBJECT_LIBRARY &&
target->GetType() != cmStateEnums::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "TARGETS given target \"" << (*targetIt)
e << "TARGETS given target \"" << tgt
<< "\" which is not an executable, library, or module.";
this->SetError(e.str());
return false;
@@ -367,7 +364,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
if (!this->Makefile->GetGlobalGenerator()->HasKnownObjectFileLocation(
&reason)) {
std::ostringstream e;
e << "TARGETS given OBJECT library \"" << (*targetIt)
e << "TARGETS given OBJECT library \"" << tgt
<< "\" which may not be installed" << reason << ".";
this->SetError(e.str());
return false;
@@ -378,7 +375,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
} else {
// Did not find the target.
std::ostringstream e;
e << "TARGETS given target \"" << (*targetIt)
e << "TARGETS given target \"" << tgt
<< "\" which does not exist in this directory.";
this->SetError(e.str());
return false;
@@ -398,10 +395,9 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
bool installsResource = false;
// Generate install script code to install the given targets.
for (std::vector<cmTarget*>::iterator ti = targets.begin();
ti != targets.end(); ++ti) {
for (cmTarget* ti : targets) {
// Handle each target type.
cmTarget& target = *(*ti);
cmTarget& target = *ti;
cmInstallTargetGenerator* archiveGenerator = nullptr;
cmInstallTargetGenerator* libraryGenerator = nullptr;
cmInstallTargetGenerator* runtimeGenerator = nullptr;
@@ -815,9 +811,8 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
this->Makefile->GetPolicyStatus(cmPolicies::CMP0062);
cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
for (std::vector<std::string>::const_iterator fileIt = filesVector.begin();
fileIt != filesVector.end(); ++fileIt) {
if (gg->IsExportedTargetsFile(*fileIt)) {
for (std::string const& file : filesVector) {
if (gg->IsExportedTargetsFile(file)) {
const char* modal = nullptr;
std::ostringstream e;
cmake::MessageType messageType = cmake::AUTHOR_WARNING;
@@ -835,8 +830,8 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
messageType = cmake::FATAL_ERROR;
}
if (modal) {
e << "The file\n " << *fileIt << "\nwas generated by the export() "
"command. It "
e << "The file\n " << file << "\nwas generated by the export() "
"command. It "
<< modal << " not be installed with the "
"install() command. Use the install(EXPORT) mechanism "
"instead. See the cmake-packages(7) manual for more.\n";
@@ -1339,10 +1334,7 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
cmExportSet* exportSet =
this->Makefile->GetGlobalGenerator()->GetExportSets()[exp.GetString()];
if (exportOld.IsEnabled()) {
for (std::vector<cmTargetExport*>::const_iterator tei =
exportSet->GetTargetExports()->begin();
tei != exportSet->GetTargetExports()->end(); ++tei) {
cmTargetExport const* te = *tei;
for (cmTargetExport* te : *exportSet->GetTargetExports()) {
cmTarget* tgt =
this->Makefile->GetGlobalGenerator()->FindTarget(te->TargetName);
const bool newCMP0022Behavior =
@@ -1379,20 +1371,19 @@ bool cmInstallCommand::MakeFilesFullPath(
const char* modeName, const std::vector<std::string>& relFiles,
std::vector<std::string>& absFiles)
{
for (std::vector<std::string>::const_iterator fileIt = relFiles.begin();
fileIt != relFiles.end(); ++fileIt) {
std::string file = (*fileIt);
for (std::string const& relFile : relFiles) {
std::string file = relFile;
std::string::size_type gpos = cmGeneratorExpression::Find(file);
if (gpos != 0 && !cmSystemTools::FileIsFullPath(file.c_str())) {
file = this->Makefile->GetCurrentSourceDirectory();
file += "/";
file += *fileIt;
file += relFile;
}
// Make sure the file is not a directory.
if (gpos == std::string::npos && cmSystemTools::FileIsDirectory(file)) {
std::ostringstream e;
e << modeName << " given directory \"" << (*fileIt) << "\" to install.";
e << modeName << " given directory \"" << relFile << "\" to install.";
this->SetError(e.str());
return false;
}
Source/cmInstallCommandArguments.cxx
+2 -4
View File
@@ -154,10 +154,8 @@ void cmInstallCommandArguments::Parse(const std::vector<std::string>* args,
bool cmInstallCommandArguments::CheckPermissions()
{
this->PermissionsString = "";
for (std::vector<std::string>::const_iterator permIt =
this->Permissions.GetVector().begin();
permIt != this->Permissions.GetVector().end(); ++permIt) {
if (!this->CheckPermissions(*permIt, this->PermissionsString)) {
for (std::string const& perm : this->Permissions.GetVector()) {
if (!this->CheckPermissions(perm, this->PermissionsString)) {
return false;
}
}
Source/cmInstallDirectoryGenerator.cxx
+5 -7
View File
@@ -62,19 +62,17 @@ void cmInstallDirectoryGenerator::GenerateScriptForConfig(
{
std::vector<std::string> dirs;
cmGeneratorExpression ge;
for (std::vector<std::string>::const_iterator i = this->Directories.begin();
i != this->Directories.end(); ++i) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
for (std::string const& d : this->Directories) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(d);
cmSystemTools::ExpandListArgument(
cge->Evaluate(this->LocalGenerator, config), dirs);
}
// Make sure all dirs have absolute paths.
cmMakefile const& mf = *this->LocalGenerator->GetMakefile();
for (std::vector<std::string>::iterator i = dirs.begin(); i != dirs.end();
++i) {
if (!cmSystemTools::FileIsFullPath(i->c_str())) {
*i = std::string(mf.GetCurrentSourceDirectory()) + "/" + *i;
for (std::string& d : dirs) {
if (!cmSystemTools::FileIsFullPath(d.c_str())) {
d = std::string(mf.GetCurrentSourceDirectory()) + "/" + d;
}
}
Source/cmInstallExportGenerator.cxx
+8 -15
View File
@@ -3,7 +3,6 @@
#include "cmInstallExportGenerator.h"
#include <algorithm>
#include <map>
#include <sstream>
#include <utility>
@@ -111,11 +110,9 @@ size_t cmInstallExportGenerator::GetMaxConfigLength() const
len = this->ConfigurationName.size();
}
} else {
for (std::vector<std::string>::const_iterator ci =
this->ConfigurationTypes->begin();
ci != this->ConfigurationTypes->end(); ++ci) {
if (ci->size() > len) {
len = ci->size();
for (std::string const& c : *this->ConfigurationTypes) {
if (c.size() > len) {
len = c.size();
}
}
}
@@ -153,10 +150,8 @@ void cmInstallExportGenerator::GenerateScript(std::ostream& os)
this->EFGen->AddConfiguration("");
}
} else {
for (std::vector<std::string>::const_iterator ci =
this->ConfigurationTypes->begin();
ci != this->ConfigurationTypes->end(); ++ci) {
this->EFGen->AddConfiguration(*ci);
for (std::string const& c : *this->ConfigurationTypes) {
this->EFGen->AddConfiguration(c);
}
}
this->EFGen->GenerateImportFile();
@@ -174,11 +169,9 @@ void cmInstallExportGenerator::GenerateScriptConfigs(std::ostream& os,
// Now create a configuration-specific install rule for the import
// file of each configuration.
std::vector<std::string> files;
for (std::map<std::string, std::string>::const_iterator i =
this->EFGen->GetConfigImportFiles().begin();
i != this->EFGen->GetConfigImportFiles().end(); ++i) {
files.push_back(i->second);
std::string config_test = this->CreateConfigTest(i->first);
for (auto const& i : this->EFGen->GetConfigImportFiles()) {
files.push_back(i.second);
std::string config_test = this->CreateConfigTest(i.first);
os << indent << "if(" << config_test << ")\n";
this->AddInstallRule(os, this->Destination, cmInstallType_FILES, files,
false, this->FilePermissions.c_str(), nullptr,
Source/cmInstallFilesGenerator.cxx
+2 -3
View File
@@ -81,9 +81,8 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(
{
std::vector<std::string> files;
cmGeneratorExpression ge;
for (std::vector<std::string>::const_iterator i = this->Files.begin();
i != this->Files.end(); ++i) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
for (std::string const& f : this->Files) {
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(f);
cmSystemTools::ExpandListArgument(
cge->Evaluate(this->LocalGenerator, config), files);
}
Source/cmInstallGenerator.cxx
+2 -3
View File
@@ -113,9 +113,8 @@ void cmInstallGenerator::AddInstallRule(
if (files.size() == 1) {
os << " \"" << files[0] << "\"";
} else {
for (std::vector<std::string>::const_iterator fi = files.begin();
fi != files.end(); ++fi) {
os << "\n" << indent << " \"" << *fi << "\"";
for (std::string const& f : files) {
os << "\n" << indent << " \"" << f << "\"";
}
os << "\n" << indent << " ";
if (!(literal_args && *literal_args)) {
Source/cmInstallTargetGenerator.cxx
+11 -22
View File
@@ -362,9 +362,8 @@ void cmInstallTargetGenerator::GetInstallObjectNames(
std::string const& config, std::vector<std::string>& objects) const
{
this->Target->GetTargetObjectNames(config, objects);
for (std::vector<std::string>::iterator i = objects.begin();
i != objects.end(); ++i) {
*i = computeInstallObjectDir(this->Target, config) + "/" + *i;
for (std::string& o : objects) {
o = computeInstallObjectDir(this->Target, config) + "/" + o;
}
}
@@ -476,9 +475,8 @@ void cmInstallTargetGenerator::AddTweak(std::ostream& os, Indent indent,
if (!tws.empty()) {
Indent indent2 = indent.Next().Next();
os << indent << "foreach(file\n";
for (std::vector<std::string>::const_iterator i = files.begin();
i != files.end(); ++i) {
os << indent2 << "\"" << this->GetDestDirPath(*i) << "\"\n";
for (std::string const& f : files) {
os << indent2 << "\"" << this->GetDestDirPath(f) << "\"\n";
}
os << indent2 << ")\n";
os << tws;
@@ -546,11 +544,7 @@ void cmInstallTargetGenerator::AddInstallNamePatchRule(
this->Target->GetLinkInformation(config)) {
std::set<cmGeneratorTarget const*> const& sharedLibs =
cli->GetSharedLibrariesLinked();
for (std::set<cmGeneratorTarget const*>::const_iterator j =
sharedLibs.begin();
j != sharedLibs.end(); ++j) {
cmGeneratorTarget const* tgt = *j;
for (cmGeneratorTarget const* tgt : sharedLibs) {
// The install_name of an imported target does not change.
if (tgt->IsImported()) {
continue;
@@ -609,12 +603,9 @@ void cmInstallTargetGenerator::AddInstallNamePatchRule(
if (!new_id.empty()) {
os << "\n" << indent << " -id \"" << new_id << "\"";
}
for (std::map<std::string, std::string>::const_iterator i =
install_name_remap.begin();
i != install_name_remap.end(); ++i) {
for (auto const& i : install_name_remap) {
os << "\n"
<< indent << " -change \"" << i->first << "\" \"" << i->second
<< "\"";
<< indent << " -change \"" << i.first << "\" \"" << i.second << "\"";
}
os << "\n" << indent << " \"" << toDestDirPath << "\")\n";
}
@@ -702,10 +693,9 @@ void cmInstallTargetGenerator::AddChrpathPatchRule(
// Note: These paths are kept unique to avoid
// install_name_tool corruption.
std::set<std::string> runpaths;
for (std::vector<std::string>::const_iterator i = oldRuntimeDirs.begin();
i != oldRuntimeDirs.end(); ++i) {
for (std::string const& i : oldRuntimeDirs) {
std::string runpath =
mf->GetGlobalGenerator()->ExpandCFGIntDir(*i, config);
mf->GetGlobalGenerator()->ExpandCFGIntDir(i, config);
if (runpaths.find(runpath) == runpaths.end()) {
runpaths.insert(runpath);
@@ -717,10 +707,9 @@ void cmInstallTargetGenerator::AddChrpathPatchRule(
}
runpaths.clear();
for (std::vector<std::string>::const_iterator i = newRuntimeDirs.begin();
i != newRuntimeDirs.end(); ++i) {
for (std::string const& i : newRuntimeDirs) {
std::string runpath =
mf->GetGlobalGenerator()->ExpandCFGIntDir(*i, config);
mf->GetGlobalGenerator()->ExpandCFGIntDir(i, config);
if (runpaths.find(runpath) == runpaths.end()) {
os << indent << "execute_process(COMMAND " << installNameTool
Source/cmInstalledFile.cxx
+2 -4
View File
@@ -90,11 +90,9 @@ bool cmInstalledFile::GetProperty(const std::string& prop,
std::string output;
std::string separator;
for (ExpressionVectorType::const_iterator j =
property.ValueExpressions.begin();
j != property.ValueExpressions.end(); ++j) {
for (auto ve : property.ValueExpressions) {
output += separator;
output += (*j)->GetInput();
output += ve->GetInput();
separator = ";";
}
Source/cmLinkDirectoriesCommand.cxx
+2 -3
View File
@@ -19,9 +19,8 @@ bool cmLinkDirectoriesCommand::InitialPass(
return true;
}
for (std::vector<std::string>::const_iterator i = args.begin();
i != args.end(); ++i) {
this->AddLinkDir(*i);
for (std::string const& i : args) {
this->AddLinkDir(i);
}
return true;
}
Source/cmLinkLineComputer.cxx
+12 -16
View File
@@ -59,17 +59,16 @@ std::string cmLinkLineComputer::ComputeLinkLibs(cmComputeLinkInformation& cli)
std::string linkLibs;
typedef cmComputeLinkInformation::ItemVector ItemVector;
ItemVector const& items = cli.GetItems();
for (ItemVector::const_iterator li = items.begin(); li != items.end();
++li) {
if (li->Target &&
li->Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (auto const& item : items) {
if (item.Target &&
item.Target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
if (li->IsPath) {
if (item.IsPath) {
linkLibs +=
this->ConvertToOutputFormat(this->ConvertToLinkReference(li->Value));
this->ConvertToOutputFormat(this->ConvertToLinkReference(item.Value));
} else {
linkLibs += li->Value;
linkLibs += item.Value;
}
linkLibs += " ";
}
@@ -103,9 +102,8 @@ std::string cmLinkLineComputer::ComputeLinkPath(
{
std::string linkPath;
std::vector<std::string> const& libDirs = cli.GetDirectories();
for (std::vector<std::string>::const_iterator libDir = libDirs.begin();
libDir != libDirs.end(); ++libDir) {
std::string libpath = this->ConvertToOutputForExisting(*libDir);
for (std::string const& libDir : libDirs) {
std::string libpath = this->ConvertToOutputForExisting(libDir);
linkPath += " " + libPathFlag;
linkPath += libpath;
linkPath += libPathTerminator;
@@ -123,10 +121,9 @@ std::string cmLinkLineComputer::ComputeRPath(cmComputeLinkInformation& cli)
std::vector<std::string> runtimeDirs;
cli.GetRPath(runtimeDirs, this->Relink);
for (std::vector<std::string>::iterator ri = runtimeDirs.begin();
ri != runtimeDirs.end(); ++ri) {
for (std::string const& rd : runtimeDirs) {
rpath += cli.GetRuntimeFlag();
rpath += this->ConvertToOutputFormat(*ri);
rpath += this->ConvertToOutputFormat(rd);
rpath += " ";
}
} else {
@@ -150,10 +147,9 @@ std::string cmLinkLineComputer::ComputeFrameworkPath(
std::string frameworkPath;
if (!fwSearchFlag.empty()) {
std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths();
for (std::vector<std::string>::const_iterator fdi = fwDirs.begin();
fdi != fwDirs.end(); ++fdi) {
for (std::string const& fd : fwDirs) {
frameworkPath += fwSearchFlag;
frameworkPath += this->ConvertToOutputFormat(*fdi);
frameworkPath += this->ConvertToOutputFormat(fd);
frameworkPath += " ";
}
}
Source/cmLinkLineDeviceComputer.cxx
+8 -10
View File
@@ -5,7 +5,6 @@
#include <set>
#include <sstream>
#include <vector>
#include "cmComputeLinkInformation.h"
#include "cmGeneratorTarget.h"
@@ -32,14 +31,13 @@ std::string cmLinkLineDeviceComputer::ComputeLinkLibraries(
typedef cmComputeLinkInformation::ItemVector ItemVector;
ItemVector const& items = cli.GetItems();
std::string config = cli.GetConfig();
for (ItemVector::const_iterator li = items.begin(); li != items.end();
++li) {
if (!li->Target) {
for (auto const& item : items) {
if (!item.Target) {
continue;
}
bool skippable = false;
switch (li->Target->GetType()) {
switch (item.Target->GetType()) {
case cmStateEnums::SHARED_LIBRARY:
case cmStateEnums::MODULE_LIBRARY:
case cmStateEnums::INTERFACE_LIBRARY:
@@ -49,7 +47,7 @@ std::string cmLinkLineDeviceComputer::ComputeLinkLibraries(
// If a static library is resolving its device linking, it should
// be removed for other device linking
skippable =
li->Target->GetPropertyAsBool("CUDA_RESOLVE_DEVICE_SYMBOLS");
item.Target->GetPropertyAsBool("CUDA_RESOLVE_DEVICE_SYMBOLS");
break;
default:
break;
@@ -60,16 +58,16 @@ std::string cmLinkLineDeviceComputer::ComputeLinkLibraries(
}
std::set<std::string> langs;
li->Target->GetLanguages(langs, config);
item.Target->GetLanguages(langs, config);
if (langs.count("CUDA") == 0) {
continue;
}
if (li->IsPath) {
if (item.IsPath) {
fout << this->ConvertToOutputFormat(
this->ConvertToLinkReference(li->Value));
this->ConvertToLinkReference(item.Value));
} else {
fout << li->Value;
fout << item.Value;
}
fout << " ";
}
Source/cmLoadCacheCommand.cxx
+11 -12
View File
@@ -27,17 +27,16 @@ bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args,
// If this set is empty, all cache entries are brought in
// and they can not be overridden.
bool excludeFiles = false;
unsigned int i;
std::set<std::string> excludes;
for (i = 0; i < args.size(); i++) {
for (std::string const& arg : args) {
if (excludeFiles) {
excludes.insert(args[i]);
excludes.insert(arg);
}
if (args[i] == "EXCLUDE") {
if (arg == "EXCLUDE") {
excludeFiles = true;
}
if (excludeFiles && (args[i] == "INCLUDE_INTERNALS")) {
if (excludeFiles && (arg == "INCLUDE_INTERNALS")) {
break;
}
}
@@ -48,25 +47,25 @@ bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args,
bool includeFiles = false;
std::set<std::string> includes;
for (i = 0; i < args.size(); i++) {
for (std::string const& arg : args) {
if (includeFiles) {
includes.insert(args[i]);
includes.insert(arg);
}
if (args[i] == "INCLUDE_INTERNALS") {
if (arg == "INCLUDE_INTERNALS") {
includeFiles = true;
}
if (includeFiles && (args[i] == "EXCLUDE")) {
if (includeFiles && (arg == "EXCLUDE")) {
break;
}
}
// Loop over each build directory listed in the arguments. Each
// directory has a cache file.
for (i = 0; i < args.size(); i++) {
if ((args[i] == "EXCLUDE") || (args[i] == "INCLUDE_INTERNALS")) {
for (std::string const& arg : args) {
if ((arg == "EXCLUDE") || (arg == "INCLUDE_INTERNALS")) {
break;
}
this->Makefile->GetCMakeInstance()->LoadCache(args[i], false, excludes,
this->Makefile->GetCMakeInstance()->LoadCache(arg, false, excludes,
includes);
}
Source/cmLocalCommonGenerator.cxx
+2 -3
View File
@@ -67,10 +67,9 @@ std::string cmLocalCommonGenerator::GetTargetFortranFlags(
this->Makefile->GetDefinition("CMAKE_Fortran_MODPATH_FLAG")) {
std::vector<std::string> includes;
this->GetIncludeDirectories(includes, target, "C", config);
for (std::vector<std::string>::const_iterator idi = includes.begin();
idi != includes.end(); ++idi) {
for (std::string const& id : includes) {
std::string flg = modpath_flag;
flg += this->ConvertToOutputFormat(*idi, cmOutputConverter::SHELL);
flg += this->ConvertToOutputFormat(id, cmOutputConverter::SHELL);
this->AppendFlags(flags, flg);
}
}
Source/cmLocalGenerator.cxx
+105 -145
View File
@@ -102,9 +102,7 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, cmMakefile* makefile)
this->LinkerSysroot = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
}
for (std::vector<std::string>::iterator i = enabledLanguages.begin();
i != enabledLanguages.end(); ++i) {
std::string const& lang = *i;
for (std::string const& lang : enabledLanguages) {
if (lang == "NONE") {
continue;
}
@@ -209,18 +207,16 @@ void cmLocalGenerator::TraceDependencies()
if (configs.empty()) {
configs.push_back("");
}
for (std::vector<std::string>::const_iterator ci = configs.begin();
ci != configs.end(); ++ci) {
this->GlobalGenerator->CreateEvaluationSourceFiles(*ci);
for (std::string const& c : configs) {
this->GlobalGenerator->CreateEvaluationSourceFiles(c);
}
// Generate the rule files for each target.
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
if ((*t)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (cmGeneratorTarget* target : targets) {
if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
(*t)->TraceDependencies();
target->TraceDependencies();
}
}
@@ -264,26 +260,24 @@ void cmLocalGenerator::GenerateTestFiles()
if (testIncludeFiles) {
std::vector<std::string> includesList;
cmSystemTools::ExpandListArgument(testIncludeFiles, includesList);
for (std::vector<std::string>::const_iterator i = includesList.begin();
i != includesList.end(); ++i) {
fout << "include(\"" << *i << "\")" << std::endl;
for (std::string const& i : includesList) {
fout << "include(\"" << i << "\")" << std::endl;
}
}
// Ask each test generator to write its code.
std::vector<cmTestGenerator*> const& testers =
this->Makefile->GetTestGenerators();
for (std::vector<cmTestGenerator*>::const_iterator gi = testers.begin();
gi != testers.end(); ++gi) {
(*gi)->Compute(this);
(*gi)->Generate(fout, config, configurationTypes);
for (cmTestGenerator* tester : testers) {
tester->Compute(this);
tester->Generate(fout, config, configurationTypes);
}
typedef std::vector<cmStateSnapshot> vec_t;
vec_t const& children = this->Makefile->GetStateSnapshot().GetChildren();
std::string parentBinDir = this->GetCurrentBinaryDirectory();
for (vec_t::const_iterator i = children.begin(); i != children.end(); ++i) {
for (cmStateSnapshot const& i : children) {
// TODO: Use add_subdirectory instead?
std::string outP = i->GetDirectory().GetCurrentBinary();
std::string outP = i.GetDirectory().GetCurrentBinary();
outP = this->ConvertToRelativePath(parentBinDir, outP);
outP = cmOutputConverter::EscapeForCMake(outP);
fout << "subdirs(" << outP << ")" << std::endl;
@@ -313,10 +307,8 @@ void cmLocalGenerator::CreateEvaluationFileOutputs(std::string const& config)
{
std::vector<cmGeneratorExpressionEvaluationFile*> ef =
this->Makefile->GetEvaluationFiles();
for (std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator li =
ef.begin();
li != ef.end(); ++li) {
(*li)->CreateOutputFile(this, config);
for (cmGeneratorExpressionEvaluationFile* geef : ef) {
geef->CreateOutputFile(this, config);
}
}
@@ -325,14 +317,12 @@ void cmLocalGenerator::ProcessEvaluationFiles(
{
std::vector<cmGeneratorExpressionEvaluationFile*> ef =
this->Makefile->GetEvaluationFiles();
for (std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator li =
ef.begin();
li != ef.end(); ++li) {
(*li)->Generate(this);
for (cmGeneratorExpressionEvaluationFile* geef : ef) {
geef->Generate(this);
if (cmSystemTools::GetFatalErrorOccured()) {
return;
}
std::vector<std::string> files = (*li)->GetFiles();
std::vector<std::string> files = geef->GetFiles();
std::sort(files.begin(), files.end());
std::vector<std::string> intersection;
@@ -403,10 +393,9 @@ void cmLocalGenerator::GenerateInstallRules()
const char* default_order[] = { "RELEASE", "MINSIZEREL", "RELWITHDEBINFO",
"DEBUG", nullptr };
for (const char** c = default_order; *c && default_config.empty(); ++c) {
for (std::vector<std::string>::iterator i = configurationTypes.begin();
i != configurationTypes.end(); ++i) {
if (cmSystemTools::UpperCase(*i) == *c) {
default_config = *i;
for (std::string const& configurationType : configurationTypes) {
if (cmSystemTools::UpperCase(configurationType) == *c) {
default_config = configurationType;
}
}
}
@@ -498,10 +487,8 @@ void cmLocalGenerator::GenerateInstallRules()
// Ask each install generator to write its code.
std::vector<cmInstallGenerator*> const& installers =
this->Makefile->GetInstallGenerators();
for (std::vector<cmInstallGenerator*>::const_iterator gi =
installers.begin();
gi != installers.end(); ++gi) {
(*gi)->Generate(fout, config, configurationTypes);
for (cmInstallGenerator* installer : installers) {
installer->Generate(fout, config, configurationTypes);
}
// Write rules from old-style specification stored in targets.
@@ -513,10 +500,9 @@ void cmLocalGenerator::GenerateInstallRules()
if (!children.empty()) {
fout << "if(NOT CMAKE_INSTALL_LOCAL_ONLY)\n";
fout << " # Include the install script for each subdirectory.\n";
for (std::vector<cmStateSnapshot>::const_iterator ci = children.begin();
ci != children.end(); ++ci) {
if (!ci->GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
std::string odir = ci->GetDirectory().GetCurrentBinary();
for (cmStateSnapshot const& c : children) {
if (!c.GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
std::string odir = c.GetDirectory().GetCurrentBinary();
cmSystemTools::ConvertToUnixSlashes(odir);
fout << " include(\"" << odir << "/cmake_install.cmake\")"
<< std::endl;
@@ -602,16 +588,12 @@ void cmLocalGenerator::ComputeTargetManifest()
// Add our targets to the manifest for each configuration.
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
cmGeneratorTarget* target = *t;
for (cmGeneratorTarget* target : targets) {
if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
for (std::vector<std::string>::iterator ci = configNames.begin();
ci != configNames.end(); ++ci) {
const char* config = ci->c_str();
target->ComputeTargetManifest(config);
for (std::string const& c : configNames) {
target->ComputeTargetManifest(c);
}
}
}
@@ -627,12 +609,9 @@ bool cmLocalGenerator::ComputeTargetCompileFeatures()
// Process compile features of all targets.
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
cmGeneratorTarget* target = *t;
for (std::vector<std::string>::iterator ci = configNames.begin();
ci != configNames.end(); ++ci) {
if (!target->ComputeCompileFeatures(*ci)) {
for (cmGeneratorTarget* target : targets) {
for (std::string const& c : configNames) {
if (!target->ComputeCompileFeatures(c)) {
return false;
}
}
@@ -729,16 +708,15 @@ std::string cmLocalGenerator::GetIncludeFlags(
#ifdef __APPLE__
emitted.insert("/System/Library/Frameworks");
#endif
std::vector<std::string>::const_iterator i;
for (i = includes.begin(); i != includes.end(); ++i) {
for (std::string const& i : includes) {
if (fwSearchFlag && *fwSearchFlag && this->Makefile->IsOn("APPLE") &&
cmSystemTools::IsPathToFramework(i->c_str())) {
std::string frameworkDir = *i;
cmSystemTools::IsPathToFramework(i.c_str())) {
std::string frameworkDir = i;
frameworkDir += "/../";
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
if (emitted.insert(frameworkDir).second) {
if (sysFwSearchFlag && target &&
target->IsSystemIncludeDirectory(*i, config)) {
target->IsSystemIncludeDirectory(i, config)) {
includeFlags << sysFwSearchFlag;
} else {
includeFlags << fwSearchFlag;
@@ -751,7 +729,7 @@ std::string cmLocalGenerator::GetIncludeFlags(
if (!flagUsed || repeatFlag) {
if (sysIncludeFlag && target &&
target->IsSystemIncludeDirectory(*i, config)) {
target->IsSystemIncludeDirectory(i, config)) {
includeFlags << sysIncludeFlag;
} else {
includeFlags << includeFlag;
@@ -759,7 +737,7 @@ std::string cmLocalGenerator::GetIncludeFlags(
flagUsed = true;
}
std::string includePath =
this->ConvertToIncludeReference(*i, shellFormat, forceFullPaths);
this->ConvertToIncludeReference(i, shellFormat, forceFullPaths);
if (quotePaths && !includePath.empty() && includePath[0] != '\"') {
includeFlags << "\"";
}
@@ -803,12 +781,11 @@ void cmLocalGenerator::AddCompileOptions(std::string& flags,
cmSystemTools::ParseWindowsCommandLine(targetFlags, opts);
}
target->GetCompileOptions(opts, config, lang);
for (std::vector<std::string>::const_iterator i = opts.begin();
i != opts.end(); ++i) {
if (r.find(i->c_str())) {
for (std::string const& opt : opts) {
if (r.find(opt.c_str())) {
// (Re-)Escape this flag. COMPILE_FLAGS were already parsed
// as a command line above, and COMPILE_OPTIONS are escaped.
this->AppendFlagEscape(flags, *i);
this->AppendFlagEscape(flags, opt);
}
}
} else {
@@ -819,30 +796,27 @@ void cmLocalGenerator::AddCompileOptions(std::string& flags,
}
std::vector<std::string> opts;
target->GetCompileOptions(opts, config, lang);
for (std::vector<std::string>::const_iterator i = opts.begin();
i != opts.end(); ++i) {
for (std::string const& opt : opts) {
// COMPILE_OPTIONS are escaped.
this->AppendFlagEscape(flags, *i);
this->AppendFlagEscape(flags, opt);
}
}
for (std::map<std::string, std::string>::const_iterator it =
target->GetMaxLanguageStandards().begin();
it != target->GetMaxLanguageStandards().end(); ++it) {
const char* standard = target->GetProperty(it->first + "_STANDARD");
for (auto const& it : target->GetMaxLanguageStandards()) {
const char* standard = target->GetProperty(it.first + "_STANDARD");
if (!standard) {
continue;
}
if (this->Makefile->IsLaterStandard(it->first, standard, it->second)) {
if (this->Makefile->IsLaterStandard(it.first, standard, it.second)) {
std::ostringstream e;
e << "The COMPILE_FEATURES property of target \"" << target->GetName()
<< "\" was evaluated when computing the link "
"implementation, and the \""
<< it->first << "_STANDARD\" was \"" << it->second
<< it.first << "_STANDARD\" was \"" << it.second
<< "\" for that computation. Computing the "
"COMPILE_FEATURES based on the link implementation resulted in a "
"higher \""
<< it->first << "_STANDARD\" \"" << standard
<< it.first << "_STANDARD\" \"" << standard
<< "\". "
"This is not permitted. The COMPILE_FEATURES may not both depend "
"on "
@@ -917,13 +891,12 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
if (const char* value = this->Makefile->GetDefinition(impDirVar)) {
std::vector<std::string> impDirVec;
cmSystemTools::ExpandListArgument(value, impDirVec);
for (std::vector<std::string>::const_iterator i = impDirVec.begin();
i != impDirVec.end(); ++i) {
std::string d = rootPath + *i;
for (std::string const& i : impDirVec) {
std::string d = rootPath + i;
cmSystemTools::ConvertToUnixSlashes(d);
emitted.insert(d);
if (!stripImplicitInclDirs) {
implicitDirs.push_back(*i);
implicitDirs.push_back(i);
}
}
}
@@ -938,26 +911,24 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
if (this->Makefile->IsOn("CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE")) {
const char* topSourceDir = this->GetState()->GetSourceDirectory();
const char* topBinaryDir = this->GetState()->GetBinaryDirectory();
for (std::vector<std::string>::const_iterator i = includes.begin();
i != includes.end(); ++i) {
for (std::string const& i : includes) {
// Emit this directory only if it is a subdirectory of the
// top-level source or binary tree.
if (cmSystemTools::ComparePath(*i, topSourceDir) ||
cmSystemTools::ComparePath(*i, topBinaryDir) ||
cmSystemTools::IsSubDirectory(*i, topSourceDir) ||
cmSystemTools::IsSubDirectory(*i, topBinaryDir)) {
if (emitted.insert(*i).second) {
dirs.push_back(*i);
if (cmSystemTools::ComparePath(i, topSourceDir) ||
cmSystemTools::ComparePath(i, topBinaryDir) ||
cmSystemTools::IsSubDirectory(i, topSourceDir) ||
cmSystemTools::IsSubDirectory(i, topBinaryDir)) {
if (emitted.insert(i).second) {
dirs.push_back(i);
}
}
}
}
// Construct the final ordered include directory list.
for (std::vector<std::string>::const_iterator i = includes.begin();
i != includes.end(); ++i) {
if (emitted.insert(*i).second) {
dirs.push_back(*i);
for (std::string const& i : includes) {
if (emitted.insert(i).second) {
dirs.push_back(i);
}
}
@@ -975,10 +946,9 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
dirs.push_back(*i);
}
for (std::vector<std::string>::const_iterator i = implicitDirs.begin();
i != implicitDirs.end(); ++i) {
if (std::find(includes.begin(), includes.end(), *i) != includes.end()) {
dirs.push_back(*i);
for (std::string const& i : implicitDirs) {
if (std::find(includes.begin(), includes.end(), i) != includes.end()) {
dirs.push_back(i);
}
}
}
@@ -1036,9 +1006,7 @@ void cmLocalGenerator::GetTargetFlags(
target->GetSourceFiles(sources, buildType);
std::string defFlag =
this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
for (std::vector<cmSourceFile*>::const_iterator i = sources.begin();
i != sources.end(); ++i) {
cmSourceFile* sf = *i;
for (cmSourceFile* sf : sources) {
if (sf->GetExtension() == "def") {
linkFlags += defFlag;
linkFlags += this->ConvertToOutputFormat(
@@ -1189,10 +1157,9 @@ static std::string GetFrameworkFlags(const std::string& lang,
lg->GetIncludeDirectories(includes, target, "C", config);
// check all include directories for frameworks as this
// will already have added a -F for the framework
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
if (lg->GetGlobalGenerator()->NameResolvesToFramework(*i)) {
std::string frameworkDir = *i;
for (std::string const& include : includes) {
if (lg->GetGlobalGenerator()->NameResolvesToFramework(include)) {
std::string frameworkDir = include;
frameworkDir += "/../";
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
emitted.insert(frameworkDir);
@@ -1202,11 +1169,11 @@ static std::string GetFrameworkFlags(const std::string& lang,
std::string flags;
if (cmComputeLinkInformation* cli = target->GetLinkInformation(config)) {
std::vector<std::string> const& frameworks = cli->GetFrameworkPaths();
for (std::vector<std::string>::const_iterator i = frameworks.begin();
i != frameworks.end(); ++i) {
if (emitted.insert(*i).second) {
for (std::string const& framework : frameworks) {
if (emitted.insert(framework).second) {
flags += fwSearchFlag;
flags += lg->ConvertToOutputFormat(*i, cmOutputConverter::SHELL);
flags +=
lg->ConvertToOutputFormat(framework, cmOutputConverter::SHELL);
flags += " ";
}
}
@@ -1359,10 +1326,9 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
this->Makefile->GetDefinition(deploymentTargetFlagVar);
if (!archs.empty() && !lang.empty() &&
(lang[0] == 'C' || lang[0] == 'F')) {
for (std::vector<std::string>::iterator i = archs.begin();
i != archs.end(); ++i) {
for (std::string const& arch : archs) {
flags += " -arch ";
flags += *i;
flags += arch;
}
}
@@ -1566,8 +1532,8 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
target->Target->GetMakefile()->GetDefinition(option_flag)) {
std::vector<std::string> optVec;
cmSystemTools::ExpandListArgument(opt, optVec);
for (size_t i = 0; i < optVec.size(); ++i) {
this->AppendFlagEscape(flags, optVec[i]);
for (std::string const& i : optVec) {
this->AppendFlagEscape(flags, i);
}
}
}
@@ -1594,8 +1560,8 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
} else {
std::vector<std::string> optVec;
cmSystemTools::ExpandListArgument(opt, optVec);
for (size_t i = 0; i < optVec.size(); ++i) {
this->AppendFlagEscape(flags, optVec[i]);
for (std::string const& i : optVec) {
this->AppendFlagEscape(flags, i);
}
}
return;
@@ -1654,8 +1620,8 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
target->Target->GetMakefile()->GetRequiredDefinition(option_flag);
std::vector<std::string> optVec;
cmSystemTools::ExpandListArgument(opt, optVec);
for (size_t i = 0; i < optVec.size(); ++i) {
this->AppendFlagEscape(flags, optVec[i]);
for (std::string const& i : optVec) {
this->AppendFlagEscape(flags, i);
}
return;
}
@@ -1671,8 +1637,8 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
target->Target->GetMakefile()->GetDefinition(option_flag)) {
std::vector<std::string> optVec;
cmSystemTools::ExpandListArgument(opt, optVec);
for (size_t i = 0; i < optVec.size(); ++i) {
this->AppendFlagEscape(flags, optVec[i]);
for (std::string const& i : optVec) {
this->AppendFlagEscape(flags, i);
}
return;
}
@@ -1871,9 +1837,8 @@ void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags,
if (picFlags) {
std::vector<std::string> options;
cmSystemTools::ExpandListArgument(picFlags, options);
for (std::vector<std::string>::const_iterator oi = options.begin();
oi != options.end(); ++oi) {
this->AppendFlagEscape(flags, *oi);
for (std::string const& o : options) {
this->AppendFlagEscape(flags, o);
}
}
}
@@ -1943,9 +1908,8 @@ void cmLocalGenerator::AppendIPOLinkerFlags(std::string& flags,
std::vector<std::string> flagsList;
cmSystemTools::ExpandListArgument(rawFlagsList, flagsList);
for (std::vector<std::string>::const_iterator oi = flagsList.begin();
oi != flagsList.end(); ++oi) {
this->AppendFlagEscape(flags, *oi);
for (std::string const& o : flagsList) {
this->AppendFlagEscape(flags, o);
}
}
@@ -1967,13 +1931,12 @@ void cmLocalGenerator::AppendDefines(
std::set<std::string>& defines,
const std::vector<std::string>& defines_vec) const
{
for (std::vector<std::string>::const_iterator di = defines_vec.begin();
di != defines_vec.end(); ++di) {
for (std::string const& d : defines_vec) {
// Skip unsupported definitions.
if (!this->CheckDefinition(*di)) {
if (!this->CheckDefinition(d)) {
continue;
}
defines.insert(*di);
defines.insert(d);
}
}
@@ -2043,9 +2006,8 @@ void cmLocalGenerator::AppendFeatureOptions(std::string& flags,
if (const char* optionList = this->Makefile->GetDefinition(optVar)) {
std::vector<std::string> options;
cmSystemTools::ExpandListArgument(optionList, options);
for (std::vector<std::string>::const_iterator oi = options.begin();
oi != options.end(); ++oi) {
this->AppendFlagEscape(flags, *oi);
for (std::string const& o : options) {
this->AppendFlagEscape(flags, o);
}
}
}
@@ -2089,10 +2051,9 @@ std::string cmLocalGenerator::ConstructComment(
comment = "Generating ";
const char* sep = "";
std::string currentBinaryDir = this->GetCurrentBinaryDirectory();
for (std::vector<std::string>::const_iterator o = ccg.GetOutputs().begin();
o != ccg.GetOutputs().end(); ++o) {
for (std::string const& o : ccg.GetOutputs()) {
comment += sep;
comment += this->ConvertToRelativePath(currentBinaryDir, *o);
comment += this->ConvertToRelativePath(currentBinaryDir, o);
sep = ", ";
}
return comment;
@@ -2123,36 +2084,35 @@ void cmLocalGenerator::GenerateTargetInstallRules(
// Convert the old-style install specification from each target to
// an install generator and run it.
const std::vector<cmGeneratorTarget*>& tgts = this->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator l = tgts.begin();
l != tgts.end(); ++l) {
if ((*l)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (cmGeneratorTarget* l : tgts) {
if (l->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
// Include the user-specified pre-install script for this target.
if (const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT")) {
if (const char* preinstall = l->GetProperty("PRE_INSTALL_SCRIPT")) {
cmInstallScriptGenerator g(preinstall, false, nullptr, false);
g.Generate(os, config, configurationTypes);
}
// Install this target if a destination is given.
if ((*l)->Target->GetInstallPath() != "") {
if (l->Target->GetInstallPath() != "") {
// Compute the full install destination. Note that converting
// to unix slashes also removes any trailing slash.
// We also skip over the leading slash given by the user.
std::string destination = (*l)->Target->GetInstallPath().substr(1);
std::string destination = l->Target->GetInstallPath().substr(1);
cmSystemTools::ConvertToUnixSlashes(destination);
if (destination.empty()) {
destination = ".";
}
// Generate the proper install generator for this target type.
switch ((*l)->GetType()) {
switch (l->GetType()) {
case cmStateEnums::EXECUTABLE:
case cmStateEnums::STATIC_LIBRARY:
case cmStateEnums::MODULE_LIBRARY: {
// Use a target install generator.
cmInstallTargetGeneratorLocal g(this, (*l)->GetName(),
cmInstallTargetGeneratorLocal g(this, l->GetName(),
destination.c_str(), false);
g.Generate(os, config, configurationTypes);
} break;
@@ -2161,18 +2121,18 @@ void cmLocalGenerator::GenerateTargetInstallRules(
// Special code to handle DLL. Install the import library
// to the normal destination and the DLL to the runtime
// destination.
cmInstallTargetGeneratorLocal g1(this, (*l)->GetName(),
cmInstallTargetGeneratorLocal g1(this, l->GetName(),
destination.c_str(), true);
g1.Generate(os, config, configurationTypes);
// We also skip over the leading slash given by the user.
destination = (*l)->Target->GetRuntimeInstallPath().substr(1);
destination = l->Target->GetRuntimeInstallPath().substr(1);
cmSystemTools::ConvertToUnixSlashes(destination);
cmInstallTargetGeneratorLocal g2(this, (*l)->GetName(),
cmInstallTargetGeneratorLocal g2(this, l->GetName(),
destination.c_str(), false);
g2.Generate(os, config, configurationTypes);
#else
// Use a target install generator.
cmInstallTargetGeneratorLocal g(this, (*l)->GetName(),
cmInstallTargetGeneratorLocal g(this, l->GetName(),
destination.c_str(), false);
g.Generate(os, config, configurationTypes);
#endif
@@ -2183,7 +2143,7 @@ void cmLocalGenerator::GenerateTargetInstallRules(
}
// Include the user-specified post-install script for this target.
if (const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT")) {
if (const char* postinstall = l->GetProperty("POST_INSTALL_SCRIPT")) {
cmInstallScriptGenerator g(postinstall, false, nullptr, false);
g.Generate(os, config, configurationTypes);
}
Source/cmLocalNinjaGenerator.cxx
+17 -23
View File
@@ -80,18 +80,18 @@ void cmLocalNinjaGenerator::Generate()
}
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
if ((*t)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (cmGeneratorTarget* target : targets) {
if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(*t);
cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(target);
if (tg) {
tg->Generate();
// Add the target to "all" if required.
if (!this->GetGlobalNinjaGenerator()->IsExcluded(
this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0], *t)) {
this->GetGlobalNinjaGenerator()->AddDependencyToAll(*t);
this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0],
target)) {
this->GetGlobalNinjaGenerator()->AddDependencyToAll(target);
}
delete tg;
}
@@ -212,8 +212,7 @@ void cmLocalNinjaGenerator::WritePools(std::ostream& os)
os, "Pools defined by global property JOB_POOLS");
std::vector<std::string> pools;
cmSystemTools::ExpandListArgument(jobpools, pools);
for (size_t i = 0; i < pools.size(); ++i) {
std::string const& pool = pools[i];
for (std::string const& pool : pools) {
const std::string::size_type eq = pool.find('=');
unsigned int jobs;
if (eq != std::string::npos &&
@@ -250,12 +249,10 @@ void cmLocalNinjaGenerator::ComputeObjectFilenames(
{
// Determine if these object files should use a custom extension
char const* custom_ext = gt->GetCustomObjectExtension();
for (std::map<cmSourceFile const*, std::string>::iterator si =
mapping.begin();
si != mapping.end(); ++si) {
cmSourceFile const* sf = si->first;
for (auto& si : mapping) {
cmSourceFile const* sf = si.first;
bool keptSourceExtension;
si->second = this->GetObjectFileNameWithoutTarget(
si.second = this->GetObjectFileNameWithoutTarget(
*sf, gt->ObjectDirectory, &keptSourceExtension, custom_ext);
}
}
@@ -291,10 +288,9 @@ void cmLocalNinjaGenerator::AppendCustomCommandDeps(
cmCustomCommandGenerator const& ccg, cmNinjaDeps& ninjaDeps)
{
const std::vector<std::string>& deps = ccg.GetDepends();
for (std::vector<std::string>::const_iterator i = deps.begin();
i != deps.end(); ++i) {
for (std::string const& i : deps) {
std::string dep;
if (this->GetRealDependency(*i, this->GetConfigName(), dep)) {
if (this->GetRealDependency(i, this->GetConfigName(), dep)) {
ninjaDeps.push_back(
this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(dep));
}
@@ -408,9 +404,8 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
this->GetGlobalNinjaGenerator()->MapToNinjaPath());
this->AppendCustomCommandDeps(ccg, ninjaDeps);
for (cmNinjaDeps::iterator i = ninjaOutputs.begin(); i != ninjaOutputs.end();
++i) {
this->GetGlobalNinjaGenerator()->SeenCustomCommandOutput(*i);
for (std::string const& ninjaOutput : ninjaOutputs) {
this->GetGlobalNinjaGenerator()->SeenCustomCommandOutput(ninjaOutput);
}
std::vector<std::string> cmdLines;
@@ -445,10 +440,9 @@ void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc,
void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements()
{
for (std::vector<cmCustomCommand const*>::iterator vi =
this->CustomCommands.begin();
vi != this->CustomCommands.end(); ++vi) {
CustomCommandTargetMap::iterator i = this->CustomCommandTargets.find(*vi);
for (cmCustomCommand const* customCommand : this->CustomCommands) {
CustomCommandTargetMap::iterator i =
this->CustomCommandTargets.find(customCommand);
assert(i != this->CustomCommandTargets.end());
// A custom command may appear on multiple targets. However, some build
Source/cmLocalUnixMakefileGenerator3.cxx
+97 -130
View File
@@ -11,7 +11,6 @@
#include <utility>
#include "cmAlgorithms.h"
#include "cmCustomCommand.h"
#include "cmCustomCommandGenerator.h"
#include "cmFileTimeComparison.h"
#include "cmGeneratedFileStream.h"
@@ -119,13 +118,12 @@ void cmLocalUnixMakefileGenerator3::Generate()
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
if ((*t)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
for (cmGeneratorTarget* target : targets) {
if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
CM_AUTO_PTR<cmMakefileTargetGenerator> tg(
cmMakefileTargetGenerator::New(*t));
cmMakefileTargetGenerator::New(target));
if (tg.get()) {
tg->WriteRuleFiles();
gg->RecordTargetProgress(tg.get());
@@ -159,12 +157,10 @@ void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames(
{
// Determine if these object files should use a custom extension
char const* custom_ext = gt->GetCustomObjectExtension();
for (std::map<cmSourceFile const*, std::string>::iterator si =
mapping.begin();
si != mapping.end(); ++si) {
cmSourceFile const* sf = si->first;
for (auto& si : mapping) {
cmSourceFile const* sf = si.first;
bool keptSourceExtension;
si->second = this->GetObjectFileNameWithoutTarget(
si.second = this->GetObjectFileNameWithoutTarget(
*sf, gt->ObjectDirectory, &keptSourceExtension, custom_ext);
}
}
@@ -173,9 +169,7 @@ void cmLocalUnixMakefileGenerator3::GetLocalObjectFiles(
std::map<std::string, LocalObjectInfo>& localObjectFiles)
{
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti) {
cmGeneratorTarget* gt = *ti;
for (cmGeneratorTarget* gt : targets) {
if (gt->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
continue;
}
@@ -189,9 +183,7 @@ void cmLocalUnixMakefileGenerator3::GetLocalObjectFiles(
dir += this->GetTargetDirectory(gt);
dir += "/";
// Compute the name of each object file.
for (std::vector<cmSourceFile const*>::iterator si = objectSources.begin();
si != objectSources.end(); ++si) {
cmSourceFile const* sf = *si;
for (cmSourceFile const* sf : objectSources) {
bool hasSourceExtension = true;
std::string objectName =
this->GetObjectFileNameWithoutTarget(*sf, dir, &hasSourceExtension);
@@ -210,18 +202,16 @@ void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets(
{
std::map<std::string, LocalObjectInfo> localObjectFiles;
this->GetLocalObjectFiles(localObjectFiles);
for (std::map<std::string, LocalObjectInfo>::iterator lo =
localObjectFiles.begin();
lo != localObjectFiles.end(); ++lo) {
targets.push_back(lo->first);
for (auto const& localObjectFile : localObjectFiles) {
targets.push_back(localObjectFile.first);
std::string::size_type dot_pos = lo->first.rfind(".");
std::string base = lo->first.substr(0, dot_pos);
if (lo->second.HasPreprocessRule) {
std::string::size_type dot_pos = localObjectFile.first.rfind(".");
std::string base = localObjectFile.first.substr(0, dot_pos);
if (localObjectFile.second.HasPreprocessRule) {
targets.push_back(base + ".i");
}
if (lo->second.HasAssembleRule) {
if (localObjectFile.second.HasAssembleRule) {
targets.push_back(base + ".s");
}
}
@@ -270,23 +260,20 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
// now write out the object rules
// for each object file name
for (std::map<std::string, LocalObjectInfo>::iterator lo =
localObjectFiles.begin();
lo != localObjectFiles.end(); ++lo) {
for (auto& localObjectFile : localObjectFiles) {
// Add a convenience rule for building the object file.
this->WriteObjectConvenienceRule(ruleFileStream,
"target to build an object file",
lo->first.c_str(), lo->second);
this->WriteObjectConvenienceRule(
ruleFileStream, "target to build an object file",
localObjectFile.first.c_str(), localObjectFile.second);
// Check whether preprocessing and assembly rules make sense.
// They make sense only for C and C++ sources.
bool lang_has_preprocessor = false;
bool lang_has_assembly = false;
for (std::vector<LocalObjectEntry>::const_iterator ei = lo->second.begin();
ei != lo->second.end(); ++ei) {
if (ei->Language == "C" || ei->Language == "CXX" ||
ei->Language == "CUDA" || ei->Language == "Fortran") {
for (LocalObjectEntry const& entry : localObjectFile.second) {
if (entry.Language == "C" || entry.Language == "CXX" ||
entry.Language == "CUDA" || entry.Language == "Fortran") {
// Right now, C, C++, Fortran and CUDA have both a preprocessor and the
// ability to generate assembly code
lang_has_preprocessor = true;
@@ -297,21 +284,21 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
// Add convenience rules for preprocessed and assembly files.
if (lang_has_preprocessor && do_preprocess_rules) {
std::string::size_type dot_pos = lo->first.rfind(".");
std::string base = lo->first.substr(0, dot_pos);
this->WriteObjectConvenienceRule(ruleFileStream,
"target to preprocess a source file",
(base + ".i").c_str(), lo->second);
lo->second.HasPreprocessRule = true;
std::string::size_type dot_pos = localObjectFile.first.rfind(".");
std::string base = localObjectFile.first.substr(0, dot_pos);
this->WriteObjectConvenienceRule(
ruleFileStream, "target to preprocess a source file",
(base + ".i").c_str(), localObjectFile.second);
localObjectFile.second.HasPreprocessRule = true;
}
if (lang_has_assembly && do_assembly_rules) {
std::string::size_type dot_pos = lo->first.rfind(".");
std::string base = lo->first.substr(0, dot_pos);
std::string::size_type dot_pos = localObjectFile.first.rfind(".");
std::string base = localObjectFile.first.substr(0, dot_pos);
this->WriteObjectConvenienceRule(
ruleFileStream, "target to generate assembly for a file",
(base + ".s").c_str(), lo->second);
lo->second.HasAssembleRule = true;
(base + ".s").c_str(), localObjectFile.second);
localObjectFile.second.HasAssembleRule = true;
}
}
@@ -355,9 +342,8 @@ void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule(
// Recursively make the rule for each target using the object file.
std::vector<std::string> commands;
for (std::vector<LocalObjectEntry>::const_iterator t = info.begin();
t != info.end(); ++t) {
std::string tgtMakefileName = this->GetRelativeTargetDirectory(t->Target);
for (LocalObjectEntry const& t : info) {
std::string tgtMakefileName = this->GetRelativeTargetDirectory(t.Target);
std::string targetName = tgtMakefileName;
tgtMakefileName += "/build.make";
targetName += "/";
@@ -384,18 +370,17 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
// on the target
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
std::string localName;
for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t) {
if (((*t)->GetType() == cmStateEnums::EXECUTABLE) ||
((*t)->GetType() == cmStateEnums::STATIC_LIBRARY) ||
((*t)->GetType() == cmStateEnums::SHARED_LIBRARY) ||
((*t)->GetType() == cmStateEnums::MODULE_LIBRARY) ||
((*t)->GetType() == cmStateEnums::OBJECT_LIBRARY) ||
((*t)->GetType() == cmStateEnums::UTILITY)) {
emitted.insert((*t)->GetName());
for (cmGeneratorTarget* target : targets) {
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) ||
(target->GetType() == cmStateEnums::UTILITY)) {
emitted.insert(target->GetName());
// for subdirs add a rule to build this specific target by name.
localName = this->GetRelativeTargetDirectory(*t);
localName = this->GetRelativeTargetDirectory(target);
localName += "/rule";
commands.clear();
depends.clear();
@@ -411,20 +396,20 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
localName, depends, commands, true);
// Add a target with the canonical name (no prefix, suffix or path).
if (localName != (*t)->GetName()) {
if (localName != target->GetName()) {
commands.clear();
depends.push_back(localName);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
(*t)->GetName(), depends, commands, true);
target->GetName(), depends, commands, true);
}
// Add a fast rule to build the target
std::string makefileName = this->GetRelativeTargetDirectory(*t);
std::string makefileName = this->GetRelativeTargetDirectory(target);
makefileName += "/build.make";
// make sure the makefile name is suitable for a makefile
std::string makeTargetName = this->GetRelativeTargetDirectory(*t);
std::string makeTargetName = this->GetRelativeTargetDirectory(target);
makeTargetName += "/build";
localName = (*t)->GetName();
localName = target->GetName();
localName += "/fast";
depends.clear();
commands.clear();
@@ -437,10 +422,10 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
// Add a local name for the rule to relink the target before
// installation.
if ((*t)->NeedRelinkBeforeInstall(this->ConfigName)) {
makeTargetName = this->GetRelativeTargetDirectory(*t);
if (target->NeedRelinkBeforeInstall(this->ConfigName)) {
makeTargetName = this->GetRelativeTargetDirectory(target);
makeTargetName += "/preinstall";
localName = (*t)->GetName();
localName = target->GetName();
localName += "/preinstall";
depends.clear();
commands.clear();
@@ -581,9 +566,8 @@ void cmLocalUnixMakefileGenerator3::WriteMakeRule(
// Split dependencies into multiple rule lines. This allows for
// very long dependency lists even on older make implementations.
std::string binDir = this->GetBinaryDirectory();
for (std::vector<std::string>::const_iterator dep = depends.begin();
dep != depends.end(); ++dep) {
replace = *dep;
for (std::string const& depend : depends) {
replace = depend;
replace = cmSystemTools::ConvertToOutputPath(
this->MaybeConvertToRelativePath(binDir, replace).c_str());
os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n";
@@ -892,9 +876,8 @@ void cmLocalUnixMakefileGenerator3::AppendRuleDepends(
void cmLocalUnixMakefileGenerator3::AppendCustomDepends(
std::vector<std::string>& depends, const std::vector<cmCustomCommand>& ccs)
{
for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i) {
cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
for (cmCustomCommand const& cc : ccs) {
cmCustomCommandGenerator ccg(cc, this->ConfigName, this);
this->AppendCustomDepend(depends, ccg);
}
}
@@ -902,11 +885,10 @@ void cmLocalUnixMakefileGenerator3::AppendCustomDepends(
void cmLocalUnixMakefileGenerator3::AppendCustomDepend(
std::vector<std::string>& depends, cmCustomCommandGenerator const& ccg)
{
for (std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
d != ccg.GetDepends().end(); ++d) {
for (std::string const& d : ccg.GetDepends()) {
// Lookup the real name of the dependency in case it is a CMake target.
std::string dep;
if (this->GetRealDependency(*d, this->ConfigName, dep)) {
if (this->GetRealDependency(d, this->ConfigName, dep)) {
depends.push_back(dep);
}
}
@@ -916,9 +898,8 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommands(
std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs,
cmGeneratorTarget* target, std::string const& relative)
{
for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i) {
cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
for (cmCustomCommand const& cc : ccs) {
cmCustomCommandGenerator ccg(cc, this->ConfigName, this);
this->AppendCustomCommand(commands, ccg, target, relative, true);
}
}
@@ -1089,9 +1070,8 @@ void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
}
if (!files.empty()) {
fout << "file(REMOVE_RECURSE\n";
for (std::vector<std::string>::const_iterator f = files.begin();
f != files.end(); ++f) {
std::string fc = this->MaybeConvertToRelativePath(currentBinDir, *f);
for (std::string const& file : files) {
std::string fc = this->MaybeConvertToRelativePath(currentBinDir, file);
fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n";
}
fout << ")\n";
@@ -1454,11 +1434,8 @@ bool cmLocalUnixMakefileGenerator3::ScanDependencies(
const char* langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
std::vector<std::string> langs;
cmSystemTools::ExpandListArgument(langStr, langs);
for (std::vector<std::string>::iterator li = langs.begin();
li != langs.end(); ++li) {
for (std::string const& lang : langs) {
// construct the checker
std::string lang = *li;
// Create the scanner for this language
cmDepends* scanner = nullptr;
if (lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM" ||
@@ -1563,25 +1540,22 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
ruleFileStream << "# Targets provided globally by CMake.\n"
<< "\n";
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
std::vector<cmGeneratorTarget*>::const_iterator glIt;
for (glIt = targets.begin(); glIt != targets.end(); ++glIt) {
if ((*glIt)->GetType() == cmStateEnums::GLOBAL_TARGET) {
for (cmGeneratorTarget* gt : targets) {
if (gt->GetType() == cmStateEnums::GLOBAL_TARGET) {
std::string targetString =
"Special rule for the target " + (*glIt)->GetName();
"Special rule for the target " + gt->GetName();
std::vector<std::string> commands;
std::vector<std::string> depends;
const char* text = (*glIt)->GetProperty("EchoString");
const char* text = gt->GetProperty("EchoString");
if (!text) {
text = "Running external command ...";
}
depends.insert(depends.end(), (*glIt)->GetUtilities().begin(),
(*glIt)->GetUtilities().end());
depends.insert(depends.end(), gt->GetUtilities().begin(),
gt->GetUtilities().end());
this->AppendEcho(commands, text,
cmLocalUnixMakefileGenerator3::EchoGlobal);
cmGeneratorTarget* gt = *glIt;
// Global targets store their rules in pre- and post-build commands.
this->AppendCustomDepends(depends, gt->GetPreBuildCommands());
this->AppendCustomDepends(depends, gt->GetPostBuildCommands());
@@ -1728,9 +1702,8 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
// dependencies for that target.
cmDepends clearer;
clearer.SetVerbose(verbose);
for (std::vector<std::string>::iterator l = files.begin(); l != files.end();
++l) {
std::string dir = cmSystemTools::GetFilenamePath(*l);
for (std::string const& file : files) {
std::string dir = cmSystemTools::GetFilenamePath(file);
// Clear the implicit dependency makefile.
std::string dependFile = dir + "/depend.make";
@@ -1802,54 +1775,51 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
cmakefileStream
<< "# The set of languages for which implicit dependencies are needed:\n";
cmakefileStream << "set(CMAKE_DEPENDS_LANGUAGES\n";
for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin();
l != implicitLangs.end(); ++l) {
cmakefileStream << " \"" << l->first << "\"\n";
for (auto const& implicitLang : implicitLangs) {
cmakefileStream << " \"" << implicitLang.first << "\"\n";
}
cmakefileStream << " )\n";
// now list the files for each language
cmakefileStream
<< "# The set of files for implicit dependencies of each language:\n";
for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin();
l != implicitLangs.end(); ++l) {
cmakefileStream << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n";
ImplicitDependFileMap const& implicitPairs = l->second;
for (auto const& implicitLang : implicitLangs) {
cmakefileStream << "set(CMAKE_DEPENDS_CHECK_" << implicitLang.first
<< "\n";
ImplicitDependFileMap const& implicitPairs = implicitLang.second;
// for each file pair
for (ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
pi != implicitPairs.end(); ++pi) {
for (cmDepends::DependencyVector::const_iterator di = pi->second.begin();
di != pi->second.end(); ++di) {
cmakefileStream << " \"" << *di << "\" ";
cmakefileStream << "\"" << pi->first << "\"\n";
for (auto const& implicitPair : implicitPairs) {
for (auto const& di : implicitPair.second) {
cmakefileStream << " \"" << di << "\" ";
cmakefileStream << "\"" << implicitPair.first << "\"\n";
}
}
cmakefileStream << " )\n";
// Tell the dependency scanner what compiler is used.
std::string cidVar = "CMAKE_";
cidVar += l->first;
cidVar += implicitLang.first;
cidVar += "_COMPILER_ID";
const char* cid = this->Makefile->GetDefinition(cidVar);
if (cid && *cid) {
cmakefileStream << "set(CMAKE_" << l->first << "_COMPILER_ID \"" << cid
<< "\")\n";
cmakefileStream << "set(CMAKE_" << implicitLang.first
<< "_COMPILER_ID \"" << cid << "\")\n";
}
// Build a list of preprocessor definitions for the target.
std::set<std::string> defines;
this->AddCompileDefinitions(defines, target, this->ConfigName, l->first);
this->AddCompileDefinitions(defines, target, this->ConfigName,
implicitLang.first);
if (!defines.empty()) {
/* clang-format off */
cmakefileStream
<< "\n"
<< "# Preprocessor definitions for this target.\n"
<< "set(CMAKE_TARGET_DEFINITIONS_" << l->first << "\n";
<< "set(CMAKE_TARGET_DEFINITIONS_" << implicitLang.first << "\n";
/* clang-format on */
for (std::set<std::string>::const_iterator di = defines.begin();
di != defines.end(); ++di) {
cmakefileStream << " " << cmOutputConverter::EscapeForCMake(*di)
for (std::string const& define : defines) {
cmakefileStream << " " << cmOutputConverter::EscapeForCMake(define)
<< "\n";
}
cmakefileStream << " )\n";
@@ -1858,21 +1828,21 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
// Target-specific include directories:
cmakefileStream << "\n"
<< "# The include file search paths:\n";
cmakefileStream << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
cmakefileStream << "set(CMAKE_" << implicitLang.first
<< "_TARGET_INCLUDE_PATH\n";
std::vector<std::string> includes;
const std::string& config =
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
this->GetIncludeDirectories(includes, target, l->first, config);
this->GetIncludeDirectories(includes, target, implicitLang.first, config);
std::string binaryDir = this->GetState()->GetBinaryDirectory();
if (this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY")) {
const char* sourceDir = this->GetState()->GetSourceDirectory();
cmEraseIf(includes, ::NotInProjectDir(sourceDir, binaryDir));
}
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
for (std::string const& include : includes) {
cmakefileStream << " \""
<< this->MaybeConvertToRelativePath(binaryDir, *i)
<< this->MaybeConvertToRelativePath(binaryDir, include)
<< "\"\n";
}
cmakefileStream << " )\n";
@@ -1891,10 +1861,8 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
}
if (!transformRules.empty()) {
cmakefileStream << "set(CMAKE_INCLUDE_TRANSFORMS\n";
for (std::vector<std::string>::const_iterator tri = transformRules.begin();
tri != transformRules.end(); ++tri) {
cmakefileStream << " " << cmOutputConverter::EscapeForCMake(*tri)
<< "\n";
for (std::string const& tr : transformRules) {
cmakefileStream << " " << cmOutputConverter::EscapeForCMake(tr) << "\n";
}
cmakefileStream << " )\n";
}
@@ -2004,10 +1972,9 @@ std::string cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(
#if defined(_WIN32) && !defined(__CYGWIN__)
if (!cmSystemTools::GetForceUnixPaths()) {
slash = "\\";
for (std::string::iterator i = components[0].begin();
i != components[0].end(); ++i) {
if (*i == '/') {
*i = '\\';
for (char& i : components[0]) {
if (i == '/') {
i = '\\';
}
}
}
Source/cmMacroCommand.cxx
+9 -11
View File
@@ -98,20 +98,18 @@ bool cmMacroHelperCommand::InvokeInitialPass(
// Invoke all the functions that were collected in the block.
cmListFileFunction newLFF;
// for each function
for (unsigned int c = 0; c < this->Functions.size(); ++c) {
for (cmListFileFunction const& func : this->Functions) {
// Replace the formal arguments and then invoke the command.
newLFF.Arguments.clear();
newLFF.Arguments.reserve(this->Functions[c].Arguments.size());
newLFF.Name = this->Functions[c].Name;
newLFF.Line = this->Functions[c].Line;
newLFF.Arguments.reserve(func.Arguments.size());
newLFF.Name = func.Name;
newLFF.Line = func.Line;
// for each argument of the current function
for (std::vector<cmListFileArgument>::iterator k =
this->Functions[c].Arguments.begin();
k != this->Functions[c].Arguments.end(); ++k) {
for (cmListFileArgument const& k : func.Arguments) {
cmListFileArgument arg;
arg.Value = k->Value;
if (k->Delim != cmListFileArgument::Bracket) {
arg.Value = k.Value;
if (k.Delim != cmListFileArgument::Bracket) {
// replace formal arguments
for (unsigned int j = 0; j < variables.size(); ++j) {
cmSystemTools::ReplaceString(arg.Value, variables[j],
@@ -131,8 +129,8 @@ bool cmMacroHelperCommand::InvokeInitialPass(
}
}
}
arg.Delim = k->Delim;
arg.Line = k->Line;
arg.Delim = k.Delim;
arg.Line = k.Line;
newLFF.Arguments.push_back(arg);
}
cmExecutionStatus status;
Source/cmMakefile.cxx
+77 -114
View File
@@ -206,15 +206,13 @@ void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff) const
msg << lff.Name << "(";
bool expand = this->GetCMakeInstance()->GetTraceExpand();
std::string temp;
for (std::vector<cmListFileArgument>::const_iterator i =
lff.Arguments.begin();
i != lff.Arguments.end(); ++i) {
for (cmListFileArgument const& arg : lff.Arguments) {
if (expand) {
temp = i->Value;
temp = arg.Value;
this->ExpandVariablesInString(temp);
msg << temp;
} else {
msg << i->Value;
msg << arg.Value;
}
msg << " ";
}
@@ -640,9 +638,8 @@ void cmMakefile::FinalPass()
// give all the commands a chance to do something
// after the file has been parsed before generation
for (std::vector<cmCommand*>::iterator i = this->FinalPassCommands.begin();
i != this->FinalPassCommands.end(); ++i) {
(*i)->FinalPass();
for (cmCommand* fpCommand : this->FinalPassCommands) {
fpCommand->FinalPass();
}
// go through all configured files and see which ones still exist.
@@ -739,9 +736,8 @@ void cmMakefile::AddCustomCommandToTarget(
}
// Always create the byproduct sources and mark them generated.
for (std::vector<std::string>::const_iterator o = byproducts.begin();
o != byproducts.end(); ++o) {
if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
for (std::string const& o : byproducts) {
if (cmSourceFile* out = this->GetOrCreateSource(o, true)) {
out->SetProperty("GENERATED", "1");
}
}
@@ -783,9 +779,7 @@ cmSourceFile* cmMakefile::AddCustomCommandToOutput(
}
// Validate custom commands. TODO: More strict?
for (cmCustomCommandLines::const_iterator i = commandLines.begin();
i != commandLines.end(); ++i) {
cmCustomCommandLine const& cl = *i;
for (cmCustomCommandLine const& cl : commandLines) {
if (!cl.empty() && !cl[0].empty() && cl[0][0] == '"') {
std::ostringstream e;
e << "COMMAND may not contain literal quotes:\n " << cl[0] << "\n";
@@ -842,15 +836,13 @@ cmSourceFile* cmMakefile::AddCustomCommandToOutput(
}
// Always create the output sources and mark them generated.
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
for (std::string const& o : outputs) {
if (cmSourceFile* out = this->GetOrCreateSource(o, true)) {
out->SetProperty("GENERATED", "1");
}
}
for (std::vector<std::string>::const_iterator o = byproducts.begin();
o != byproducts.end(); ++o) {
if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
for (std::string const& o : byproducts) {
if (cmSourceFile* out = this->GetOrCreateSource(o, true)) {
out->SetProperty("GENERATED", "1");
}
}
@@ -879,9 +871,8 @@ cmSourceFile* cmMakefile::AddCustomCommandToOutput(
void cmMakefile::UpdateOutputToSourceMap(
std::vector<std::string> const& outputs, cmSourceFile* source)
{
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
this->UpdateOutputToSourceMap(*o, source);
for (std::string const& o : outputs) {
this->UpdateOutputToSourceMap(o, source);
}
}
@@ -941,10 +932,9 @@ void cmMakefile::AddCustomCommandOldStyle(
cmsys::RegularExpression sourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|"
"rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|"
"hm|hpp|hxx|in|txx|inl)$");
for (std::vector<std::string>::const_iterator oi = outputs.begin();
oi != outputs.end(); ++oi) {
for (std::string const& oi : outputs) {
// Get the name of this output.
const char* output = oi->c_str();
const char* output = oi.c_str();
cmSourceFile* sf;
// Choose whether to use a main dependency.
@@ -1062,9 +1052,8 @@ cmTarget* cmMakefile::AddUtilityCommand(
}
// Always create the byproduct sources and mark them generated.
for (std::vector<std::string>::const_iterator o = byproducts.begin();
o != byproducts.end(); ++o) {
if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
for (std::string const& byproduct : byproducts) {
if (cmSourceFile* out = this->GetOrCreateSource(byproduct, true)) {
out->SetProperty("GENERATED", "1");
}
}
@@ -1226,10 +1215,9 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent)
parent->GetProperty("COMPILE_DEFINITIONS"));
std::vector<std::string> configs;
this->GetConfigurations(configs);
for (std::vector<std::string>::const_iterator ci = configs.begin();
ci != configs.end(); ++ci) {
for (std::string const& config : configs) {
std::string defPropName = "COMPILE_DEFINITIONS_";
defPropName += cmSystemTools::UpperCase(*ci);
defPropName += cmSystemTools::UpperCase(config);
const char* prop = parent->GetProperty(defPropName);
this->SetProperty(defPropName, prop);
}
@@ -1391,10 +1379,8 @@ void cmMakefile::Configure()
if (this->IsRootMakefile()) {
bool hasVersion = false;
// search for the right policy command
for (std::vector<cmListFileFunction>::iterator i =
listFile.Functions.begin();
i != listFile.Functions.end(); ++i) {
if (cmSystemTools::LowerCase(i->Name) == "cmake_minimum_required") {
for (cmListFileFunction const& func : listFile.Functions) {
if (cmSystemTools::LowerCase(func.Name) == "cmake_minimum_required") {
hasVersion = true;
break;
}
@@ -1420,10 +1406,8 @@ void cmMakefile::Configure()
allowedCommands.insert("option");
allowedCommands.insert("message");
isProblem = false;
for (std::vector<cmListFileFunction>::iterator i =
listFile.Functions.begin();
i != listFile.Functions.end(); ++i) {
std::string name = cmSystemTools::LowerCase(i->Name);
for (cmListFileFunction const& func : listFile.Functions) {
std::string name = cmSystemTools::LowerCase(func.Name);
if (allowedCommands.find(name) == allowedCommands.end()) {
isProblem = true;
break;
@@ -1442,10 +1426,8 @@ void cmMakefile::Configure()
}
bool hasProject = false;
// search for a project command
for (std::vector<cmListFileFunction>::iterator i =
listFile.Functions.begin();
i != listFile.Functions.end(); ++i) {
if (cmSystemTools::LowerCase(i->Name) == "project") {
for (cmListFileFunction const& func : listFile.Functions) {
if (cmSystemTools::LowerCase(func.Name) == "project") {
hasProject = true;
break;
}
@@ -1577,9 +1559,8 @@ std::vector<cmTarget*> cmMakefile::GetImportedTargets() const
{
std::vector<cmTarget*> tgts;
tgts.reserve(this->ImportedTargets.size());
for (TargetMap::const_iterator it = this->ImportedTargets.begin();
it != this->ImportedTargets.end(); ++it) {
tgts.push_back(it->second);
for (auto const& impTarget : this->ImportedTargets) {
tgts.push_back(impTarget.second);
}
return tgts;
}
@@ -1602,9 +1583,8 @@ void cmMakefile::AddIncludeDirectories(const std::vector<std::string>& incs,
}
// Property on each target:
for (cmTargets::iterator l = this->Targets.begin(); l != this->Targets.end();
++l) {
cmTarget& t = l->second;
for (auto& target : this->Targets) {
cmTarget& t = target.second;
t.InsertInclude(entryString, lfbt, before);
}
}
@@ -1617,9 +1597,8 @@ void cmMakefile::AddSystemIncludeDirectories(const std::set<std::string>& incs)
this->SystemIncludeDirectories.insert(incs.begin(), incs.end());
for (cmTargets::iterator l = this->Targets.begin(); l != this->Targets.end();
++l) {
cmTarget& t = l->second;
for (auto& target : this->Targets) {
cmTarget& t = target.second;
t.AddSystemIncludeDirectories(incs);
}
}
@@ -1788,14 +1767,13 @@ void cmMakefile::AddGlobalLinkInformation(cmTarget& target)
std::vector<std::string> linkDirs;
cmSystemTools::ExpandListArgument(linkDirsProp, linkDirs);
for (std::vector<std::string>::iterator j = linkDirs.begin();
j != linkDirs.end(); ++j) {
std::string newdir = *j;
for (std::string const& linkDir : linkDirs) {
std::string newdir = linkDir;
// remove trailing slashes
if (*j->rbegin() == '/') {
newdir = j->substr(0, j->size() - 1);
if (*linkDir.rbegin() == '/') {
newdir = linkDir.substr(0, linkDir.size() - 1);
}
target.AddLinkDirectory(*j);
target.AddLinkDirectory(linkDir);
}
}
@@ -1888,22 +1866,19 @@ cmSourceFile* cmMakefile::LinearGetSourceFileWithOutput(
// look through all the source files that have custom commands
// and see if the custom command has the passed source file as an output
for (std::vector<cmSourceFile*>::const_iterator i =
this->SourceFiles.begin();
i != this->SourceFiles.end(); ++i) {
for (cmSourceFile* src : this->SourceFiles) {
// does this source file have a custom command?
if ((*i)->GetCustomCommand()) {
if (src->GetCustomCommand()) {
// Does the output of the custom command match the source file name?
const std::vector<std::string>& outputs =
(*i)->GetCustomCommand()->GetOutputs();
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
out = *o;
src->GetCustomCommand()->GetOutputs();
for (std::string const& output : outputs) {
out = output;
std::string::size_type pos = out.rfind(name);
// If the output matches exactly
if (pos != std::string::npos && pos == out.size() - name.size() &&
(pos == 0 || out[pos - 1] == '/')) {
return *i;
return src;
}
}
}
@@ -1936,12 +1911,10 @@ cmSourceGroup* cmMakefile::GetSourceGroup(
cmSourceGroup* sg = nullptr;
// first look for source group starting with the same as the one we want
for (std::vector<cmSourceGroup>::const_iterator sgIt =
this->SourceGroups.begin();
sgIt != this->SourceGroups.end(); ++sgIt) {
std::string sgName = sgIt->GetName();
for (cmSourceGroup const& srcGroup : this->SourceGroups) {
std::string sgName = srcGroup.GetName();
if (sgName == name[0]) {
sg = const_cast<cmSourceGroup*>(&(*sgIt));
sg = const_cast<cmSourceGroup*>(&srcGroup);
break;
}
}
@@ -2094,9 +2067,8 @@ void cmMakefile::ExpandVariablesCMP0019()
}
// Also for each target's INCLUDE_DIRECTORIES property:
for (cmTargets::iterator l = this->Targets.begin(); l != this->Targets.end();
++l) {
cmTarget& t = l->second;
for (auto& target : this->Targets) {
cmTarget& t = target.second;
if (t.GetType() == cmStateEnums::INTERFACE_LIBRARY ||
t.GetType() == cmStateEnums::GLOBAL_TARGET) {
continue;
@@ -2243,9 +2215,9 @@ bool cmMakefile::PlatformIsAppleIos() const
"iphonesimulator", "watchos", "watchsimulator",
};
for (size_t i = 0; i < sizeof(embedded) / sizeof(embedded[0]); ++i) {
if (sdkRoot.find(embedded[i]) == 0 ||
sdkRoot.find(std::string("/") + embedded[i]) != std::string::npos) {
for (std::string const& i : embedded) {
if (sdkRoot.find(i) == 0 ||
sdkRoot.find(std::string("/") + i) != std::string::npos) {
return true;
}
}
@@ -2967,23 +2939,22 @@ bool cmMakefile::ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
if (!filename) {
filename = efp.c_str();
}
std::vector<cmListFileArgument>::const_iterator i;
std::string value;
outArgs.reserve(inArgs.size());
for (i = inArgs.begin(); i != inArgs.end(); ++i) {
for (cmListFileArgument const& i : inArgs) {
// No expansion in a bracket argument.
if (i->Delim == cmListFileArgument::Bracket) {
outArgs.push_back(i->Value);
if (i.Delim == cmListFileArgument::Bracket) {
outArgs.push_back(i.Value);
continue;
}
// Expand the variables in the argument.
value = i->Value;
this->ExpandVariablesInString(value, false, false, false, filename,
i->Line, false, false);
value = i.Value;
this->ExpandVariablesInString(value, false, false, false, filename, i.Line,
false, false);
// If the argument is quoted, it should be one argument.
// Otherwise, it may be a list of arguments.
if (i->Delim == cmListFileArgument::Quoted) {
if (i.Delim == cmListFileArgument::Quoted) {
outArgs.push_back(value);
} else {
cmSystemTools::ExpandListArgument(value, outArgs);
@@ -3000,29 +2971,28 @@ bool cmMakefile::ExpandArguments(
if (!filename) {
filename = efp.c_str();
}
std::vector<cmListFileArgument>::const_iterator i;
std::string value;
outArgs.reserve(inArgs.size());
for (i = inArgs.begin(); i != inArgs.end(); ++i) {
for (cmListFileArgument const& i : inArgs) {
// No expansion in a bracket argument.
if (i->Delim == cmListFileArgument::Bracket) {
outArgs.push_back(cmExpandedCommandArgument(i->Value, true));
if (i.Delim == cmListFileArgument::Bracket) {
outArgs.push_back(cmExpandedCommandArgument(i.Value, true));
continue;
}
// Expand the variables in the argument.
value = i->Value;
this->ExpandVariablesInString(value, false, false, false, filename,
i->Line, false, false);
value = i.Value;
this->ExpandVariablesInString(value, false, false, false, filename, i.Line,
false, false);
// If the argument is quoted, it should be one argument.
// Otherwise, it may be a list of arguments.
if (i->Delim == cmListFileArgument::Quoted) {
if (i.Delim == cmListFileArgument::Quoted) {
outArgs.push_back(cmExpandedCommandArgument(value, true));
} else {
std::vector<std::string> stringArgs;
cmSystemTools::ExpandListArgument(value, stringArgs);
for (size_t j = 0; j < stringArgs.size(); ++j) {
outArgs.push_back(cmExpandedCommandArgument(stringArgs[j], false));
for (std::string const& stringArg : stringArgs) {
outArgs.push_back(cmExpandedCommandArgument(stringArg, false));
}
}
}
@@ -3112,10 +3082,7 @@ void cmMakefile::SetArgcArgv(const std::vector<std::string>& args)
cmSourceFile* cmMakefile::GetSource(const std::string& sourceName) const
{
cmSourceFileLocation sfl(this, sourceName);
for (std::vector<cmSourceFile*>::const_iterator sfi =
this->SourceFiles.begin();
sfi != this->SourceFiles.end(); ++sfi) {
cmSourceFile* sf = *sfi;
for (cmSourceFile* sf : this->SourceFiles) {
if (sf->Matches(sfl)) {
return sf;
}
@@ -3166,12 +3133,11 @@ void cmMakefile::EnableLanguage(std::vector<std::string> const& lang,
std::vector<std::string> langs;
std::vector<std::string> langsRC;
langs.reserve(lang.size());
for (std::vector<std::string>::const_iterator i = lang.begin();
i != lang.end(); ++i) {
if (*i == "RC") {
langsRC.push_back(*i);
for (std::string const& i : lang) {
if (i == "RC") {
langsRC.push_back(i);
} else {
langs.push_back(*i);
langs.push_back(i);
}
}
if (!langs.empty()) {
@@ -3365,9 +3331,7 @@ std::string cmMakefile::GetModulesFile(const char* filename) const
cmSystemTools::ExpandListArgument(cmakeModulePath, modulePath);
// Look through the possible module directories.
for (std::vector<std::string>::iterator i = modulePath.begin();
i != modulePath.end(); ++i) {
std::string itempl = *i;
for (std::string itempl : modulePath) {
cmSystemTools::ConvertToUnixSlashes(itempl);
itempl += "/";
itempl += filename;
@@ -3657,14 +3621,13 @@ void cmMakefile::AddCMakeDependFilesFromUser()
if (const char* deps_str = this->GetProperty("CMAKE_CONFIGURE_DEPENDS")) {
cmSystemTools::ExpandListArgument(deps_str, deps);
}
for (std::vector<std::string>::iterator i = deps.begin(); i != deps.end();
++i) {
if (cmSystemTools::FileIsFullPath(i->c_str())) {
this->AddCMakeDependFile(*i);
for (std::string const& dep : deps) {
if (cmSystemTools::FileIsFullPath(dep.c_str())) {
this->AddCMakeDependFile(dep);
} else {
std::string f = this->GetCurrentSourceDirectory();
f += "/";
f += *i;
f += dep;
this->AddCMakeDependFile(f);
}
}
Source/cmMakefileExecutableTargetGenerator.cxx
+8 -10
View File
@@ -256,11 +256,10 @@ void cmMakefileExecutableTargetGenerator::WriteDeviceExecutableRule(
// Expand placeholders in the commands.
rulePlaceholderExpander->SetTargetImpLib(targetOutputReal);
for (std::vector<std::string>::iterator i = real_link_commands.begin();
i != real_link_commands.end(); ++i) {
*i = launcher + *i;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator, *i,
vars);
for (std::string& real_link_command : real_link_commands) {
real_link_command = launcher + real_link_command;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
real_link_command, vars);
}
// Restore path conversion to normal shells.
@@ -638,11 +637,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// Expand placeholders in the commands.
rulePlaceholderExpander->SetTargetImpLib(targetOutPathImport);
for (std::vector<std::string>::iterator i = real_link_commands.begin();
i != real_link_commands.end(); ++i) {
*i = launcher + *i;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator, *i,
vars);
for (std::string& real_link_command : real_link_commands) {
real_link_command = launcher + real_link_command;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
real_link_command, vars);
}
// Restore path conversion to normal shells.
Source/cmMakefileLibraryTargetGenerator.cxx
+14 -22
View File
@@ -419,11 +419,10 @@ void cmMakefileLibraryTargetGenerator::WriteDeviceLibraryRules(
cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
// Expand placeholders.
for (std::vector<std::string>::iterator i = real_link_commands.begin();
i != real_link_commands.end(); ++i) {
*i = launcher + *i;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator, *i,
vars);
for (std::string& real_link_command : real_link_commands) {
real_link_command = launcher + real_link_command;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
real_link_command, vars);
}
// Restore path conversion to normal shells.
this->LocalGenerator->SetLinkScriptShell(false);
@@ -897,10 +896,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
std::vector<std::string>::iterator osi = object_strings.begin();
{
vars.Objects = osi->c_str();
for (std::vector<std::string>::const_iterator i =
archiveCreateCommands.begin();
i != archiveCreateCommands.end(); ++i) {
std::string cmd = launcher + *i;
for (std::string const& acc : archiveCreateCommands) {
std::string cmd = launcher + acc;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
cmd, vars);
real_link_commands.push_back(cmd);
@@ -909,10 +906,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Append to the archive with the other object sets.
for (++osi; osi != object_strings.end(); ++osi) {
vars.Objects = osi->c_str();
for (std::vector<std::string>::const_iterator i =
archiveAppendCommands.begin();
i != archiveAppendCommands.end(); ++i) {
std::string cmd = launcher + *i;
for (std::string const& aac : archiveAppendCommands) {
std::string cmd = launcher + aac;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
cmd, vars);
real_link_commands.push_back(cmd);
@@ -920,10 +915,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
}
// Finish the archive.
vars.Objects = "";
for (std::vector<std::string>::const_iterator i =
archiveFinishCommands.begin();
i != archiveFinishCommands.end(); ++i) {
std::string cmd = launcher + *i;
for (std::string const& afc : archiveFinishCommands) {
std::string cmd = launcher + afc;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator, cmd,
vars);
// If there is no ranlib the command will be ":". Skip it.
@@ -945,11 +938,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
}
// Expand placeholders.
for (std::vector<std::string>::iterator i = real_link_commands.begin();
i != real_link_commands.end(); ++i) {
*i = launcher + *i;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator, *i,
vars);
for (std::string& real_link_command : real_link_commands) {
real_link_command = launcher + real_link_command;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
real_link_command, vars);
}
}
Source/cmMakefileTargetGenerator.cxx
+71 -110
View File
@@ -153,18 +153,16 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
this->GeneratorTarget->GetCustomCommands(customCommands, config);
std::string currentBinDir =
this->LocalGenerator->GetCurrentBinaryDirectory();
for (std::vector<cmSourceFile const*>::const_iterator si =
customCommands.begin();
si != customCommands.end(); ++si) {
cmCustomCommandGenerator ccg(*(*si)->GetCustomCommand(), this->ConfigName,
for (cmSourceFile const* sf : customCommands) {
cmCustomCommandGenerator ccg(*sf->GetCustomCommand(), this->ConfigName,
this->LocalGenerator);
this->GenerateCustomRuleFile(ccg);
if (clean) {
const std::vector<std::string>& outputs = ccg.GetOutputs();
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
for (std::string const& output : outputs) {
this->CleanFiles.push_back(
this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir, *o));
this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir,
output));
}
}
}
@@ -178,18 +176,14 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
extraSources, this->MacOSXContentGenerator);
std::vector<cmSourceFile const*> externalObjects;
this->GeneratorTarget->GetExternalObjects(externalObjects, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
externalObjects.begin();
si != externalObjects.end(); ++si) {
this->ExternalObjects.push_back((*si)->GetFullPath());
for (cmSourceFile const* sf : externalObjects) {
this->ExternalObjects.push_back(sf->GetFullPath());
}
std::vector<cmSourceFile const*> objectSources;
this->GeneratorTarget->GetObjectSources(objectSources, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
objectSources.begin();
si != objectSources.end(); ++si) {
for (cmSourceFile const* sf : objectSources) {
// Generate this object file's rule file.
this->WriteObjectRuleFiles(**si);
this->WriteObjectRuleFiles(*sf);
}
}
@@ -272,28 +266,26 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
// put the compiler in the rules.make file so that if it changes
// things rebuild
for (std::set<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l) {
for (std::string const& language : languages) {
std::string compiler = "CMAKE_";
compiler += *l;
compiler += language;
compiler += "_COMPILER";
*this->FlagFileStream << "# compile " << *l << " with "
*this->FlagFileStream << "# compile " << language << " with "
<< this->Makefile->GetSafeDefinition(compiler)
<< "\n";
}
for (std::set<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l) {
std::string flags = this->GetFlags(*l);
std::string defines = this->GetDefines(*l);
std::string includes = this->GetIncludes(*l);
for (std::string const& language : languages) {
std::string flags = this->GetFlags(language);
std::string defines = this->GetDefines(language);
std::string includes = this->GetIncludes(language);
// Escape comment characters so they do not terminate assignment.
cmSystemTools::ReplaceString(flags, "#", "\\#");
cmSystemTools::ReplaceString(defines, "#", "\\#");
cmSystemTools::ReplaceString(includes, "#", "\\#");
*this->FlagFileStream << *l << "_FLAGS = " << flags << "\n\n";
*this->FlagFileStream << *l << "_DEFINES = " << defines << "\n\n";
*this->FlagFileStream << *l << "_INCLUDES = " << includes << "\n\n";
*this->FlagFileStream << language << "_FLAGS = " << flags << "\n\n";
*this->FlagFileStream << language << "_DEFINES = " << defines << "\n\n";
*this->FlagFileStream << language << "_INCLUDES = " << includes << "\n\n";
}
}
@@ -673,10 +665,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
if (clauncher && *clauncher) {
std::vector<std::string> launcher_cmd;
cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
e = launcher_cmd.end();
i != e; ++i) {
*i = this->LocalGenerator->EscapeForShell(*i);
for (std::string& i : launcher_cmd) {
i = this->LocalGenerator->EscapeForShell(i);
}
std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
compileCommands.front().insert(0, run_launcher);
@@ -694,11 +684,10 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
}
// Expand placeholders in the commands.
for (std::vector<std::string>::iterator i = compileCommands.begin();
i != compileCommands.end(); ++i) {
*i = launcher + *i;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator, *i,
vars);
for (std::string& compileCommand : compileCommands) {
compileCommand = launcher + compileCommand;
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
compileCommand, vars);
}
// Change the command working directory to the local build tree.
@@ -759,11 +748,10 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
vars.PreprocessedSource = shellObjI.c_str();
// Expand placeholders in the commands.
for (std::vector<std::string>::iterator i = preprocessCommands.begin();
i != preprocessCommands.end(); ++i) {
for (std::string& preprocessCommand : preprocessCommands) {
// no launcher for preprocessor commands
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
*i, vars);
rulePlaceholderExpander->ExpandRuleVariables(
this->LocalGenerator, preprocessCommand, vars);
}
this->LocalGenerator->CreateCDCommand(
@@ -808,11 +796,10 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
vars.AssemblySource = shellObjS.c_str();
// Expand placeholders in the commands.
for (std::vector<std::string>::iterator i = assemblyCommands.begin();
i != assemblyCommands.end(); ++i) {
for (std::string& assemblyCommand : assemblyCommands) {
// no launcher for assembly commands
rulePlaceholderExpander->ExpandRuleVariables(this->LocalGenerator,
*i, vars);
assemblyCommand, vars);
}
this->LocalGenerator->CreateCDCommand(
@@ -880,10 +867,9 @@ void cmMakefileTargetGenerator::WriteTargetRequiresRules()
// This target drives dependency generation for all object files.
std::string relPath = this->LocalGenerator->GetHomeRelativeOutputPath();
std::string objTarget;
for (std::vector<std::string>::const_iterator obj = this->Objects.begin();
obj != this->Objects.end(); ++obj) {
for (std::string const& obj : this->Objects) {
objTarget = relPath;
objTarget += *obj;
objTarget += obj;
objTarget += ".requires";
depends.push_back(objTarget);
}
@@ -1007,12 +993,10 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
<< "# Pairs of files generated by the same build rule.\n"
<< "set(CMAKE_MULTIPLE_OUTPUT_PAIRS\n";
/* clang-format on */
for (MultipleOutputPairsType::const_iterator pi =
this->MultipleOutputPairs.begin();
pi != this->MultipleOutputPairs.end(); ++pi) {
for (auto const& pi : this->MultipleOutputPairs) {
*this->InfoFileStream
<< " " << cmOutputConverter::EscapeForCMake(pi->first) << " "
<< cmOutputConverter::EscapeForCMake(pi->second) << "\n";
<< " " << cmOutputConverter::EscapeForCMake(pi.first) << " "
<< cmOutputConverter::EscapeForCMake(pi.second) << "\n";
}
*this->InfoFileStream << " )\n\n";
}
@@ -1026,9 +1010,8 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
<< "set(CMAKE_TARGET_LINKED_INFO_FILES\n";
/* clang-format on */
std::vector<std::string> dirs = this->GetLinkedTargetDirectories();
for (std::vector<std::string>::iterator i = dirs.begin(); i != dirs.end();
++i) {
*this->InfoFileStream << " \"" << *i << "/DependInfo.cmake\"\n";
for (std::string const& d : dirs) {
*this->InfoFileStream << " \"" << d << "/DependInfo.cmake\"\n";
}
*this->InfoFileStream << " )\n";
}
@@ -1126,9 +1109,8 @@ void cmMakefileTargetGenerator::DriveCustomCommands(
std::vector<cmSourceFile*> sources;
this->GeneratorTarget->GetSourceFiles(
sources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator source = sources.begin();
source != sources.end(); ++source) {
if (cmCustomCommand* cc = (*source)->GetCustomCommand()) {
for (cmSourceFile* source : sources) {
if (cmCustomCommand* cc = source->GetCustomCommand()) {
cmCustomCommandGenerator ccg(*cc, this->ConfigName,
this->LocalGenerator);
const std::vector<std::string>& outputs = ccg.GetOutputs();
@@ -1187,12 +1169,10 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile(
}
// Setup implicit dependency scanning.
for (cmCustomCommand::ImplicitDependsList::const_iterator idi =
ccg.GetCC().GetImplicitDepends().begin();
idi != ccg.GetCC().GetImplicitDepends().end(); ++idi) {
for (auto const& idi : ccg.GetCC().GetImplicitDepends()) {
std::string objFullPath = cmSystemTools::CollapseFullPath(outputs[0]);
std::string srcFullPath = cmSystemTools::CollapseFullPath(idi->second);
this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, idi->first,
std::string srcFullPath = cmSystemTools::CollapseFullPath(idi.second);
this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, idi.first,
objFullPath.c_str(),
srcFullPath.c_str());
}
@@ -1225,11 +1205,10 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
if (!lineContinue) {
lineContinue = "\\";
}
for (std::vector<std::string>::const_iterator i = this->Objects.begin();
i != this->Objects.end(); ++i) {
for (std::string const& obj : this->Objects) {
*this->BuildFileStream << " " << lineContinue << "\n";
*this->BuildFileStream << this->LocalGenerator->ConvertToQuotedOutputPath(
i->c_str(), useWatcomQuote);
obj.c_str(), useWatcomQuote);
}
*this->BuildFileStream << "\n";
@@ -1246,14 +1225,12 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
/* clang-format on */
std::string currentBinDir =
this->LocalGenerator->GetCurrentBinaryDirectory();
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
for (std::string const& obj : this->ExternalObjects) {
object =
this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir, *i);
this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir, obj);
*this->BuildFileStream << " " << lineContinue << "\n";
*this->BuildFileStream << this->LocalGenerator->ConvertToQuotedOutputPath(
i->c_str(), useWatcomQuote);
obj.c_str(), useWatcomQuote);
}
*this->BuildFileStream << "\n"
<< "\n";
@@ -1323,14 +1300,11 @@ void cmMakefileTargetGenerator::WriteObjectsStrings(
cmMakefileTargetGeneratorObjectStrings helper(
objStrings, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory(), limit);
for (std::vector<std::string>::const_iterator i = this->Objects.begin();
i != this->Objects.end(); ++i) {
helper.Feed(*i);
for (std::string const& obj : this->Objects) {
helper.Feed(obj);
}
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
helper.Feed(*i);
for (std::string const& obj : this->ExternalObjects) {
helper.Feed(obj);
}
helper.Done();
}
@@ -1398,10 +1372,9 @@ void cmMakefileTargetGenerator::AppendObjectDepends(
// Add dependencies on the compiled object files.
std::string relPath = this->LocalGenerator->GetHomeRelativeOutputPath();
std::string objTarget;
for (std::vector<std::string>::const_iterator obj = this->Objects.begin();
obj != this->Objects.end(); ++obj) {
for (std::string const& obj : this->Objects) {
objTarget = relPath;
objTarget += *obj;
objTarget += obj;
depends.push_back(objTarget);
}
@@ -1426,19 +1399,16 @@ void cmMakefileTargetGenerator::AppendLinkDepends(
if (cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
this->GeneratorTarget->GetModuleDefinitionInfo(
this->GetConfigName())) {
for (std::vector<cmSourceFile const*>::const_iterator i =
mdi->Sources.begin();
i != mdi->Sources.end(); ++i) {
depends.push_back((*i)->GetFullPath());
for (cmSourceFile const* src : mdi->Sources) {
depends.push_back(src->GetFullPath());
}
}
// Add a dependency on user-specified manifest files, if any.
std::vector<cmSourceFile const*> manifest_srcs;
this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
mi != manifest_srcs.end(); ++mi) {
depends.push_back((*mi)->GetFullPath());
for (cmSourceFile const* manifest_src : manifest_srcs) {
depends.push_back(manifest_src->GetFullPath());
}
// Add user-specified dependencies.
@@ -1481,12 +1451,11 @@ void cmMakefileTargetGenerator::CreateLinkScript(
linkScriptName += name;
cmGeneratedFileStream linkScriptStream(linkScriptName.c_str());
linkScriptStream.SetCopyIfDifferent(true);
for (std::vector<std::string>::const_iterator cmd = link_commands.begin();
cmd != link_commands.end(); ++cmd) {
for (std::string const& link_command : link_commands) {
// Do not write out empty commands or commands beginning in the
// shell no-op ":".
if (!cmd->empty() && (*cmd)[0] != ':') {
linkScriptStream << *cmd << "\n";
if (!link_command.empty() && link_command[0] != ':') {
linkScriptStream << link_command << "\n";
}
}
@@ -1521,14 +1490,11 @@ bool cmMakefileTargetGenerator::CheckUseResponseFileForObjects(
// actual list will likely be much shorter than this. However, in the
// worst case all objects will remain as absolute paths.
size_t length = 0;
for (std::vector<std::string>::const_iterator i = this->Objects.begin();
i != this->Objects.end(); ++i) {
length += i->size() + 3;
for (std::string const& obj : this->Objects) {
length += obj.size() + 3;
}
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
length += i->size() + 3;
for (std::string const& ext_obj : this->ExternalObjects) {
length += ext_obj.size() + 3;
}
// We need to guarantee room for both objects and libraries, so
@@ -1751,22 +1717,17 @@ void cmMakefileTargetGenerator::GenDefFile(
cmGeneratedFileStream fout(objlist_file.c_str());
if (mdi->WindowsExportAllSymbols) {
for (std::vector<std::string>::const_iterator i = this->Objects.begin();
i != this->Objects.end(); ++i) {
if (cmHasLiteralSuffix(*i, ".obj")) {
fout << *i << "\n";
for (std::string const& obj : this->Objects) {
if (cmHasLiteralSuffix(obj, ".obj")) {
fout << obj << "\n";
}
}
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
fout << *i << "\n";
for (std::string const& obj : this->ExternalObjects) {
fout << obj << "\n";
}
}
for (std::vector<cmSourceFile const*>::const_iterator i =
mdi->Sources.begin();
i != mdi->Sources.end(); ++i) {
fout << (*i)->GetFullPath() << "\n";
for (cmSourceFile const* src : mdi->Sources) {
fout << src->GetFullPath() << "\n";
}
}
Source/cmNinjaNormalTargetGenerator.cxx
+24 -36
View File
@@ -10,7 +10,6 @@
#include <sstream>
#include "cmAlgorithms.h"
#include "cmCustomCommand.h"
#include "cmCustomCommandGenerator.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
@@ -33,6 +32,8 @@
#include "cm_auto_ptr.hxx"
#include "cmake.h"
class cmCustomCommand;
cmNinjaNormalTargetGenerator::cmNinjaNormalTargetGenerator(
cmGeneratorTarget* target)
: cmNinjaTargetGenerator(target)
@@ -112,17 +113,14 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules()
std::vector<cmSourceFile const*> sourceFiles;
this->GetGeneratorTarget()->GetObjectSources(
sourceFiles, this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile const*>::const_iterator i =
sourceFiles.begin();
i != sourceFiles.end(); ++i) {
const std::string& lang = (*i)->GetLanguage();
for (cmSourceFile const* sf : sourceFiles) {
std::string const lang = sf->GetLanguage();
if (!lang.empty()) {
languages.insert(lang);
}
}
for (std::set<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l) {
this->WriteLanguageRules(*l);
for (std::string const& language : languages) {
this->WriteLanguageRules(language);
}
}
@@ -248,11 +246,10 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRule(bool useResponseFile)
// Rule for linking library/executable.
std::vector<std::string> linkCmds = this->ComputeDeviceLinkCmd();
for (std::vector<std::string>::iterator i = linkCmds.begin();
i != linkCmds.end(); ++i) {
*i = launcher + *i;
for (std::string& linkCmd : linkCmds) {
linkCmd = launcher + linkCmd;
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(),
*i, vars);
linkCmd, vars);
}
// If there is no ranlib the command will be ":". Skip it.
@@ -373,11 +370,10 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile)
// Rule for linking library/executable.
std::vector<std::string> linkCmds = this->ComputeLinkCmd();
for (std::vector<std::string>::iterator i = linkCmds.begin();
i != linkCmds.end(); ++i) {
*i = launcher + *i;
for (std::string& linkCmd : linkCmds) {
linkCmd = launcher + linkCmd;
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(),
*i, vars);
linkCmd, vars);
}
// If there is no ranlib the command will be ":". Skip it.
@@ -731,10 +727,8 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatement()
&postBuildCmdLines };
for (unsigned i = 0; i != 3; ++i) {
for (std::vector<cmCustomCommand>::const_iterator ci =
cmdLists[i]->begin();
ci != cmdLists[i]->end(); ++ci) {
cmCustomCommandGenerator ccg(*ci, cfgName, this->GetLocalGenerator());
for (cmCustomCommand const& cc : *cmdLists[i]) {
cmCustomCommandGenerator ccg(cc, cfgName, this->GetLocalGenerator());
localGen.AppendCustomCommandLines(ccg, *cmdLineLists[i]);
std::vector<std::string> const& ccByproducts = ccg.GetByproducts();
std::transform(ccByproducts.begin(), ccByproducts.end(),
@@ -960,10 +954,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
&postBuildCmdLines };
for (unsigned i = 0; i != 3; ++i) {
for (std::vector<cmCustomCommand>::const_iterator ci =
cmdLists[i]->begin();
ci != cmdLists[i]->end(); ++ci) {
cmCustomCommandGenerator ccg(*ci, cfgName, this->GetLocalGenerator());
for (cmCustomCommand const& cc : *cmdLists[i]) {
cmCustomCommandGenerator ccg(cc, cfgName, this->GetLocalGenerator());
localGen.AppendCustomCommandLines(ccg, *cmdLineLists[i]);
std::vector<std::string> const& ccByproducts = ccg.GetByproducts();
std::transform(ccByproducts.begin(), ccByproducts.end(),
@@ -993,17 +985,15 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
if (mdi->WindowsExportAllSymbols) {
cmNinjaDeps objs = this->GetObjects();
for (cmNinjaDeps::iterator i = objs.begin(); i != objs.end(); ++i) {
if (cmHasLiteralSuffix(*i, ".obj")) {
fout << *i << "\n";
for (std::string const& obj : objs) {
if (cmHasLiteralSuffix(obj, ".obj")) {
fout << obj << "\n";
}
}
}
for (std::vector<cmSourceFile const*>::const_iterator i =
mdi->Sources.begin();
i != mdi->Sources.end(); ++i) {
fout << (*i)->GetFullPath() << "\n";
for (cmSourceFile const* src : mdi->Sources) {
fout << src->GetFullPath() << "\n";
}
}
// If we have any PRE_LINK commands, we need to go back to CMAKE_BINARY_DIR
@@ -1050,11 +1040,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
// Ninja should restat after linking if and only if there are byproducts.
vars["RESTAT"] = byproducts.empty() ? "" : "1";
for (cmNinjaDeps::const_iterator oi = byproducts.begin(),
oe = byproducts.end();
oi != oe; ++oi) {
this->GetGlobalGenerator()->SeenCustomCommandOutput(*oi);
outputs.push_back(*oi);
for (std::string const& o : byproducts) {
this->GetGlobalGenerator()->SeenCustomCommandOutput(o);
outputs.push_back(o);
}
// Write the build statement for this target.
Source/cmNinjaTargetGenerator.cxx
+28 -48
View File
@@ -215,19 +215,16 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
if (cmGeneratorTarget::ModuleDefinitionInfo const* mdi =
this->GeneratorTarget->GetModuleDefinitionInfo(
this->GetConfigName())) {
for (std::vector<cmSourceFile const*>::const_iterator i =
mdi->Sources.begin();
i != mdi->Sources.end(); ++i) {
result.push_back(this->ConvertToNinjaPath((*i)->GetFullPath()));
for (cmSourceFile const* src : mdi->Sources) {
result.push_back(this->ConvertToNinjaPath(src->GetFullPath()));
}
}
// Add a dependency on user-specified manifest files, if any.
std::vector<cmSourceFile const*> manifest_srcs;
this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
mi != manifest_srcs.end(); ++mi) {
result.push_back(this->ConvertToNinjaPath((*mi)->GetFullPath()));
for (cmSourceFile const* manifest_src : manifest_srcs) {
result.push_back(this->ConvertToNinjaPath(manifest_src->GetFullPath()));
}
// Add user-specified dependencies.
@@ -519,11 +516,10 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
std::vector<std::string> ppCmds;
cmSystemTools::ExpandListArgument(ppCmd, ppCmds);
for (std::vector<std::string>::iterator i = ppCmds.begin();
i != ppCmds.end(); ++i) {
*i = launcher + *i;
for (std::string& i : ppCmds) {
i = launcher + i;
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(),
*i, ppVars);
i, ppVars);
}
// Run CMake dependency scanner on preprocessed output.
@@ -657,10 +653,8 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
if (clauncher && *clauncher) {
std::vector<std::string> launcher_cmd;
cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
e = launcher_cmd.end();
i != e; ++i) {
*i = this->LocalGenerator->EscapeForShell(*i);
for (std::string& i : launcher_cmd) {
i = this->LocalGenerator->EscapeForShell(i);
}
std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
compileCmds.front().insert(0, run_launcher);
@@ -671,10 +665,9 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
compileCmds.front().insert(0, cldeps);
}
for (std::vector<std::string>::iterator i = compileCmds.begin();
i != compileCmds.end(); ++i) {
*i = launcher + *i;
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), *i,
for (std::string& i : compileCmds) {
i = launcher + i;
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), i,
vars);
}
@@ -705,10 +698,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
std::vector<cmSourceFile const*> customCommands;
this->GeneratorTarget->GetCustomCommands(customCommands, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
customCommands.begin();
si != customCommands.end(); ++si) {
cmCustomCommand const* cc = (*si)->GetCustomCommand();
for (cmSourceFile const* sf : customCommands) {
cmCustomCommand const* cc = sf->GetCustomCommand();
this->GetLocalGenerator()->AddCustomCommandTarget(
cc, this->GetGeneratorTarget());
// Record the custom commands for this target. The container is used
@@ -725,10 +716,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
extraSources, this->MacOSXContentGenerator);
std::vector<cmSourceFile const*> externalObjects;
this->GeneratorTarget->GetExternalObjects(externalObjects, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
externalObjects.begin();
si != externalObjects.end(); ++si) {
this->Objects.push_back(this->GetSourceFilePath(*si));
for (cmSourceFile const* sf : externalObjects) {
this->Objects.push_back(this->GetSourceFilePath(sf));
}
cmNinjaDeps orderOnlyDeps;
@@ -740,10 +729,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
this->ExtraFiles.end());
// Add order-only dependencies on custom command outputs.
for (std::vector<cmCustomCommand const*>::const_iterator cci =
this->CustomCommands.begin();
cci != this->CustomCommands.end(); ++cci) {
cmCustomCommand const* cc = *cci;
for (cmCustomCommand const* cc : this->CustomCommands) {
cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
this->GetLocalGenerator());
const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
@@ -768,10 +754,8 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements()
}
std::vector<cmSourceFile const*> objectSources;
this->GeneratorTarget->GetObjectSources(objectSources, config);
for (std::vector<cmSourceFile const*>::const_iterator si =
objectSources.begin();
si != objectSources.end(); ++si) {
this->WriteObjectBuildStatement(*si);
for (cmSourceFile const* sf : objectSources) {
this->WriteObjectBuildStatement(sf);
}
if (!this->DDIFiles.empty()) {
@@ -848,10 +832,9 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
if (const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
std::vector<std::string> depList;
cmSystemTools::ExpandListArgument(objectDeps, depList);
for (std::vector<std::string>::iterator odi = depList.begin();
odi != depList.end(); ++odi) {
if (cmSystemTools::FileIsFullPath(*odi)) {
*odi = cmSystemTools::CollapseFullPath(*odi);
for (std::string& odi : depList) {
if (cmSystemTools::FileIsFullPath(odi)) {
odi = cmSystemTools::CollapseFullPath(odi);
}
}
std::transform(depList.begin(), depList.end(),
@@ -1019,19 +1002,17 @@ void cmNinjaTargetGenerator::WriteTargetDependInfo(std::string const& lang)
std::vector<std::string> includes;
this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
lang, this->GetConfigName());
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
for (std::string const& i : includes) {
// Convert the include directories the same way we do for -I flags.
// See upstream ninja issue 1251.
tdi_include_dirs.append(this->ConvertToNinjaPath(*i));
tdi_include_dirs.append(this->ConvertToNinjaPath(i));
}
Json::Value& tdi_linked_target_dirs = tdi["linked-target-dirs"] =
Json::arrayValue;
std::vector<std::string> linked = this->GetLinkedTargetDirectories();
for (std::vector<std::string>::iterator i = linked.begin();
i != linked.end(); ++i) {
tdi_linked_target_dirs.append(*i);
for (std::string const& l : linked) {
tdi_linked_target_dirs.append(l);
}
std::string const tdin = this->GetTargetDependInfoPath(lang);
@@ -1099,10 +1080,9 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
CM_AUTO_PTR<cmRulePlaceholderExpander> rulePlaceholderExpander(
this->GetLocalGenerator()->CreateRulePlaceholderExpander());
for (std::vector<std::string>::iterator i = compileCmds.begin();
i != compileCmds.end(); ++i) {
for (std::string& i : compileCmds) {
// no launcher for CMAKE_EXPORT_COMPILE_COMMANDS
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), *i,
rulePlaceholderExpander->ExpandRuleVariables(this->GetLocalGenerator(), i,
compileObjectVars);
}
Source/cmNinjaUtilityTargetGenerator.cxx
+7 -12
View File
@@ -51,17 +51,15 @@ void cmNinjaUtilityTargetGenerator::Generate()
bool uses_terminal = false;
for (unsigned i = 0; i != 2; ++i) {
for (std::vector<cmCustomCommand>::const_iterator ci =
cmdLists[i]->begin();
ci != cmdLists[i]->end(); ++ci) {
cmCustomCommandGenerator ccg(*ci, this->GetConfigName(),
for (cmCustomCommand const& ci : *cmdLists[i]) {
cmCustomCommandGenerator ccg(ci, this->GetConfigName(),
this->GetLocalGenerator());
this->GetLocalGenerator()->AppendCustomCommandDeps(ccg, deps);
this->GetLocalGenerator()->AppendCustomCommandLines(ccg, commands);
std::vector<std::string> const& ccByproducts = ccg.GetByproducts();
std::transform(ccByproducts.begin(), ccByproducts.end(),
std::back_inserter(util_outputs), MapToNinjaPath());
if (ci->GetUsesTerminal()) {
if (ci.GetUsesTerminal()) {
uses_terminal = true;
}
}
@@ -71,9 +69,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
std::string config =
this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
this->GetGeneratorTarget()->GetSourceFiles(sources, config);
for (std::vector<cmSourceFile*>::const_iterator source = sources.begin();
source != sources.end(); ++source) {
if (cmCustomCommand* cc = (*source)->GetCustomCommand()) {
for (cmSourceFile const* source : sources) {
if (cmCustomCommand const* cc = source->GetCustomCommand()) {
cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
this->GetLocalGenerator());
this->GetLocalGenerator()->AddCustomCommandTarget(
@@ -132,10 +129,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
return;
}
for (cmNinjaDeps::const_iterator oi = util_outputs.begin(),
oe = util_outputs.end();
oi != oe; ++oi) {
this->GetGlobalGenerator()->SeenCustomCommandOutput(*oi);
for (std::string const& util_output : util_outputs) {
this->GetGlobalGenerator()->SeenCustomCommandOutput(util_output);
}
this->GetGlobalGenerator()->WriteCustomCommandBuild(
Source/cmOSXBundleGenerator.cxx
+3 -4
View File
@@ -195,12 +195,11 @@ void cmOSXBundleGenerator::GenerateMacOSXContentStatements(
return;
}
for (std::vector<cmSourceFile const*>::const_iterator si = sources.begin();
si != sources.end(); ++si) {
for (cmSourceFile const* source : sources) {
cmGeneratorTarget::SourceFileFlags tsFlags =
this->GT->GetTargetSourceFileFlags(*si);
this->GT->GetTargetSourceFileFlags(source);
if (tsFlags.Type != cmGeneratorTarget::SourceFileTypeNormal) {
(*generator)(**si, tsFlags.MacFolder);
(*generator)(*source, tsFlags.MacFolder);
}
}
}
Source/cmOrderDirectories.cxx
+24 -31
View File
@@ -75,9 +75,8 @@ public:
void FindImplicitConflicts(std::ostringstream& w)
{
bool first = true;
for (unsigned int i = 0; i < this->OD->OriginalDirectories.size(); ++i) {
for (std::string const& dir : this->OD->OriginalDirectories) {
// Check if this directory conflicts with the entry.
std::string const& dir = this->OD->OriginalDirectories[i];
if (dir != this->Directory &&
cmSystemTools::GetRealPath(dir) !=
cmSystemTools::GetRealPath(this->Directory) &&
@@ -226,12 +225,10 @@ bool cmOrderDirectoriesConstraintLibrary::FindConflict(std::string const& dir)
this->OD->RemoveLibraryExtension.find(this->FileName)) {
std::string lib = this->OD->RemoveLibraryExtension.match(1);
std::string ext = this->OD->RemoveLibraryExtension.match(2);
for (std::vector<std::string>::iterator i =
this->OD->LinkExtensions.begin();
i != this->OD->LinkExtensions.end(); ++i) {
if (*i != ext) {
for (std::string const& LinkExtension : this->OD->LinkExtensions) {
if (LinkExtension != ext) {
std::string fname = lib;
fname += *i;
fname += LinkExtension;
if (this->FileMayConflict(dir, fname)) {
return true;
}
@@ -346,9 +343,8 @@ void cmOrderDirectories::SetImplicitDirectories(
std::set<std::string> const& implicitDirs)
{
this->ImplicitDirectories.clear();
for (std::set<std::string>::const_iterator i = implicitDirs.begin();
i != implicitDirs.end(); ++i) {
this->ImplicitDirectories.insert(this->GetRealPath(*i));
for (std::string const& implicitDir : implicitDirs) {
this->ImplicitDirectories.insert(this->GetRealPath(implicitDir));
}
}
@@ -375,8 +371,8 @@ void cmOrderDirectories::CollectOriginalDirectories()
this->AddOriginalDirectories(this->UserDirectories);
// Add directories containing constraints.
for (unsigned int i = 0; i < this->ConstraintEntries.size(); ++i) {
this->ConstraintEntries[i]->AddDirectory();
for (cmOrderDirectoriesConstraint* entry : this->ConstraintEntries) {
entry->AddDirectory();
}
// Add language runtime directories last.
@@ -400,20 +396,19 @@ int cmOrderDirectories::AddOriginalDirectory(std::string const& dir)
void cmOrderDirectories::AddOriginalDirectories(
std::vector<std::string> const& dirs)
{
for (std::vector<std::string>::const_iterator di = dirs.begin();
di != dirs.end(); ++di) {
for (std::string const& dir : dirs) {
// We never explicitly specify implicit link directories.
if (this->IsImplicitDirectory(*di)) {
if (this->IsImplicitDirectory(dir)) {
continue;
}
// Skip the empty string.
if (di->empty()) {
if (dir.empty()) {
continue;
}
// Add this directory.
this->AddOriginalDirectory(*di);
this->AddOriginalDirectory(dir);
}
}
@@ -442,16 +437,15 @@ void cmOrderDirectories::FindConflicts()
}
// Clean up the conflict graph representation.
for (std::vector<ConflictList>::iterator i = this->ConflictGraph.begin();
i != this->ConflictGraph.end(); ++i) {
for (ConflictList& cl : this->ConflictGraph) {
// Sort the outgoing edges for each graph node so that the
// original order will be preserved as much as possible.
std::sort(i->begin(), i->end());
std::sort(cl.begin(), cl.end());
// Make the edge list unique so cycle detection will be reliable.
ConflictList::iterator last =
std::unique(i->begin(), i->end(), cmOrderDirectoriesCompare());
i->erase(last, i->end());
std::unique(cl.begin(), cl.end(), cmOrderDirectoriesCompare());
cl.erase(last, cl.end());
}
// Check items in implicit link directories.
@@ -463,12 +457,12 @@ void cmOrderDirectories::FindImplicitConflicts()
// Check for items in implicit link directories that have conflicts
// in the explicit directories.
std::ostringstream conflicts;
for (unsigned int i = 0; i < this->ImplicitDirEntries.size(); ++i) {
this->ImplicitDirEntries[i]->FindImplicitConflicts(conflicts);
for (cmOrderDirectoriesConstraint* entry : this->ImplicitDirEntries) {
entry->FindImplicitConflicts(conflicts);
}
// Skip warning if there were no conflicts.
std::string text = conflicts.str();
std::string const text = conflicts.str();
if (text.empty()) {
return;
}
@@ -515,8 +509,8 @@ void cmOrderDirectories::VisitDirectory(unsigned int i)
// Visit the neighbors of the node first.
ConflictList const& clist = this->ConflictGraph[i];
for (ConflictList::const_iterator j = clist.begin(); j != clist.end(); ++j) {
this->VisitDirectory(j->first);
for (ConflictPair const& j : clist) {
this->VisitDirectory(j.first);
}
// Now that all directories required to come before this one have
@@ -542,10 +536,9 @@ void cmOrderDirectories::DiagnoseCycle()
for (unsigned int i = 0; i < this->ConflictGraph.size(); ++i) {
ConflictList const& clist = this->ConflictGraph[i];
e << " dir " << i << " is [" << this->OriginalDirectories[i] << "]\n";
for (ConflictList::const_iterator j = clist.begin(); j != clist.end();
++j) {
e << " dir " << j->first << " must precede it due to ";
this->ConstraintEntries[j->second]->Report(e);
for (ConflictPair const& j : clist) {
e << " dir " << j.first << " must precede it due to ";
this->ConstraintEntries[j.second]->Report(e);
e << "\n";
}
}
Source/cmOutputConverter.cxx
+3 -4
View File
@@ -285,12 +285,11 @@ cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat(
if (value && *value) {
std::vector<std::string> fmt;
cmSystemTools::ExpandListArgument(value, fmt);
for (std::vector<std::string>::iterator fi = fmt.begin(); fi != fmt.end();
++fi) {
if (*fi == "FIXED") {
for (std::string const& fi : fmt) {
if (fi == "FIXED") {
format = FortranFormatFixed;
}
if (*fi == "FREE") {
if (fi == "FREE") {
format = FortranFormatFree;
}
}
Source/cmOutputRequiredFilesCommand.cxx
+19 -45
View File
@@ -5,7 +5,6 @@
#include "cmsys/FStream.hxx"
#include "cmsys/RegularExpression.hxx"
#include <map>
#include <unordered_map>
#include <utility>
#include "cmAlgorithms.h"
@@ -114,8 +113,9 @@ public:
std::set<std::string> uniqueIncludes;
std::vector<std::string> orderedAndUniqueIncludes;
cmTargets& targets = this->Makefile->GetTargets();
for (cmTargets::iterator l = targets.begin(); l != targets.end(); ++l) {
const char* incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
for (auto const& target : targets) {
const char* incDirProp =
target.second.GetProperty("INCLUDE_DIRECTORIES");
if (!incDirProp) {
continue;
}
@@ -126,9 +126,7 @@ public:
std::vector<std::string> includes;
cmSystemTools::ExpandListArgument(incDirs, includes);
for (std::vector<std::string>::const_iterator j = includes.begin();
j != includes.end(); ++j) {
std::string path = *j;
for (std::string& path : includes) {
this->Makefile->ExpandVariablesInString(path);
if (uniqueIncludes.insert(path).second) {
orderedAndUniqueIncludes.push_back(path);
@@ -136,10 +134,8 @@ public:
}
}
for (std::vector<std::string>::const_iterator it =
orderedAndUniqueIncludes.begin();
it != orderedAndUniqueIncludes.end(); ++it) {
this->AddSearchPath(*it);
for (std::string const& inc : orderedAndUniqueIncludes) {
this->AddSearchPath(inc);
}
}
@@ -220,10 +216,7 @@ protected:
if (cmSystemTools::FileExists(cxxFile.c_str())) {
found = true;
}
for (std::vector<std::string>::iterator i =
this->IncludeDirectories.begin();
i != this->IncludeDirectories.end(); ++i) {
std::string path = *i;
for (std::string path : this->IncludeDirectories) {
path = path + "/";
path = path + cxxFile;
if (cmSystemTools::FileExists(path.c_str())) {
@@ -235,10 +228,7 @@ protected:
if (cmSystemTools::FileExists(cxxFile.c_str())) {
found = true;
}
for (std::vector<std::string>::iterator i =
this->IncludeDirectories.begin();
i != this->IncludeDirectories.end(); ++i) {
std::string path = *i;
for (std::string path : this->IncludeDirectories) {
path = path + "/";
path = path + cxxFile;
if (cmSystemTools::FileExists(path.c_str())) {
@@ -251,10 +241,7 @@ protected:
if (cmSystemTools::FileExists(cxxFile.c_str())) {
found = true;
}
for (std::vector<std::string>::iterator i =
this->IncludeDirectories.begin();
i != this->IncludeDirectories.end(); ++i) {
std::string path = *i;
for (std::string path : this->IncludeDirectories) {
path = path + "/";
path = path + cxxFile;
if (cmSystemTools::FileExists(path.c_str())) {
@@ -267,10 +254,7 @@ protected:
if (cmSystemTools::FileExists(cxxFile.c_str())) {
found = true;
}
for (std::vector<std::string>::iterator i =
this->IncludeDirectories.begin();
i != this->IncludeDirectories.end(); ++i) {
std::string path = *i;
for (std::string path : this->IncludeDirectories) {
path = path + "/";
path = path + cxxFile;
if (cmSystemTools::FileExists(path.c_str())) {
@@ -337,10 +321,8 @@ protected:
if (!cFile.GetDepends().empty()) {
// Dependency hints have been given. Use them to begin the
// recursion.
for (std::vector<std::string>::const_iterator file =
cFile.GetDepends().begin();
file != cFile.GetDepends().end(); ++file) {
this->AddDependency(info, file->c_str());
for (std::string const& file : cFile.GetDepends()) {
this->AddDependency(info, file.c_str());
}
// Found dependency information. We are done.
@@ -357,10 +339,7 @@ protected:
found = true;
} else {
// try to guess which include path to use
for (std::vector<std::string>::iterator t =
this->IncludeDirectories.begin();
t != this->IncludeDirectories.end(); ++t) {
std::string incpath = *t;
for (std::string incpath : this->IncludeDirectories) {
if (!incpath.empty() && incpath[incpath.size() - 1] != '/') {
incpath = incpath + "/";
}
@@ -442,10 +421,7 @@ protected:
return fp;
}
for (std::vector<std::string>::iterator i =
this->IncludeDirectories.begin();
i != this->IncludeDirectories.end(); ++i) {
std::string path = *i;
for (std::string path : this->IncludeDirectories) {
if (!path.empty() && path[path.size() - 1] != '/') {
path = path + "/";
}
@@ -532,19 +508,17 @@ void cmOutputRequiredFilesCommand::ListDependencies(
// add info to the visited set
visited->insert(info);
// now recurse with info's dependencies
for (cmDependInformation::DependencySetType::const_iterator d =
info->DependencySet.begin();
d != info->DependencySet.end(); ++d) {
if (visited->find(*d) == visited->end()) {
for (cmDependInformation* d : info->DependencySet) {
if (visited->find(d) == visited->end()) {
if (info->FullPath != "") {
std::string tmp = (*d)->FullPath;
std::string tmp = d->FullPath;
std::string::size_type pos = tmp.rfind('.');
if (pos != std::string::npos && (tmp.substr(pos) != ".h")) {
tmp = tmp.substr(0, pos);
fprintf(fout, "%s\n", (*d)->FullPath.c_str());
fprintf(fout, "%s\n", d->FullPath.c_str());
}
}
this->ListDependencies(*d, fout, visited);
this->ListDependencies(d, fout, visited);
}
}
}
Source/cmParseArgumentsCommand.cxx
+37 -49
View File
@@ -5,7 +5,6 @@
#include <map>
#include <set>
#include <sstream>
#include <stddef.h>
#include <utility>
#include "cmAlgorithms.h"
@@ -19,11 +18,11 @@ static std::string escape_arg(const std::string& arg)
{
// replace ";" with "\;" so output argument lists will split correctly
std::string escapedArg;
for (size_t i = 0; i < arg.size(); ++i) {
if (arg[i] == ';') {
for (char i : arg) {
if (i == ';') {
escapedArg += '\\';
}
escapedArg += arg[i];
escapedArg += i;
}
return escapedArg;
}
@@ -85,37 +84,31 @@ bool cmParseArgumentsCommand::InitialPass(std::vector<std::string> const& args,
// the second argument is a (cmake) list of options without argument
std::vector<std::string> list;
cmSystemTools::ExpandListArgument(*argIter++, list);
for (std::vector<std::string>::const_iterator iter = list.begin(),
end = list.end();
iter != end; ++iter) {
if (!used_keywords.insert(*iter).second) {
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
for (std::string const& iter : list) {
if (!used_keywords.insert(iter).second) {
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + iter);
}
options[*iter]; // default initialize
options[iter]; // default initialize
}
// the third argument is a (cmake) list of single argument options
list.clear();
cmSystemTools::ExpandListArgument(*argIter++, list);
for (std::vector<std::string>::const_iterator iter = list.begin(),
end = list.end();
iter != end; ++iter) {
if (!used_keywords.insert(*iter).second) {
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
for (std::string const& iter : list) {
if (!used_keywords.insert(iter).second) {
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + iter);
}
single[*iter]; // default initialize
single[iter]; // default initialize
}
// the fourth argument is a (cmake) list of multi argument options
list.clear();
cmSystemTools::ExpandListArgument(*argIter++, list);
for (std::vector<std::string>::const_iterator iter = list.begin(),
end = list.end();
iter != end; ++iter) {
if (!used_keywords.insert(*iter).second) {
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
for (std::string const& iter : list) {
if (!used_keywords.insert(iter).second) {
this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + iter);
}
multi[*iter]; // default initialize
multi[iter]; // default initialize
}
enum insideValues
@@ -160,46 +153,45 @@ bool cmParseArgumentsCommand::InitialPass(std::vector<std::string> const& args,
}
// iterate over the arguments list and fill in the values where applicable
for (argIter = list.begin(), argEnd = list.end(); argIter != argEnd;
++argIter) {
const options_map::iterator optIter = options.find(*argIter);
for (std::string const& arg : list) {
const options_map::iterator optIter = options.find(arg);
if (optIter != options.end()) {
insideValues = NONE;
optIter->second = true;
continue;
}
const single_map::iterator singleIter = single.find(*argIter);
const single_map::iterator singleIter = single.find(arg);
if (singleIter != single.end()) {
insideValues = SINGLE;
currentArgName = *argIter;
currentArgName = arg;
continue;
}
const multi_map::iterator multiIter = multi.find(*argIter);
const multi_map::iterator multiIter = multi.find(arg);
if (multiIter != multi.end()) {
insideValues = MULTI;
currentArgName = *argIter;
currentArgName = arg;
continue;
}
switch (insideValues) {
case SINGLE:
single[currentArgName] = *argIter;
single[currentArgName] = arg;
insideValues = NONE;
break;
case MULTI:
if (parseFromArgV) {
multi[currentArgName].push_back(escape_arg(*argIter));
multi[currentArgName].push_back(escape_arg(arg));
} else {
multi[currentArgName].push_back(*argIter);
multi[currentArgName].push_back(arg);
}
break;
default:
if (parseFromArgV) {
unparsed.push_back(escape_arg(*argIter));
unparsed.push_back(escape_arg(arg));
} else {
unparsed.push_back(*argIter);
unparsed.push_back(arg);
}
break;
}
@@ -208,28 +200,24 @@ bool cmParseArgumentsCommand::InitialPass(std::vector<std::string> const& args,
// now iterate over the collected values and update their definition
// within the current scope. undefine if necessary.
for (options_map::const_iterator iter = options.begin(), end = options.end();
iter != end; ++iter) {
this->Makefile->AddDefinition(prefix + iter->first,
iter->second ? "TRUE" : "FALSE");
for (auto const& iter : options) {
this->Makefile->AddDefinition(prefix + iter.first,
iter.second ? "TRUE" : "FALSE");
}
for (single_map::const_iterator iter = single.begin(), end = single.end();
iter != end; ++iter) {
if (!iter->second.empty()) {
this->Makefile->AddDefinition(prefix + iter->first,
iter->second.c_str());
for (auto const& iter : single) {
if (!iter.second.empty()) {
this->Makefile->AddDefinition(prefix + iter.first, iter.second.c_str());
} else {
this->Makefile->RemoveDefinition(prefix + iter->first);
this->Makefile->RemoveDefinition(prefix + iter.first);
}
}
for (multi_map::const_iterator iter = multi.begin(), end = multi.end();
iter != end; ++iter) {
if (!iter->second.empty()) {
for (auto const& iter : multi) {
if (!iter.second.empty()) {
this->Makefile->AddDefinition(
prefix + iter->first, cmJoin(cmMakeRange(iter->second), ";").c_str());
prefix + iter.first, cmJoin(cmMakeRange(iter.second), ";").c_str());
} else {
this->Makefile->RemoveDefinition(prefix + iter->first);
this->Makefile->RemoveDefinition(prefix + iter.first);
}
}
Source/cmPathLabel.cxx
+2 -4
View File
@@ -2,15 +2,13 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmPathLabel.h"
#include <stddef.h>
cmPathLabel::cmPathLabel(const std::string& label)
: Label(label)
, Hash(0)
{
// Use a Jenkins one-at-a-time hash with under/over-flow protection
for (size_t i = 0; i < this->Label.size(); ++i) {
this->Hash += this->Label[i];
for (char i : this->Label) {
this->Hash += i;
this->Hash += ((this->Hash & 0x003FFFFF) << 10);
this->Hash ^= ((this->Hash & 0xFFFFFFC0) >> 6);
}
Source/cmPolicies.cxx
+2 -3
View File
@@ -120,9 +120,8 @@ static void DiagnoseAncientPolicies(
e << "The project requests behavior compatible with CMake version \""
<< majorVer << "." << minorVer << "." << patchVer
<< "\", which requires the OLD behavior for some policies:\n";
for (std::vector<cmPolicies::PolicyID>::const_iterator i = ancient.begin();
i != ancient.end(); ++i) {
e << " " << idToString(*i) << ": " << idToShortDescription(*i) << "\n";
for (cmPolicies::PolicyID i : ancient) {
e << " " << idToString(i) << ": " << idToShortDescription(i) << "\n";
}
e << "However, this version of CMake no longer supports the OLD "
<< "behavior for these policies. "

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