summaryrefslogtreecommitdiffstats
path: root/Source
diff options
context:
space:
mode:
Diffstat (limited to 'Source')
-rw-r--r--Source/cmExtraSublimeTextGenerator.cxx2
-rw-r--r--Source/cmGlobalNinjaGenerator.cxx28
-rw-r--r--Source/cmLocalGenerator.cxx19
-rw-r--r--Source/cmLocalGenerator.h1
-rw-r--r--Source/cmLocalNinjaGenerator.cxx2
-rw-r--r--Source/cmLocalNinjaGenerator.h2
-rw-r--r--Source/cmLocalUnixMakefileGenerator3.cxx13
-rw-r--r--Source/cmLocalUnixMakefileGenerator3.h1
-rw-r--r--Source/cmMakefileLibraryTargetGenerator.cxx4
-rw-r--r--Source/cmMakefileTargetGenerator.cxx14
-rw-r--r--Source/cmNinjaTargetGenerator.cxx65
-rw-r--r--Source/cmNinjaTargetGenerator.h8
12 files changed, 100 insertions, 59 deletions
diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx
index 7fe47c3..5fff0fb 100644
--- a/Source/cmExtraSublimeTextGenerator.cxx
+++ b/Source/cmExtraSublimeTextGenerator.cxx
@@ -399,7 +399,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
lg->GetIncludeDirectories(includes, gtgt, language, config);
std::string includeFlags =
lg->GetIncludeFlags(includes, gtgt, language, true); // full include paths
- lg->AppendFlags(flags, includeFlags.c_str());
+ lg->AppendFlags(flags, includeFlags);
}
// Append old-style preprocessor definition flags.
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index 88f1b08..a0caf0e 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -141,7 +141,7 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
cmGlobalNinjaGenerator::WriteComment(os, comment);
- cmOStringStream arguments;
+ std::string arguments;
// TODO: Better formatting for when there are multiple input/output files.
@@ -150,7 +150,7 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
i != explicitDeps.end();
++i)
{
- arguments << " " << EncodeIdent(EncodePath(*i), os);
+ arguments += " " + EncodeIdent(EncodePath(*i), os);
//we need to track every dependency that comes in, since we are trying
//to find dependencies that are side effects of build commands
@@ -161,39 +161,39 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
// Write implicit dependencies.
if(!implicitDeps.empty())
{
- arguments << " |";
+ arguments += " |";
for(cmNinjaDeps::const_iterator i = implicitDeps.begin();
i != implicitDeps.end();
++i)
- arguments << " " << EncodeIdent(EncodePath(*i), os);
+ arguments += " " + EncodeIdent(EncodePath(*i), os);
}
// Write order-only dependencies.
if(!orderOnlyDeps.empty())
{
- arguments << " ||";
+ arguments += " ||";
for(cmNinjaDeps::const_iterator i = orderOnlyDeps.begin();
i != orderOnlyDeps.end();
++i)
- arguments << " " << EncodeIdent(EncodePath(*i), os);
+ arguments += " " + EncodeIdent(EncodePath(*i), os);
}
- arguments << "\n";
+ arguments += "\n";
- cmOStringStream build;
+ std::string build;
// Write outputs files.
- build << "build";
+ build += "build";
for(cmNinjaDeps::const_iterator i = outputs.begin();
i != outputs.end(); ++i)
{
- build << " " << EncodeIdent(EncodePath(*i), os);
+ build += " " + EncodeIdent(EncodePath(*i), os);
this->CombinedBuildOutputs.insert( EncodePath(*i) );
}
- build << ":";
+ build += ":";
// Write the rule.
- build << " " << rule;
+ build += " " + rule;
// Write the variables bound to this build statement.
cmOStringStream variable_assignments;
@@ -203,9 +203,9 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
i->first, i->second, "", 1);
// check if a response file rule should be used
- std::string buildstr = build.str();
+ std::string buildstr = build;
std::string assignments = variable_assignments.str();
- const std::string args = arguments.str();
+ const std::string& args = arguments;
if (cmdLineLimit > 0
&& args.size() + buildstr.size() + assignments.size()
> (size_t) cmdLineLimit) {
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index c4c6428..209900f 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -2214,7 +2214,7 @@ static void AddVisibilityCompileOption(std::string &flags, cmTarget* target,
return;
}
std::string option = std::string(opt) + prop;
- lg->AppendFlags(flags, option.c_str());
+ lg->AppendFlags(flags, option);
}
static void AddInlineVisibilityCompileOption(std::string &flags,
@@ -2398,11 +2398,10 @@ void cmLocalGenerator::AddConfigVariableFlags(std::string& flags,
//----------------------------------------------------------------------------
void cmLocalGenerator::AppendFlags(std::string& flags,
- const char* newFlags)
+ const std::string& newFlags)
{
- if(newFlags && *newFlags)
+ if(!newFlags.empty())
{
- std::string newf = newFlags;
if(flags.size())
{
flags += " ";
@@ -2412,10 +2411,20 @@ void cmLocalGenerator::AppendFlags(std::string& flags,
}
//----------------------------------------------------------------------------
+void cmLocalGenerator::AppendFlags(std::string& flags,
+ const char* newFlags)
+{
+ if(newFlags && *newFlags)
+ {
+ this->AppendFlags(flags, std::string(newFlags));
+ }
+}
+
+//----------------------------------------------------------------------------
void cmLocalGenerator::AppendFlagEscape(std::string& flags,
const std::string& rawFlag)
{
- this->AppendFlags(flags, this->EscapeForShell(rawFlag).c_str());
+ this->AppendFlags(flags, this->EscapeForShell(rawFlag));
}
//----------------------------------------------------------------------------
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index cf754aa..32da21b 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -152,6 +152,7 @@ public:
void AddCompilerRequirementFlag(std::string &flags, cmTarget* target,
const std::string& lang);
///! Append flags to a string.
+ virtual void AppendFlags(std::string& flags, const std::string& newFlags);
virtual void AppendFlags(std::string& flags, const char* newFlags);
virtual void AppendFlagEscape(std::string& flags,
const std::string& rawFlag);
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 2f763ce..2ac8363 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -294,7 +294,7 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
os << std::endl;
}
-std::string cmLocalNinjaGenerator::ConvertToNinjaPath(const char *path)
+std::string cmLocalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
{
std::string convPath = this->Convert(path, cmLocalGenerator::HOME_OUTPUT);
#ifdef _WIN32
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index e91e60b..11321b8 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -67,7 +67,7 @@ public:
std::string GetHomeRelativeOutputPath() const
{ return this->HomeRelativeOutputPath; }
- std::string ConvertToNinjaPath(const char *path);
+ std::string ConvertToNinjaPath(const std::string& path);
struct map_to_ninja_path {
cmLocalNinjaGenerator *LocalGenerator;
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 7ffe84d..94e45e5 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -956,15 +956,15 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
- const char* newFlags)
+ const std::string& newFlags)
{
- if(this->WatcomWMake && newFlags && *newFlags)
+ if(this->WatcomWMake && !newFlags.empty())
{
std::string newf = newFlags;
if(newf.find("\\\"") != newf.npos)
{
cmSystemTools::ReplaceString(newf, "\\\"", "\"");
- this->cmLocalGenerator::AppendFlags(flags, newf.c_str());
+ this->cmLocalGenerator::AppendFlags(flags, newf);
return;
}
}
@@ -972,6 +972,13 @@ void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
}
//----------------------------------------------------------------------------
+void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
+ const char* newFlags)
+{
+ this->cmLocalGenerator::AppendFlags(flags, newFlags);
+}
+
+//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::AppendRuleDepend(std::vector<std::string>& depends,
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index 99974ee..4f2e4a0 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -168,6 +168,7 @@ public:
const std::string& tgt);
// append flags to a string
+ virtual void AppendFlags(std::string& flags, const std::string& newFlags);
virtual void AppendFlags(std::string& flags, const char* newFlags);
// append an echo command
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 7ac0256..80473f6 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -249,7 +249,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
// Create set of linking flags.
std::string linkFlags;
- this->LocalGenerator->AppendFlags(linkFlags, extraFlags.c_str());
+ this->LocalGenerator->AppendFlags(linkFlags, extraFlags);
// Add OSX version flags, if any.
if(this->Target->GetType() == cmTarget::SHARED_LIBRARY ||
@@ -810,6 +810,6 @@ cmMakefileLibraryTargetGenerator
// Append the flag since a non-zero version is specified.
cmOStringStream vflag;
vflag << flag << major << "." << minor << "." << patch;
- this->LocalGenerator->AppendFlags(flags, vflag.str().c_str());
+ this->LocalGenerator->AppendFlags(flags, vflag.str());
}
}
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index d4723ad..73d24a9 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -303,7 +303,7 @@ std::string cmMakefileTargetGenerator::GetFlags(const std::string &l)
// Add include directory flags.
this->LocalGenerator->
- AppendFlags(flags,this->GetFrameworkFlags(l).c_str());
+ AppendFlags(flags,this->GetFrameworkFlags(l));
// Add target-specific flags.
this->LocalGenerator->AddCompileOptions(flags, this->Target,
@@ -551,7 +551,7 @@ cmMakefileTargetGenerator
std::string langFlags = "$(";
langFlags += lang;
langFlags += "_FLAGS)";
- this->LocalGenerator->AppendFlags(flags, langFlags.c_str());
+ this->LocalGenerator->AppendFlags(flags, langFlags);
std::string configUpper =
cmSystemTools::UpperCase(this->LocalGenerator->ConfigurationName);
@@ -1968,11 +1968,11 @@ void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
std::string arg = "@" +
this->CreateResponseFile(name.c_str(), includeFlags,
this->FlagFileDepends[lang]);
- this->LocalGenerator->AppendFlags(flags, arg.c_str());
+ this->LocalGenerator->AppendFlags(flags, arg);
}
else
{
- this->LocalGenerator->AppendFlags(flags, includeFlags.c_str());
+ this->LocalGenerator->AppendFlags(flags, includeFlags);
}
}
@@ -2044,7 +2044,7 @@ void cmMakefileTargetGenerator::AddFortranFlags(std::string& flags)
modflag += this->Convert(mod_dir,
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::SHELL);
- this->LocalGenerator->AppendFlags(flags, modflag.c_str());
+ this->LocalGenerator->AppendFlags(flags, modflag);
}
// If there is a separate module path flag then duplicate the
@@ -2066,7 +2066,7 @@ void cmMakefileTargetGenerator::AddFortranFlags(std::string& flags)
flg += this->Convert(*idi,
cmLocalGenerator::NONE,
cmLocalGenerator::SHELL);
- this->LocalGenerator->AppendFlags(flags, flg.c_str());
+ this->LocalGenerator->AppendFlags(flags, flg);
}
}
}
@@ -2093,7 +2093,7 @@ void cmMakefileTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
// vs6's "cl -link" pass it to the linker.
std::string flag = defFileFlag;
flag += (this->LocalGenerator->ConvertToLinkReference(def));
- this->LocalGenerator->AppendFlags(flags, flag.c_str());
+ this->LocalGenerator->AppendFlags(flags, flag);
}
//----------------------------------------------------------------------------
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index cb6eb90..292a22f 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -121,6 +121,12 @@ void cmNinjaTargetGenerator::AddFeatureFlags(std::string& flags,
}
}
+std::string
+cmNinjaTargetGenerator::OrderDependsTargetForTarget()
+{
+ return "cmake_order_depends_target_" + this->GetTargetName();
+}
+
// TODO: Most of the code is picked up from
// void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink),
// void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
@@ -169,7 +175,7 @@ cmNinjaTargetGenerator::ComputeFlagsForObject(cmSourceFile const* source,
if(cmGlobalNinjaGenerator::IsMinGW())
cmSystemTools::ReplaceString(includeFlags, "\\", "/");
- this->LocalGenerator->AppendFlags(languageFlags, includeFlags.c_str());
+ this->LocalGenerator->AppendFlags(languageFlags, includeFlags);
// Append old-style preprocessor definition flags.
this->LocalGenerator->AppendFlags(languageFlags,
@@ -496,7 +502,7 @@ cmNinjaTargetGenerator
this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget());
// Record the custom commands for this target. The container is used
// in WriteObjectBuildStatement when called in a loop below.
- this->CustomCommands.push_back((*si)->GetCustomCommand());
+ this->CustomCommands.push_back(cc);
}
std::vector<cmSourceFile const*> headerSources;
this->GeneratorTarget->GetHeaderSources(headerSources, config);
@@ -516,6 +522,33 @@ cmNinjaTargetGenerator
{
this->Objects.push_back(this->GetSourceFilePath(*si));
}
+
+ cmNinjaDeps orderOnlyDeps;
+ this->GetLocalGenerator()->AppendTargetDepends(this->Target, orderOnlyDeps);
+
+ // 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;
+ cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
+ this->GetMakefile());
+ const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
+ std::transform(ccoutputs.begin(), ccoutputs.end(),
+ std::back_inserter(orderOnlyDeps), MapToNinjaPath());
+ }
+
+ cmNinjaDeps orderOnlyTarget;
+ orderOnlyTarget.push_back(this->OrderDependsTargetForTarget());
+ this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
+ "Order-only phony target for "
+ + this->GetTargetName(),
+ orderOnlyTarget,
+ cmNinjaDeps(),
+ cmNinjaDeps(),
+ orderOnlyDeps);
+
std::vector<cmSourceFile const*> objectSources;
this->GeneratorTarget->GetObjectSources(objectSources, config);
for(std::vector<cmSourceFile const*>::const_iterator
@@ -554,11 +587,6 @@ cmNinjaTargetGenerator
sourceFileName = this->GetSourceFilePath(source);
explicitDeps.push_back(sourceFileName);
- // Ensure that the target dependencies are built before any source file in
- // the target, using order-only dependencies.
- cmNinjaDeps orderOnlyDeps;
- this->GetLocalGenerator()->AppendTargetDepends(this->Target, orderOnlyDeps);
-
cmNinjaDeps implicitDeps;
if(const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
std::vector<std::string> depList;
@@ -567,18 +595,8 @@ cmNinjaTargetGenerator
std::back_inserter(implicitDeps), MapToNinjaPath());
}
- // 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;
- cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
- this->GetMakefile());
- const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
- std::transform(ccoutputs.begin(), ccoutputs.end(),
- std::back_inserter(orderOnlyDeps), MapToNinjaPath());
- }
+ cmNinjaDeps orderOnlyDeps;
+ orderOnlyDeps.push_back(this->OrderDependsTargetForTarget());
// If the source file is GENERATED and does not have a custom command
// (either attached to this source file or another one), assume that one of
@@ -698,7 +716,7 @@ cmNinjaTargetGenerator
std::string flag = defFileFlag;
flag += (this->LocalGenerator->ConvertToLinkReference(
this->ModuleDefinitionFile));
- this->LocalGenerator->AppendFlags(flags, flag.c_str());
+ this->LocalGenerator->AppendFlags(flags, flag);
}
void
@@ -760,9 +778,10 @@ cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
this->Generator->GetGlobalGenerator()->AddDependencyToAll(output);
}
-void cmNinjaTargetGenerator::addPoolNinjaVariable(const char* pool_property,
- cmTarget* target,
- cmNinjaVars& vars)
+void cmNinjaTargetGenerator::addPoolNinjaVariable(
+ const std::string& pool_property,
+ cmTarget* target,
+ cmNinjaVars& vars)
{
const char* pool = target->GetProperty(pool_property);
if (pool)
diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h
index 8073af2..94c420f 100644
--- a/Source/cmNinjaTargetGenerator.h
+++ b/Source/cmNinjaTargetGenerator.h
@@ -74,6 +74,10 @@ protected:
bool GetFeatureAsBool(const std::string& feature);
void AddFeatureFlags(std::string& flags, const std::string& lang);
+ std::string OrderDependsTargetForTarget();
+
+ std::string ComputeOrderDependsForTarget();
+
/**
* Compute the flags for compilation of object files for a given @a language.
* @note Generally it is the value of the variable whose name is computed
@@ -85,7 +89,7 @@ protected:
std::string ComputeDefines(cmSourceFile const* source,
const std::string& language);
- std::string ConvertToNinjaPath(const char *path) const {
+ std::string ConvertToNinjaPath(const std::string& path) const {
return this->GetLocalGenerator()->ConvertToNinjaPath(path);
}
cmLocalNinjaGenerator::map_to_ninja_path MapToNinjaPath() const {
@@ -142,7 +146,7 @@ protected:
cmOSXBundleGenerator* OSXBundleGenerator;
std::set<std::string> MacContentFolders;
- void addPoolNinjaVariable(const char* pool_property,
+ void addPoolNinjaVariable(const std::string& pool_property,
cmTarget* target,
cmNinjaVars& vars);
generated by cgit v0.12 at 2024-11-08 09:43:53 (GMT)