kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'genex-generator-objects' 

2293d43d cmLocalGenerator: Store cmGeneratorTargets.
488723f5 cmMakefile: Store container of cmExportBuildFileGenerators.
15834405 cmGeneratorExpression: Port interface to cmGeneratorTarget.
11165525 cmGeneratorExpression: Port to cmLocalGenerator.
This commit is contained in:
Brad King 2015-10-14 13:35:59 -04:00 committed by CMake Topic Stage
parent ff6ae3ecfc 2293d43d00
commit ad3ff60f4a
42 changed files with 281 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/cmCPackPropertiesGenerator.cxx
View File

@ -18,7 +18,7 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os,
const std::string& config, Indent const& indent)
{
std::string const& expandedFileName =
this->InstalledFile.GetNameExpression().Evaluate(this->LG->GetMakefile(),
this->InstalledFile.GetNameExpression().Evaluate(this->LG,
config);
cmInstalledFile::PropertyMapType const& properties =
@ -38,7 +38,7 @@ void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os,
j = property.ValueExpressions.begin();
j != property.ValueExpressions.end(); ++j)
{
std::string value = (*j)->Evaluate(LG->GetMakefile(), config);
std::string value = (*j)->Evaluate(this->LG, config);
os << " " << cmOutputConverter::EscapeForCMake(value);
}

9
Source/cmCustomCommandGenerator.cxx
View File

@ -43,15 +43,14 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
{
std::string const& argv0 = this->CC.GetCommandLines()[c][0];
cmGeneratorTarget* target =
this->LG->GetMakefile()->FindGeneratorTargetToUse(argv0);
this->LG->FindGeneratorTargetToUse(argv0);
if(target && target->GetType() == cmTarget::EXECUTABLE &&
(target->Target->IsImported()
|| !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING")))
{
return target->GetLocation(this->Config);
}
return this->GE->Parse(argv0)->Evaluate(this->LG->GetMakefile(),
this->Config);
return this->GE->Parse(argv0)->Evaluate(this->LG, this->Config);
}
//----------------------------------------------------------------------------
@ -92,7 +91,7 @@ cmCustomCommandGenerator
for(unsigned int j=1;j < commandLine.size(); ++j)
{
std::string arg =
this->GE->Parse(commandLine[j])->Evaluate(this->LG->GetMakefile(),
this->GE->Parse(commandLine[j])->Evaluate(this->LG,
this->Config);
cmd += " ";
if(this->OldStyle)
@ -146,7 +145,7 @@ std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const
= this->GE->Parse(*i);
std::vector<std::string> result;
cmSystemTools::ExpandListArgument(
cge->Evaluate(this->LG->GetMakefile(), this->Config), result);
cge->Evaluate(this->LG, this->Config), result);
for (std::vector<std::string>::iterator it = result.begin();
it != result.end(); ++it)
{

21
Source/cmExportBuildFileGenerator.cxx
View File

@ -18,12 +18,17 @@
//----------------------------------------------------------------------------
cmExportBuildFileGenerator::cmExportBuildFileGenerator()
: Backtrace()
{
this->Makefile = 0;
this->LG = 0;
this->ExportSet = 0;
}
//----------------------------------------------------------------------------
void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
{
this->LG = lg;
}
//----------------------------------------------------------------------------
bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
{
@ -37,7 +42,7 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
tei = targets.begin();
tei != targets.end(); ++tei)
{
cmGeneratorTarget *te = this->Makefile
cmGeneratorTarget *te = this->LG
->FindGeneratorTargetToUse(*tei);
expectedTargets += sep + this->Namespace + te->Target->GetExportName();
sep = " ";
@ -49,8 +54,9 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
{
std::ostringstream e;
e << "given target \"" << te->GetName() << "\" more than once.";
this->Makefile->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace);
this->LG->GetGlobalGenerator()->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->LG->GetMakefile()->GetBacktrace());
return false;
}
if (te->GetType() == cmTarget::INTERFACE_LIBRARY)
@ -328,8 +334,9 @@ cmExportBuildFileGenerator
e << "If the required target is not easy to reference in this call, "
<< "consider using the APPEND option with multiple separate calls.";
this->Makefile->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace);
this->LG->GetGlobalGenerator()->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->LG->GetMakefile()->GetBacktrace());
}
std::string

8
Source/cmExportBuildFileGenerator.h
View File

@ -43,10 +43,7 @@ public:
/** Set whether to append generated code to the output file. */
void SetAppendMode(bool append) { this->AppendMode = append; }
void SetMakefile(cmMakefile *mf) {
this->Makefile = mf;
this->Backtrace = this->Makefile->GetBacktrace();
}
void Compute(cmLocalGenerator* lg);
protected:
// Implement virtual methods from the superclass.
@ -80,8 +77,7 @@ protected:
std::vector<std::string> Targets;
cmExportSet *ExportSet;
std::vector<cmGeneratorTarget*> Exports;
cmMakefile* Makefile;
cmListFileBacktrace Backtrace;
cmLocalGenerator* LG;
};
#endif

2
Source/cmExportCommand.cxx
View File

@ -221,7 +221,7 @@ bool cmExportCommand
{
ebfg->SetTargets(targets);
}
ebfg->SetMakefile(this->Makefile);
this->Makefile->AddExportBuildFileGenerator(ebfg);
ebfg->SetExportOld(this->ExportOld.IsEnabled());
// Compute the set of configurations exported.

4
Source/cmExportFileGenerator.cxx
View File

@ -456,8 +456,8 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
true);
this->ReplaceInstallPrefix(dirs);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
std::string exportDirs = cge->Evaluate(target->Target->GetMakefile(), "",
false, target->Target);
std::string exportDirs = cge->Evaluate(target->GetLocalGenerator(), "",
false, target);
if (cge->GetHadContextSensitiveCondition())
{

7
Source/cmExportTryCompileFileGenerator.cxx
View File

@ -78,10 +78,11 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
cmGeneratorTarget* gtgt =
tgt->GetMakefile()->GetGlobalGenerator()->GetGeneratorTarget(tgt);
cmGeneratorTarget gDummyHead(&dummyHead, gtgt->GetLocalGenerator());
std::string result = cge->Evaluate(gtgt->Target->GetMakefile(), this->Config,
false, &dummyHead,
gtgt->Target, &dagChecker);
std::string result = cge->Evaluate(gtgt->GetLocalGenerator(), this->Config,
false, &gDummyHead,
gtgt, &dagChecker);
const std::set<cmTarget const*> &allTargets = cge->GetAllTargetsSeen();
for(std::set<cmTarget const*>::const_iterator li = allTargets.begin();

3
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -965,8 +965,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
it != this->GlobalGenerator->GetLocalGenerators().end();
++it)
{
cmGeneratorTargetsType targets = (*it)->GetMakefile()
->GetGeneratorTargets();
cmGeneratorTargetsType targets = (*it)->GetGeneratorTargets();
for (cmGeneratorTargetsType::iterator l = targets.begin();
l != targets.end(); ++l)
{

16
Source/cmGeneratorExpression.cxx
View File

@ -48,13 +48,13 @@ cmGeneratorExpression::~cmGeneratorExpression()
}
//----------------------------------------------------------------------------
const char *cmCompiledGeneratorExpression::Evaluate(
cmMakefile* mf, const std::string& config, bool quiet,
cmTarget const* headTarget,
const char *cmCompiledGeneratorExpression::Evaluate(cmLocalGenerator* lg,
const std::string& config, bool quiet,
const cmGeneratorTarget* headTarget,
cmGeneratorExpressionDAGChecker *dagChecker,
std::string const& language) const
{
return this->Evaluate(mf,
return this->Evaluate(lg,
config,
quiet,
headTarget,
@ -65,13 +65,13 @@ const char *cmCompiledGeneratorExpression::Evaluate(
//----------------------------------------------------------------------------
const char *cmCompiledGeneratorExpression::Evaluate(
cmMakefile* mf, const std::string& config, bool quiet,
cmTarget const* headTarget,
cmTarget const* currentTarget,
cmLocalGenerator* lg, const std::string& config, bool quiet,
const cmGeneratorTarget* headTarget,
const cmGeneratorTarget* currentTarget,
cmGeneratorExpressionDAGChecker *dagChecker,
std::string const& language) const
{
cmGeneratorExpressionContext context(mf, config, quiet, headTarget,
cmGeneratorExpressionContext context(lg, config, quiet, headTarget,
currentTarget ? currentTarget : headTarget,
this->EvaluateForBuildsystem,
this->Backtrace, language);

13
Source/cmGeneratorExpression.h
View File

@ -20,7 +20,8 @@
#include <cmsys/auto_ptr.hxx>
class cmTarget;
class cmMakefile;
class cmGeneratorTarget;
class cmLocalGenerator;
class cmListFileBacktrace;
struct cmGeneratorExpressionEvaluator;
@ -78,15 +79,15 @@ private:
class cmCompiledGeneratorExpression
{
public:
const char* Evaluate(cmMakefile* mf, const std::string& config,
const char* Evaluate(cmLocalGenerator* lg, const std::string& config,
bool quiet = false,
cmTarget const* headTarget = 0,
cmTarget const* currentTarget = 0,
cmGeneratorTarget const* headTarget = 0,
cmGeneratorTarget const* currentTarget = 0,
cmGeneratorExpressionDAGChecker *dagChecker = 0,
std::string const& language = std::string()) const;
const char* Evaluate(cmMakefile* mf, const std::string& config,
const char* Evaluate(cmLocalGenerator* lg, const std::string& config,
bool quiet,
cmTarget const* headTarget,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker *dagChecker,
std::string const& language = std::string()) const;

13
Source/cmGeneratorExpressionContext.cxx
View File

@ -11,20 +11,21 @@
============================================================================*/
#include "cmGeneratorExpressionContext.h"
#include "cmGeneratorTarget.h"
cmGeneratorExpressionContext::cmGeneratorExpressionContext(
cmMakefile* mf, std::string const& config,
bool quiet, cmTarget const* headTarget,
cmTarget const* currentTarget,
cmLocalGenerator* lg, std::string const& config,
bool quiet, cmGeneratorTarget const* headTarget,
const cmGeneratorTarget* currentTarget,
bool evaluateForBuildsystem,
cmListFileBacktrace const& backtrace,
std::string const& language)
: Backtrace(backtrace),
Makefile(mf),
LG(lg),
Config(config),
Language(language),
HeadTarget(headTarget),
CurrentTarget(currentTarget),
HeadTarget(headTarget ? headTarget->Target : 0),
CurrentTarget(currentTarget ? currentTarget->Target : 0),
Quiet(quiet),
HadError(false),
HadContextSensitiveCondition(false),

10
Source/cmGeneratorExpressionContext.h
View File

@ -19,13 +19,15 @@
#include <string>
class cmTarget;
class cmGeneratorTarget;
class cmLocalGenerator;
//----------------------------------------------------------------------------
struct cmGeneratorExpressionContext
{
cmGeneratorExpressionContext(cmMakefile* mf, std::string const& config,
bool quiet, cmTarget const* headTarget,
cmTarget const* currentTarget,
cmGeneratorExpressionContext(cmLocalGenerator* lg, std::string const& config,
bool quiet, const cmGeneratorTarget* headTarget,
cmGeneratorTarget const* currentTarget,
bool evaluateForBuildsystem,
cmListFileBacktrace const& backtrace,
std::string const& language);
@ -38,7 +40,7 @@ struct cmGeneratorExpressionContext
std::set<cmTarget const*> SourceSensitiveTargets;
std::map<cmTarget const*, std::map<std::string, std::string> >
MaxLanguageStandard;
cmMakefile *Makefile;
cmLocalGenerator *LG;
std::string Config;
std::string Language;
cmTarget const* HeadTarget; // The target whose property is being evaluated.

7
Source/cmGeneratorExpressionDAGChecker.cxx
View File

@ -13,6 +13,7 @@
#include "cmGeneratorExpressionDAGChecker.h"
#include "cmMakefile.h"
#include "cmLocalGenerator.h"
#include "cmAlgorithms.h"
//----------------------------------------------------------------------------
@ -110,7 +111,7 @@ void cmGeneratorExpressionDAGChecker::ReportError(
<< " " << expr << "\n"
<< "Self reference on target \""
<< context->HeadTarget->GetName() << "\".\n";
context->Makefile->GetCMakeInstance()
context->LG->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(),
parent->Backtrace);
return;
@ -121,7 +122,7 @@ void cmGeneratorExpressionDAGChecker::ReportError(
e << "Error evaluating generator expression:\n"
<< " " << expr << "\n"
<< "Dependency loop found.";
context->Makefile->GetCMakeInstance()
context->LG->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(),
context->Backtrace);
}
@ -134,7 +135,7 @@ void cmGeneratorExpressionDAGChecker::ReportError(
<< " "
<< (parent->Content ? parent->Content->GetOriginalExpression() : expr)
<< "\n";
context->Makefile->GetCMakeInstance()
context->LG->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(),
parent->Backtrace);
parent = parent->Parent;

8
Source/cmGeneratorExpressionEvaluationFile.cxx
View File

@ -44,7 +44,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg,
std::string rawCondition = this->Condition->GetInput();
if (!rawCondition.empty())
{
std::string condResult = this->Condition->Evaluate(lg->GetMakefile(),
std::string condResult = this->Condition->Evaluate(lg,
config,
false, 0, 0, 0, lang);
if (condResult == "0")
@ -62,10 +62,10 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg,
}
const std::string outputFileName
= this->OutputFileExpr->Evaluate(lg->GetMakefile(), config,
= this->OutputFileExpr->Evaluate(lg, config,
false, 0, 0, 0, lang);
const std::string outputContent
= inputExpression->Evaluate(lg->GetMakefile(),
= inputExpression->Evaluate(lg,
config,
false, 0, 0, 0, lang);
@ -110,7 +110,7 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
for(std::vector<std::string>::const_iterator le = enabledLanguages.begin();
le != enabledLanguages.end(); ++le)
{
std::string name = this->OutputFileExpr->Evaluate(lg->GetMakefile(),
std::string name = this->OutputFileExpr->Evaluate(lg,
config,
false, 0, 0, 0, *le);
cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name);

68
Source/cmGeneratorExpressionNode.cxx
View File

@ -17,15 +17,16 @@
//----------------------------------------------------------------------------
std::string cmGeneratorExpressionNode::EvaluateDependentExpression(
std::string const& prop, cmMakefile *makefile,
std::string const& prop, cmLocalGenerator *lg,
cmGeneratorExpressionContext *context,
cmTarget const* headTarget, cmTarget const* currentTarget,
cmGeneratorTarget const* headTarget,
cmGeneratorTarget const* currentTarget,
cmGeneratorExpressionDAGChecker *dagChecker)
{
cmGeneratorExpression ge(context->Backtrace);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem);
std::string result = cge->Evaluate(makefile,
std::string result = cge->Evaluate(lg,
context->Config,
context->Quiet,
headTarget,
@ -367,7 +368,8 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
const std::string &lang) const
{
const char *compilerId =
context->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID");
context->LG->GetMakefile()
->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID");
if (parameters.empty())
{
return compilerId ? compilerId : "";
@ -391,13 +393,13 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0)
{
switch(context->Makefile->GetPolicyStatus(cmPolicies::CMP0044))
switch(context->LG->GetMakefile()->GetPolicyStatus(cmPolicies::CMP0044))
{
case cmPolicies::WARN:
{
std::ostringstream e;
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0044);
context->Makefile->GetCMakeInstance()
context->LG->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING,
e.str(), context->Backtrace);
}
@ -470,7 +472,8 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode
cmGeneratorExpressionDAGChecker *,
const std::string &lang) const
{
const char *compilerVersion = context->Makefile->GetSafeDefinition(
const char *compilerVersion =
context->LG->GetMakefile()->GetSafeDefinition(
"CMAKE_" + lang + "_COMPILER_VERSION");
if (parameters.empty())
{
@ -553,7 +556,7 @@ struct PlatformIdNode : public cmGeneratorExpressionNode
cmGeneratorExpressionDAGChecker *) const
{
const char *platformId =
context->Makefile->GetSafeDefinition("CMAKE_SYSTEM_NAME");
context->LG->GetMakefile()->GetSafeDefinition("CMAKE_SYSTEM_NAME");
if (parameters.empty())
{
return platformId ? platformId : "";
@ -768,7 +771,7 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode
}
std::vector<std::string> enabledLanguages;
cmGlobalGenerator* gg = context->Makefile->GetGlobalGenerator();
cmGlobalGenerator* gg = context->LG->GetGlobalGenerator();
gg->GetEnabledLanguages(enabledLanguages);
if (!parameters.empty() &&
std::find(enabledLanguages.begin(), enabledLanguages.end(),
@ -858,10 +861,10 @@ getLinkedTargetsContent(
{
linkedTargetsContent =
cmGeneratorExpressionNode::EvaluateDependentExpression(depString,
target->Target->GetMakefile(),
target->GetLocalGenerator(),
context,
headTarget->Target,
target->Target, dagChecker);
headTarget,
target, dagChecker);
}
linkedTargetsContent =
cmGeneratorExpression::StripEmptyListElements(linkedTargetsContent);
@ -940,16 +943,17 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
}
if(propertyName == "ALIASED_TARGET")
{
if(context->Makefile->IsAlias(targetName))
if(context->LG->GetMakefile()->IsAlias(targetName))
{
if(cmTarget* tgt = context->Makefile->FindTargetToUse(targetName))
if(cmTarget* tgt =
context->LG->GetMakefile()->FindTargetToUse(targetName))
{
return tgt->GetName();
}
}
return "";
}
target = context->Makefile->FindTargetToUse(targetName);
target = context->LG->GetMakefile()->FindTargetToUse(targetName);
if (!target)
{
@ -994,7 +998,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
assert(target);
cmGeneratorTarget* gtgt =
context->Makefile->GetGlobalGenerator()->GetGeneratorTarget(target);
context->LG->GetGlobalGenerator()->GetGeneratorTarget(target);
if (propertyName == "LINKER_LANGUAGE")
{
@ -1099,7 +1103,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
"COMPILE_DEFINITIONS_"))
{
cmPolicies::PolicyStatus polSt =
context->Makefile->GetPolicyStatus(cmPolicies::CMP0043);
context->LG->GetMakefile()->GetPolicyStatus(cmPolicies::CMP0043);
if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
{
interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS";
@ -1112,7 +1116,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
if(isInterfaceProperty)
{
cmGeneratorTarget* gHeadTarget =
context->Makefile->GetGlobalGenerator()
context->LG->GetGlobalGenerator()
->GetGeneratorTarget(headTarget);
if(cmLinkInterfaceLibraries const* iface =
gtgt->GetLinkInterfaceLibraries(context->Config, gHeadTarget, true))
@ -1212,9 +1216,11 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
}
if(!interfacePropertyName.empty())
{
cmGeneratorTarget* gHeadTarget =
context->LG->GetGlobalGenerator()->GetGeneratorTarget(headTarget);
std::string result = this->EvaluateDependentExpression(prop,
context->Makefile, context,
headTarget, target, &dagChecker);
context->LG, context,
gHeadTarget, gtgt, &dagChecker);
if (!linkedTargetsContent.empty())
{
result += (result.empty() ? "" : ";") + linkedTargetsContent;
@ -1269,7 +1275,7 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode
std::string tgtName = parameters.front();
cmGeneratorTarget* gt =
context->Makefile->FindGeneratorTargetToUse(tgtName);
context->LG->FindGeneratorTargetToUse(tgtName);
if (!gt)
{
std::ostringstream e;
@ -1312,7 +1318,8 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode
assert(!map_it->second.empty());
result += sep;
std::string objFile = obj_dir + map_it->second;
cmSourceFile* sf = context->Makefile->GetOrCreateSource(objFile, true);
cmSourceFile* sf =
context->LG->GetMakefile()->GetOrCreateSource(objFile, true);
sf->SetObjectLibrary(tgtName);
sf->SetProperty("EXTERNAL_OBJECT", "1");
result += objFile;
@ -1354,7 +1361,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
{
std::string error;
std::string lang;
if (!context->Makefile->CompileFeatureKnown(context->HeadTarget,
if (!context->LG->GetMakefile()->CompileFeatureKnown(context->HeadTarget,
*it, lang, &error))
{
reportError(context, content->GetOriginalExpression(), error);
@ -1365,7 +1372,8 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
if (availableFeatures.find(lang) == availableFeatures.end())
{
const char* featuresKnown
= context->Makefile->CompileFeaturesAvailable(lang, &error);
= context->LG->GetMakefile()->CompileFeaturesAvailable(lang,
&error);
if (!featuresKnown)
{
reportError(context, content->GetOriginalExpression(), error);
@ -1383,7 +1391,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
{
std::vector<std::string> const& langAvailable
= availableFeatures[lit->first];
const char* standardDefault = context->Makefile
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)
@ -1399,7 +1407,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
// All features known for the language are always available.
continue;
}
if (!context->Makefile->HaveStandardAvailable(target,
if (!context->LG->GetMakefile()->HaveStandardAvailable(target,
lit->first, *it))
{
if (evalLL)
@ -1617,7 +1625,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag>
std::string pdbSupportVar = "CMAKE_" + language + "_LINKER_SUPPORTS_PDB";
if(!context->Makefile->IsOn(pdbSupportVar))
if(!context->LG->GetMakefile()->IsOn(pdbSupportVar))
{
::reportError(context, content->GetOriginalExpression(),
"TARGET_PDB_FILE is not supported by the target linker.");
@ -1731,7 +1739,7 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode
return std::string();
}
cmGeneratorTarget* target =
context->Makefile->FindGeneratorTargetToUse(name);
context->LG->FindGeneratorTargetToUse(name);
if(!target)
{
::reportError(context, content->GetOriginalExpression(),
@ -1813,7 +1821,7 @@ static const struct ShellPathNode : public cmGeneratorExpressionNode
"\"" + parameters.front() + "\" is not an absolute path.");
return std::string();
}
cmOutputConverter converter(context->Makefile->GetStateSnapshot());
cmOutputConverter converter(context->LG->GetStateSnapshot());
return converter.ConvertDirectorySeparatorsForShell(parameters.front());
}
} shellPathNode;
@ -1897,7 +1905,7 @@ void reportError(cmGeneratorExpressionContext *context,
e << "Error evaluating generator expression:\n"
<< " " << expr << "\n"
<< result;
context->Makefile->GetCMakeInstance()
context->LG->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e.str(),
context->Backtrace);
}

5
Source/cmGeneratorExpressionNode.h
View File

@ -54,9 +54,10 @@ struct cmGeneratorExpressionNode
) const = 0;
static std::string EvaluateDependentExpression(
std::string const& prop, cmMakefile *makefile,
std::string const& prop, cmLocalGenerator *lg,
cmGeneratorExpressionContext *context,
cmTarget const* headTarget, cmTarget const* currentTarget,
const cmGeneratorTarget* headTarget,
const cmGeneratorTarget* currentTarget,
cmGeneratorExpressionDAGChecker *dagChecker);
static const cmGeneratorExpressionNode* GetNode(

64
Source/cmGeneratorTarget.cxx
View File

@ -453,7 +453,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config,
// Now evaluate genex and update the previously-prepared map entry.
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName);
i->second = cge->Evaluate(this->Makefile, config);
i->second = cge->Evaluate(this->LocalGenerator, config);
}
else if(i->second.empty())
{
@ -510,7 +510,7 @@ cmGeneratorTarget::GetSourceDepends(cmSourceFile const* sf) const
return 0;
}
static void handleSystemIncludesDep(cmMakefile *mf,
static void handleSystemIncludesDep(cmLocalGenerator *lg,
cmGeneratorTarget const* depTgt,
const std::string& config,
cmGeneratorTarget const* headTarget,
@ -523,9 +523,9 @@ static void handleSystemIncludesDep(cmMakefile *mf,
{
cmGeneratorExpression ge;
cmSystemTools::ExpandListArgument(ge.Parse(dirs)
->Evaluate(mf,
config, false, headTarget->Target,
depTgt->Target, dagChecker), result);
->Evaluate(lg,
config, false, headTarget,
depTgt, dagChecker), result);
}
if (!depTgt->IsImported() || excludeImported)
{
@ -537,9 +537,9 @@ static void handleSystemIncludesDep(cmMakefile *mf,
{
cmGeneratorExpression ge;
cmSystemTools::ExpandListArgument(ge.Parse(dirs)
->Evaluate(mf,
config, false, headTarget->Target,
depTgt->Target, dagChecker), result);
->Evaluate(lg,
config, false, headTarget,
depTgt, dagChecker), result);
}
}
@ -879,8 +879,8 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
{
cmGeneratorExpression ge;
cmSystemTools::ExpandListArgument(ge.Parse(*it)
->Evaluate(this->Makefile,
config, false, this->Target,
->Evaluate(this->LocalGenerator,
config, false, this,
&dagChecker), result);
}
@ -889,7 +889,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
for(std::vector<cmGeneratorTarget const*>::const_iterator
li = deps.begin(), le = deps.end(); li != le; ++li)
{
handleSystemIncludesDep(this->Makefile, *li, config, this,
handleSystemIncludesDep(this->LocalGenerator, *li, config, this,
&dagChecker, result, excludeImported);
}
@ -961,11 +961,12 @@ static bool processSources(cmGeneratorTarget const* tgt,
cmLinkImplItem const& item = (*it)->LinkImplItem;
std::string const& targetName = item;
std::vector<std::string> entrySources;
cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf,
cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(
tgt->GetLocalGenerator(),
config,
false,
tgt->Target,
tgt->Target,
tgt,
tgt,
dagChecker),
entrySources);
@ -2054,10 +2055,10 @@ void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string> &result,
this->GetName(),
"AUTOUIC_OPTIONS", 0, 0);
cmSystemTools::ExpandListArgument(ge.Parse(prop)
->Evaluate(this->Makefile,
->Evaluate(this->LocalGenerator,
config,
false,
this->Target,
this,
&dagChecker),
result);
}
@ -2304,7 +2305,8 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
// Check for a target with this name.
if(cmGeneratorTarget* t
= this->Makefile->FindGeneratorTargetToUse(util))
= this->GeneratorTarget->
GetLocalGenerator()->FindGeneratorTargetToUse(util))
{
// If we find the target and the dep was given as a full path,
// then make sure it was not a full path to something else, and
@ -2376,7 +2378,7 @@ cmTargetTraceDependencies
{
const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge
= ge.Parse(*cli);
cge->Evaluate(this->Makefile, "", true);
cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true);
std::set<cmTarget*> geTargets = cge->GetTargets();
targets.insert(geTargets.begin(), geTargets.end());
}
@ -2530,8 +2532,6 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
const std::string& config, bool debugIncludes,
const std::string& language)
{
cmMakefile *mf = tgt->Target->GetMakefile();
for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator
it = entries.begin(), end = entries.end(); it != end; ++it)
{
@ -2540,10 +2540,11 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
bool const fromImported = item.Target && item.Target->IsImported();
bool const checkCMP0027 = item.FromGenex;
std::vector<std::string> entryIncludes;
cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf,
cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(
tgt->GetLocalGenerator(),
config,
false,
tgt->Target,
tgt,
dagChecker, language),
entryIncludes);
@ -2746,16 +2747,15 @@ static void processCompileOptionsInternal(cmGeneratorTarget const* tgt,
const std::string& config, bool debugOptions, const char *logName,
std::string const& language)
{
cmMakefile *mf = tgt->Target->GetMakefile();
for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator
it = entries.begin(), end = entries.end(); it != end; ++it)
{
std::vector<std::string> entryOptions;
cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(mf,
cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(
tgt->GetLocalGenerator(),
config,
false,
tgt->Target,
tgt,
dagChecker,
language),
entryOptions);
@ -4452,11 +4452,11 @@ void cmGeneratorTarget::ExpandLinkItems(std::string const& prop,
std::vector<std::string> libs;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value);
cmSystemTools::ExpandListArgument(cge->Evaluate(
this->Makefile,
this->LocalGenerator,
config,
false,
headTarget->Target,
this->Target, &dagChecker), libs);
headTarget,
this, &dagChecker), libs);
this->LookupLinkItems(libs, items);
hadHeadSensitiveCondition = cge->GetHadHeadSensitiveCondition();
}
@ -4777,7 +4777,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(config_outdir);
out = cge->Evaluate(this->Makefile, config);
out = cge->Evaluate(this->LocalGenerator, config);
// Skip per-configuration subdirectory.
conf = "";
@ -4788,7 +4788,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(outdir);
out = cge->Evaluate(this->Makefile, config);
out = cge->Evaluate(this->LocalGenerator, config);
// Skip per-configuration subdirectory if the value contained a
// generator expression.
@ -5347,7 +5347,7 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge =
ge.Parse(*le);
std::string const evaluated =
cge->Evaluate(this->Makefile, config, false, head->Target, &dagChecker);
cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker);
cmSystemTools::ExpandListArgument(evaluated, llibs);
if(cge->GetHadHeadSensitiveCondition())
{

34
Source/cmGlobalGenerator.cxx
View File

@ -73,7 +73,7 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm)
this->CurrentMakefile = 0;
this->TryCompileOuterMakefile = 0;
this->ConfigureDoneCMP0026 = false;
this->ConfigureDoneCMP0026AndCMP0024 = false;
}
cmGlobalGenerator::~cmGlobalGenerator()
@ -234,6 +234,16 @@ bool cmGlobalGenerator::GenerateImportFile(const std::string &file)
if (it != this->BuildExportSets.end())
{
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);
}
}
delete it->second;
it->second = 0;
this->BuildExportSets.erase(it);
@ -1122,11 +1132,11 @@ void cmGlobalGenerator::Configure()
this->CMakeInstance->GetHomeOutputDirectory());
// now do it
this->ConfigureDoneCMP0026 = false;
this->ConfigureDoneCMP0026AndCMP0024 = false;
dirMf->Configure();
dirMf->EnforceDirectoryLevelRules();
this->ConfigureDoneCMP0026 = true;
this->ConfigureDoneCMP0026AndCMP0024 = true;
// Put a copy of each global target in every directory.
cmTargets globalTargets;
@ -1226,6 +1236,20 @@ bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
return false;
}
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]);
}
}
}
bool cmGlobalGenerator::Compute()
{
// Some generators track files replaced during the Generate.
@ -1255,6 +1279,8 @@ bool cmGlobalGenerator::Compute()
this->CreateQtAutoGeneratorsTargets();
#endif
this->ComputeBuildFileGenerators();
unsigned int i;
// Add generator specific helper commands
@ -1552,7 +1578,7 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes,
this->GeneratorTargets[*j] = gt;
generatorTargets[*j] = gt;
}
mf->SetGeneratorTargets(generatorTargets);
lg->SetGeneratorTargets(generatorTargets);
}
//----------------------------------------------------------------------------

7
Source/cmGlobalGenerator.h
View File

@ -362,7 +362,10 @@ public:
cmFileLockPool& GetFileLockPool() { return FileLockPool; }
#endif
bool GetConfigureDoneCMP0026() const { return this->ConfigureDoneCMP0026; }
bool GetConfigureDoneCMP0026() const
{ return this->ConfigureDoneCMP0026AndCMP0024; }
void ComputeBuildFileGenerators();
std::string MakeSilentFlag;
protected:
@ -520,7 +523,7 @@ protected:
bool ForceUnixPaths;
bool ToolSupportsColor;
bool InstallTargetEnabled;
bool ConfigureDoneCMP0026;
bool ConfigureDoneCMP0026AndCMP0024;
};
#endif

2
Source/cmGlobalGhsMultiGenerator.cxx
View File

@ -287,7 +287,7 @@ void cmGlobalGhsMultiGenerator::Generate()
{
cmLocalGhsMultiGenerator *lg =
static_cast<cmLocalGhsMultiGenerator *>(this->LocalGenerators[i]);
cmGeneratorTargetsType tgts = lg->GetMakefile()->GetGeneratorTargets();
cmGeneratorTargetsType tgts = lg->GetGeneratorTargets();
this->UpdateBuildFiles(&tgts);
}
}

3
Source/cmGlobalKdevelopGenerator.cxx
View File

@ -68,8 +68,7 @@ void cmGlobalKdevelopGenerator::Generate()
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
lg!=lgs.end(); lg++)
{
cmMakefile* makefile=(*lg)->GetMakefile();
cmGeneratorTargetsType const& targets = makefile->GetGeneratorTargets();
cmGeneratorTargetsType const& targets = (*lg)->GetGeneratorTargets();
for (cmGeneratorTargetsType::const_iterator ti = targets.begin();
ti != targets.end(); ti++)
{

6
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -461,7 +461,7 @@ cmGlobalUnixMakefileGenerator3
// The directory-level rule should depend on the target-level rules
// for all targets in the directory.
std::vector<std::string> depends;
cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets();
cmGeneratorTargetsType targets = lg->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator l = targets.begin();
l != targets.end(); ++l)
{
@ -628,7 +628,7 @@ cmGlobalUnixMakefileGenerator3
lg = static_cast<cmLocalUnixMakefileGenerator3 *>
(this->LocalGenerators[i]);
// for each target Generate the rule files for each target.
cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets();
cmGeneratorTargetsType targets = lg->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
{
@ -729,7 +729,7 @@ cmGlobalUnixMakefileGenerator3
depends.push_back("cmake_check_build_system");
// for each target Generate the rule files for each target.
cmGeneratorTargetsType targets = lg->GetMakefile()->GetGeneratorTargets();
cmGeneratorTargetsType targets = lg->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
{

3
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -1016,7 +1016,8 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression>
cge = ge.Parse(propertyValue);
if(cmSystemTools::IsOn(cge->Evaluate(target->GetMakefile(), *i)))
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
if(cmSystemTools::IsOn(cge->Evaluate(gt->GetLocalGenerator(), *i)))
{
activeConfigs.insert(*i);
}

2
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -256,7 +256,7 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
noCommandLines);
cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg);
mf->AddGeneratorTarget(tgt, gt);
lg->AddGeneratorTarget(tgt, gt);
// Organize in the "predefined targets" folder:
//

4
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -87,7 +87,7 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
"Build all projects");
cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]);
allBuild->GetMakefile()->AddGeneratorTarget(allBuild, gt);
gen[0]->AddGeneratorTarget(allBuild, gt);
#if 0
// Can't activate this code because we want ALL_BUILD
@ -108,7 +108,7 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
i != gen.end(); ++i)
{
cmGeneratorTargetsType targets =
(*i)->GetMakefile()->GetGeneratorTargets();
(*i)->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
{

6
Source/cmGlobalXCodeGenerator.cxx
View File

@ -459,7 +459,7 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
"echo", "Build all projects");
cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root);
mf->AddGeneratorTarget(allbuild, allBuildGt);
root->AddGeneratorTarget(allbuild, allBuildGt);
// Refer to the main build configuration file for easy editing.
std::string listfile = root->GetCurrentSourceDirectory();
@ -494,7 +494,7 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
"make", "-f", file.c_str());
cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root);
mf->AddGeneratorTarget(check, checkGt);
root->AddGeneratorTarget(check, checkGt);
}
// now make the allbuild depend on all the non-utility targets
@ -2486,7 +2486,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
{
cmGeneratorExpression ge;
std::string processed = ge.Parse(i->second.GetValue())
->Evaluate(this->CurrentMakefile, configName);
->Evaluate(this->CurrentLocalGenerator, configName);
buildSettings->AddAttribute(attribute.c_str(),
this->CreateString(processed));
}

1
Source/cmIncludeCommand.cxx
View File

@ -126,6 +126,7 @@ bool cmIncludeCommand
}
}
gg->CreateGenerationObjects();
gg->ComputeBuildFileGenerators();
gg->GenerateImportFile(fname_abs);
}

2
Source/cmInstallDirectoryGenerator.cxx
View File

@ -97,5 +97,5 @@ cmInstallDirectoryGenerator::GetDestination(std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)
->Evaluate(this->LocalGenerator->GetMakefile(), config);
->Evaluate(this->LocalGenerator, config);
}

4
Source/cmInstallFilesGenerator.cxx
View File

@ -68,7 +68,7 @@ cmInstallFilesGenerator::GetDestination(std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)
->Evaluate(this->LocalGenerator->GetMakefile(), config);
->Evaluate(this->LocalGenerator, config);
}
//----------------------------------------------------------------------------
@ -117,7 +117,7 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(std::ostream& os,
{
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
cmSystemTools::ExpandListArgument(cge->Evaluate(
this->LocalGenerator->GetMakefile(), config), files);
this->LocalGenerator, config), files);
}
this->AddFilesInstallRule(os, config, indent, files);
}

2
Source/cmInstallTargetGenerator.cxx
View File

@ -351,7 +351,7 @@ cmInstallTargetGenerator::GetDestination(std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)
->Evaluate(this->Target->Target->GetMakefile(), config);
->Evaluate(this->Target->GetLocalGenerator(), config);
}
//----------------------------------------------------------------------------

24
Source/cmLocalGenerator.cxx
View File

@ -132,7 +132,7 @@ void cmLocalGenerator::TraceDependencies()
this->GlobalGenerator->CreateEvaluationSourceFiles(*ci);
}
// Generate the rule files for each target.
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
{
@ -448,6 +448,13 @@ void cmLocalGenerator::GenerateInstallRules()
}
}
void cmLocalGenerator::AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt)
{
this->GeneratorTargets[t] = gt;
this->GetGlobalGenerator()->AddGeneratorTarget(t, gt);
}
//----------------------------------------------------------------------------
void cmLocalGenerator::ComputeTargetManifest()
{
@ -460,7 +467,7 @@ void cmLocalGenerator::ComputeTargetManifest()
}
// Add our targets to the manifest for each configuration.
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
{
@ -1766,6 +1773,17 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
this->AddConfigVariableFlags(flags, flagsVar, config);
}
//----------------------------------------------------------------------------
cmGeneratorTarget*
cmLocalGenerator::FindGeneratorTargetToUse(const std::string& name) const
{
if (cmTarget *t = this->Makefile->FindTargetToUse(name))
{
return this->GetGlobalGenerator()->GetGeneratorTarget(t);
}
return 0;
}
//----------------------------------------------------------------------------
bool cmLocalGenerator::GetRealDependency(const std::string& inName,
const std::string& config,
@ -1792,7 +1810,7 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName,
// Look for a CMake target with the given name.
if(cmGeneratorTarget* target =
this->Makefile->FindGeneratorTargetToUse(name))
this->FindGeneratorTargetToUse(name))
{
// make sure it is not just a coincidence that the target name
// found is part of the inName

14
Source/cmLocalGenerator.h
View File

@ -112,6 +112,19 @@ public:
bool forResponseFile = false,
const std::string& config = "");
const cmGeneratorTargetsType &GetGeneratorTargets() const
{
return this->GeneratorTargets;
}
void SetGeneratorTargets(const cmGeneratorTargetsType &targets)
{
this->GeneratorTargets = targets;
}
void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt);
cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const;
/**
* Encode a list of preprocessor definitions for the compiler
* command line.
@ -354,6 +367,7 @@ protected:
std::set<std::string> ObjectMaxPathViolations;
std::set<cmTarget const*> WarnCMP0063;
cmGeneratorTargetsType GeneratorTargets;
bool EmitUniversalBinaryFlags;

2
Source/cmLocalGhsMultiGenerator.cxx
View File

@ -26,7 +26,7 @@ cmLocalGhsMultiGenerator::~cmLocalGhsMultiGenerator() {}
void cmLocalGhsMultiGenerator::Generate()
{
cmGeneratorTargetsType tgts = this->GetMakefile()->GetGeneratorTargets();
cmGeneratorTargetsType tgts = this->GetGeneratorTargets();
for (cmGeneratorTargetsType::iterator l = tgts.begin(); l != tgts.end();
++l)

2
Source/cmLocalNinjaGenerator.cxx
View File

@ -73,7 +73,7 @@ void cmLocalNinjaGenerator::Generate()
}
}
cmGeneratorTargetsType targets = this->GetMakefile()->GetGeneratorTargets();
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)
{

6
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -113,7 +113,7 @@ void cmLocalUnixMakefileGenerator3::Generate()
this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES");
// Generate the rule files for each target.
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
for(cmGeneratorTargetsType::iterator t = targets.begin();
@ -175,7 +175,7 @@ void cmLocalUnixMakefileGenerator3::
GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
{
std::set<std::string> emitted;
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
@ -418,7 +418,7 @@ void cmLocalUnixMakefileGenerator3
// for each target we just provide a rule to cd up to the top and do a make
// on the target
cmGeneratorTargetsType targets = this->Makefile->GetGeneratorTargets();
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
std::string localName;
for(cmGeneratorTargetsType::iterator t = targets.begin();
t != targets.end(); ++t)

40
Source/cmMakefile.cxx
View File

@ -667,6 +667,29 @@ cmMakefile::GetEvaluationFiles() const
return this->EvaluationFiles;
}
std::vector<cmExportBuildFileGenerator*>
cmMakefile::GetExportBuildFileGenerators() const
{
return this->ExportBuildFileGenerators;
}
void cmMakefile::RemoveExportBuildFileGeneratorCMP0024(
cmExportBuildFileGenerator* gen)
{
std::vector<cmExportBuildFileGenerator*>::iterator it =
std::find(this->ExportBuildFileGenerators.begin(),
this->ExportBuildFileGenerators.end(), gen);
if(it != this->ExportBuildFileGenerators.end())
{
this->ExportBuildFileGenerators.erase(it);
}
}
void cmMakefile::AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen)
{
this->ExportBuildFileGenerators.push_back(gen);
}
namespace
{
struct file_not_persistent
@ -1757,12 +1780,6 @@ const char* cmMakefile::GetCurrentBinaryDirectory() const
return this->StateSnapshot.GetDirectory().GetCurrentBinary();
}
void cmMakefile::AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt)
{
this->GeneratorTargets[t] = gt;
this->GetGlobalGenerator()->AddGeneratorTarget(t, gt);
}
//----------------------------------------------------------------------------
void cmMakefile::AddIncludeDirectories(const std::vector<std::string> &incs,
bool before)
@ -4213,17 +4230,6 @@ bool cmMakefile::IsAlias(const std::string& name) const
return this->GetGlobalGenerator()->IsAlias(name);
}
//----------------------------------------------------------------------------
cmGeneratorTarget*
cmMakefile::FindGeneratorTargetToUse(const std::string& name) const
{
if (cmTarget *t = this->FindTargetToUse(name))
{
return this->GetGlobalGenerator()->GetGeneratorTarget(t);
}
return 0;
}
//----------------------------------------------------------------------------
bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
bool isCustom) const

21
Source/cmMakefile.h
View File

@ -17,7 +17,6 @@
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmNewLineStyle.h"
#include "cmGeneratorTarget.h"
#include "cmExpandedCommandArgument.h"
#include "cmake.h"
#include "cmState.h"
@ -51,6 +50,7 @@ class cmake;
class cmMakefileCall;
class cmCMakePolicyCommand;
class cmGeneratorExpressionEvaluationFile;
class cmExportBuildFileGenerator;
/** \class cmMakefile
* \brief Process the input CMakeLists.txt file.
@ -392,17 +392,6 @@ public:
return this->ImportedTargetsOwned;
}
const cmGeneratorTargetsType &GetGeneratorTargets() const
{
return this->GeneratorTargets;
}
void SetGeneratorTargets(const cmGeneratorTargetsType &targets)
{
this->GeneratorTargets = targets;
}
void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt);
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;
@ -411,7 +400,6 @@ public:
cmTarget* FindTargetToUse(const std::string& name,
bool excludeAliases = false) const;
bool IsAlias(const std::string& name) const;
cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const;
/**
* Mark include directories as system directories.
@ -789,6 +777,11 @@ public:
bool inputIsContent);
std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const;
std::vector<cmExportBuildFileGenerator*>
GetExportBuildFileGenerators() const;
void RemoveExportBuildFileGeneratorCMP0024(cmExportBuildFileGenerator* gen);
void AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen);
protected:
// add link libraries and directories to the target
void AddGlobalLinkInformation(const std::string& name, cmTarget& target);
@ -810,7 +803,6 @@ protected:
typedef std::map<std::string, cmTarget*> TargetMap;
#endif
TargetMap AliasTargets;
cmGeneratorTargetsType GeneratorTargets;
std::vector<cmSourceFile*> SourceFiles;
// Tests
@ -881,6 +873,7 @@ private:
mutable cmsys::RegularExpression cmNamedCurly;
std::vector<cmMakefile*> UnConfiguredDirectories;
std::vector<cmExportBuildFileGenerator*> ExportBuildFileGenerators;
std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles;

7
Source/cmMakefileTargetGenerator.cxx
View File

@ -147,8 +147,11 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(additional_clean_files);
cmSystemTools::ExpandListArgument(cge->Evaluate(this->Makefile, config,
false, this->Target, 0, 0),
cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator,
config,
false,
this->GeneratorTarget,
0, 0),
this->CleanFiles);
}

2
Source/cmQtAutoGeneratorInitializer.cxx
View File

@ -886,7 +886,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
commandLines, false, autogenComment.c_str());
cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
makefile->AddGeneratorTarget(autogenTarget, gt);
lg->AddGeneratorTarget(autogenTarget, gt);
// Set target folder
const char* autogenFolder = makefile->GetState()

8
Source/cmTestGenerator.cxx
View File

@ -89,7 +89,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
// be translated.
std::string exe = command[0];
cmGeneratorTarget* target =
this->LG->GetMakefile()->FindGeneratorTargetToUse(exe);
this->LG->FindGeneratorTargetToUse(exe);
if(target && target->GetType() == cmTarget::EXECUTABLE)
{
// Use the target file on disk.
@ -117,7 +117,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
else
{
// Use the command name given.
exe = ge.Parse(exe.c_str())->Evaluate(this->LG->GetMakefile(), config);
exe = ge.Parse(exe.c_str())->Evaluate(this->LG, config);
cmSystemTools::ConvertToUnixSlashes(exe);
}
@ -128,7 +128,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
{
os << " " << cmOutputConverter::EscapeForCMake(
ge.Parse(*ci)->Evaluate(
this->LG->GetMakefile(), config));
this->LG, config));
}
// Finish the test command.
@ -145,7 +145,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
{
os << " " << i->first
<< " " << cmOutputConverter::EscapeForCMake(
ge.Parse(i->second.GetValue())->Evaluate(this->LG->GetMakefile(),
ge.Parse(i->second.GetValue())->Evaluate(this->LG,
config));
}
os << ")" << std::endl;

11
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -1370,7 +1370,7 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
}
for(size_t i = 0; i != this->Configurations.size(); ++i)
{
if(0 == strcmp(cge->Evaluate(this->Makefile,
if(0 == strcmp(cge->Evaluate(this->LocalGenerator,
this->Configurations[i]), "1"))
{
this->WriteString("<DeploymentContent Condition=\""
@ -2301,7 +2301,8 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(nativeLibDirectoriesExpression);
std::string nativeLibDirs = cge->Evaluate(this->Makefile, configName);
std::string nativeLibDirs = cge->Evaluate(this->LocalGenerator,
configName);
this->WriteString("<NativeLibDirectories>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs) <<
"</NativeLibDirectories>\n";
@ -2313,7 +2314,8 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(nativeLibDependenciesExpression);
std::string nativeLibDeps = cge->Evaluate(this->Makefile, configName);
std::string nativeLibDeps = cge->Evaluate(this->LocalGenerator,
configName);
this->WriteString("<NativeLibDependencies>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps) <<
"</NativeLibDependencies>\n";
@ -2333,7 +2335,8 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(jarDirectoriesExpression);
std::string jarDirectories = cge->Evaluate(this->Makefile, configName);
std::string jarDirectories = cge->Evaluate(this->LocalGenerator,
configName);
this->WriteString("<JarDirectories>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories) <<
"</JarDirectories>\n";

1
bootstrap
View File

@ -261,6 +261,7 @@ CMAKE_CXX_SOURCES="\
cmPropertyDefinitionMap \
cmMakeDepend \
cmMakefile \
cmExportBuildFileGenerator \
cmExportFileGenerator \
cmExportInstallFileGenerator \
cmExportTryCompileFileGenerator \