mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-04-27 09:29:15 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge topic 'add-genex-evaluate-utility'

Browse Source 
7dcf9cb83c cmGeneratorExpression: Add cmGeneratorExpression::Evaluate utility
c7c59dae82 cmCustomCommandGenerator: Replace generator expression member
c12222db86 cmGeneratorExpression: Remove Evaluate overload by parameter re-ordering
1811411fec cmGeneratorExpression: Move quiet flag to cmCompiledGeneratorExpression
edb0bbd18b cmGeneratorTarget: Remove unused virtual signature of TargetPropertyEntry

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !3852
This commit is contained in:
Brad King
2019-09-24 14:31:25 +00:00
committed by Kitware Robot
parent 13c7a16cde 7dcf9cb83c
commit 908fc3605b
24 changed files with 198 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/cmCustomCommandGenerator.cxx
+7 -13
View File
@@ -19,7 +19,7 @@
namespace {
void AppendPaths(const std::vector<std::string>& inputs,
cmGeneratorExpression& ge, cmLocalGenerator* lg,
cmGeneratorExpression const& ge, cmLocalGenerator* lg,
std::string const& config, std::vector<std::string>& output)
{
for (std::string const& in : inputs) {
@@ -45,15 +45,15 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
, LG(lg)
, OldStyle(cc.GetEscapeOldStyle())
, MakeVars(cc.GetEscapeAllowMakeVars())
, GE(new cmGeneratorExpression(cc.GetBacktrace()))
, EmulatorsWithArguments(cc.GetCommandLines().size())
{
cmGeneratorExpression ge(cc.GetBacktrace());
const cmCustomCommandLines& cmdlines = this->CC.GetCommandLines();
for (cmCustomCommandLine const& cmdline : cmdlines) {
cmCustomCommandLine argv;
for (std::string const& clarg : cmdline) {
std::unique_ptr<cmCompiledGeneratorExpression> cge =
this->GE->Parse(clarg);
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(clarg);
std::string parsed_arg = cge->Evaluate(this->LG, this->Config);
if (this->CC.GetCommandExpandLists()) {
cmAppend(argv, cmExpandedList(parsed_arg));
@@ -72,15 +72,14 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
this->CommandLines.push_back(std::move(argv));
}
AppendPaths(cc.GetByproducts(), *this->GE, this->LG, this->Config,
AppendPaths(cc.GetByproducts(), ge, this->LG, this->Config,
this->Byproducts);
AppendPaths(cc.GetDepends(), *this->GE, this->LG, this->Config,
this->Depends);
AppendPaths(cc.GetDepends(), ge, this->LG, this->Config, this->Depends);
const std::string& workingdirectory = this->CC.GetWorkingDirectory();
if (!workingdirectory.empty()) {
std::unique_ptr<cmCompiledGeneratorExpression> cge =
this->GE->Parse(workingdirectory);
ge.Parse(workingdirectory);
this->WorkingDirectory = cge->Evaluate(this->LG, this->Config);
// Convert working directory to a full path.
if (!this->WorkingDirectory.empty()) {
@@ -93,11 +92,6 @@ cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
this->FillEmulatorsWithArguments();
}
cmCustomCommandGenerator::~cmCustomCommandGenerator()
{
delete this->GE;
}
unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
{
return static_cast<unsigned int>(this->CC.GetCommandLines().size());
Source/cmCustomCommandGenerator.h
-3
View File
@@ -10,7 +10,6 @@
#include <vector>
class cmCustomCommand;
class cmGeneratorExpression;
class cmLocalGenerator;
class cmCustomCommandGenerator
@@ -20,7 +19,6 @@ class cmCustomCommandGenerator
cmLocalGenerator* LG;
bool OldStyle;
bool MakeVars;
cmGeneratorExpression* GE;
cmCustomCommandLines CommandLines;
std::vector<std::vector<std::string>> EmulatorsWithArguments;
std::vector<std::string> Byproducts;
@@ -34,7 +32,6 @@ class cmCustomCommandGenerator
public:
cmCustomCommandGenerator(cmCustomCommand const& cc, std::string config,
cmLocalGenerator* lg);
~cmCustomCommandGenerator();
cmCustomCommandGenerator(const cmCustomCommandGenerator&) = delete;
cmCustomCommandGenerator& operator=(const cmCustomCommandGenerator&) =
delete;
Source/cmExportFileGenerator.cxx
+1 -1
View File
@@ -380,7 +380,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
this->ReplaceInstallPrefix(dirs);
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
std::string exportDirs =
cge->Evaluate(target->GetLocalGenerator(), "", false, target);
cge->Evaluate(target->GetLocalGenerator(), "", target);
if (cge->GetHadContextSensitiveCondition()) {
cmLocalGenerator* lg = target->GetLocalGenerator();
Source/cmExportTryCompileFileGenerator.cxx
+2 -3
View File
@@ -74,9 +74,8 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator());
std::string result =
cge->Evaluate(tgt->GetLocalGenerator(), this->Config, false, &gDummyHead,
tgt, &dagChecker, language);
std::string result = cge->Evaluate(tgt->GetLocalGenerator(), this->Config,
&gDummyHead, &dagChecker, tgt, language);
const std::set<cmGeneratorTarget const*>& allTargets =
cge->GetAllTargetsSeen();
Source/cmGeneratorExpression.cxx
+42 -19
View File
@@ -21,40 +21,56 @@ cmGeneratorExpression::cmGeneratorExpression(cmListFileBacktrace backtrace)
{
}
cmGeneratorExpression::~cmGeneratorExpression() = default;
std::unique_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
std::string const& input)
std::string input) const
{
return std::unique_ptr<cmCompiledGeneratorExpression>(
new cmCompiledGeneratorExpression(this->Backtrace, input));
new cmCompiledGeneratorExpression(this->Backtrace, std::move(input)));
}
std::unique_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
const char* input)
const char* input) const
{
return this->Parse(std::string(input ? input : ""));
}
cmGeneratorExpression::~cmGeneratorExpression() = default;
const std::string& cmCompiledGeneratorExpression::Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet,
const cmGeneratorTarget* headTarget,
std::string cmGeneratorExpression::Evaluate(
std::string input, cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& language) const
cmGeneratorTarget const* currentTarget, std::string const& language)
{
return this->Evaluate(lg, config, quiet, headTarget, headTarget, dagChecker,
if (Find(input) != std::string::npos) {
cmCompiledGeneratorExpression cge(cmListFileBacktrace(), std::move(input));
return cge.Evaluate(lg, config, headTarget, dagChecker, currentTarget,
language);
}
return input;
}
std::string cmGeneratorExpression::Evaluate(
const char* input, cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
cmGeneratorTarget const* currentTarget, std::string const& language)
{
return input ? Evaluate(std::string(input), lg, config, headTarget,
dagChecker, currentTarget, language)
: "";
}
const std::string& cmCompiledGeneratorExpression::Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet,
const cmGeneratorTarget* headTarget, const cmGeneratorTarget* currentTarget,
cmLocalGenerator* lg, const std::string& config,
const cmGeneratorTarget* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& language) const
const cmGeneratorTarget* currentTarget, std::string const& language) const
{
cmGeneratorExpressionContext context(
lg, config, quiet, headTarget, currentTarget ? currentTarget : headTarget,
this->EvaluateForBuildsystem, this->Backtrace, language);
lg, config, this->Quiet, headTarget,
currentTarget ? currentTarget : headTarget, this->EvaluateForBuildsystem,
this->Backtrace, language);
return this->EvaluateWithContext(context, dagChecker);
}
@@ -97,9 +113,10 @@ cmCompiledGeneratorExpression::cmCompiledGeneratorExpression(
cmListFileBacktrace backtrace, std::string input)
: Backtrace(std::move(backtrace))
, Input(std::move(input))
, EvaluateForBuildsystem(false)
, Quiet(false)
, HadContextSensitiveCondition(false)
, HadHeadSensitiveCondition(false)
, EvaluateForBuildsystem(false)
{
cmGeneratorExpressionLexer l;
std::vector<cmGeneratorExpressionToken> tokens = l.Tokenize(this->Input);
@@ -377,10 +394,10 @@ void cmCompiledGeneratorExpression::GetMaxLanguageStandard(
}
const std::string& cmGeneratorExpressionInterpreter::Evaluate(
const char* expression, const std::string& property)
std::string expression, const std::string& property)
{
this->CompiledGeneratorExpression =
this->GeneratorExpression.Parse(expression);
this->GeneratorExpression.Parse(std::move(expression));
// Specify COMPILE_OPTIONS to DAGchecker, same semantic as COMPILE_FLAGS
cmGeneratorExpressionDAGChecker dagChecker(
@@ -389,6 +406,12 @@ const std::string& cmGeneratorExpressionInterpreter::Evaluate(
nullptr);
return this->CompiledGeneratorExpression->Evaluate(
this->LocalGenerator, this->Config, false, this->HeadTarget, &dagChecker,
this->LocalGenerator, this->Config, this->HeadTarget, &dagChecker, nullptr,
this->Language);
}
const std::string& cmGeneratorExpressionInterpreter::Evaluate(
const char* expression, const std::string& property)
{
return this->Evaluate(std::string(expression ? expression : ""), property);
}
Source/cmGeneratorExpression.h
+26 -17
View File
@@ -41,8 +41,22 @@ public:
cmGeneratorExpression& operator=(cmGeneratorExpression const&) = delete;
std::unique_ptr<cmCompiledGeneratorExpression> Parse(
std::string const& input);
std::unique_ptr<cmCompiledGeneratorExpression> Parse(const char* input);
std::string input) const;
std::unique_ptr<cmCompiledGeneratorExpression> Parse(
const char* input) const;
static std::string Evaluate(
std::string input, cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget = nullptr,
cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
cmGeneratorTarget const* currentTarget = nullptr,
std::string const& language = std::string());
static std::string Evaluate(
const char* input, cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget = nullptr,
cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
cmGeneratorTarget const* currentTarget = nullptr,
std::string const& language = std::string());
enum PreprocessContext
{
@@ -87,15 +101,10 @@ public:
cmCompiledGeneratorExpression const&) = delete;
const std::string& Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet = false,
cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget = nullptr,
cmGeneratorTarget const* currentTarget = nullptr,
cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
std::string const& language = std::string()) const;
const std::string& Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
cmGeneratorTarget const* currentTarget = nullptr,
std::string const& language = std::string()) const;
/** Get set of targets found during evaluations. */
@@ -135,6 +144,8 @@ public:
this->EvaluateForBuildsystem = eval;
}
void SetQuiet(bool quiet) { this->Quiet = quiet; }
void GetMaxLanguageStandard(cmGeneratorTarget const* tgt,
std::map<std::string, std::string>& mapping);
@@ -152,6 +163,8 @@ private:
std::vector<cmGeneratorExpressionEvaluator*> Evaluators;
const std::string Input;
bool NeedsEvaluation;
bool EvaluateForBuildsystem;
bool Quiet;
mutable std::set<cmGeneratorTarget*> DependTargets;
mutable std::set<cmGeneratorTarget const*> AllTargetsSeen;
@@ -163,7 +176,6 @@ private:
mutable bool HadContextSensitiveCondition;
mutable bool HadHeadSensitiveCondition;
mutable std::set<cmGeneratorTarget const*> SourceSensitiveTargets;
bool EvaluateForBuildsystem;
};
class cmGeneratorExpressionInterpreter
@@ -172,11 +184,11 @@ public:
cmGeneratorExpressionInterpreter(cmLocalGenerator* localGenerator,
std::string config,
cmGeneratorTarget const* headTarget,
std::string lang = std::string())
std::string language = std::string())
: LocalGenerator(localGenerator)
, Config(std::move(config))
, HeadTarget(headTarget)
, Language(std::move(lang))
, Language(std::move(language))
{
}
@@ -185,13 +197,10 @@ public:
cmGeneratorExpressionInterpreter& operator=(
cmGeneratorExpressionInterpreter const&) = delete;
const std::string& Evaluate(std::string expression,
const std::string& property);
const std::string& Evaluate(const char* expression,
const std::string& property);
const std::string& Evaluate(const std::string& expression,
const std::string& property)
{
return this->Evaluate(expression.c_str(), property);
}
protected:
cmGeneratorExpression GeneratorExpression;
Source/cmGeneratorExpressionEvaluationFile.cxx
+7 -7
View File
@@ -37,8 +37,8 @@ void cmGeneratorExpressionEvaluationFile::Generate(
{
std::string rawCondition = this->Condition->GetInput();
if (!rawCondition.empty()) {
std::string condResult = this->Condition->Evaluate(
lg, config, false, nullptr, nullptr, nullptr, lang);
std::string condResult =
this->Condition->Evaluate(lg, config, nullptr, nullptr, nullptr, lang);
if (condResult == "0") {
return;
}
@@ -54,9 +54,9 @@ void cmGeneratorExpressionEvaluationFile::Generate(
}
std::string outputFileName = this->OutputFileExpr->Evaluate(
lg, config, false, nullptr, nullptr, nullptr, lang);
const std::string& outputContent = inputExpression->Evaluate(
lg, config, false, nullptr, nullptr, nullptr, lang);
lg, config, nullptr, nullptr, nullptr, lang);
const std::string& outputContent =
inputExpression->Evaluate(lg, config, nullptr, nullptr, nullptr, lang);
if (cmSystemTools::FileIsFullPath(outputFileName)) {
outputFileName = cmSystemTools::CollapseFullPath(outputFileName);
@@ -100,8 +100,8 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
gg->GetEnabledLanguages(enabledLanguages);
for (std::string const& le : enabledLanguages) {
std::string name = this->OutputFileExpr->Evaluate(
lg, config, false, nullptr, nullptr, nullptr, le);
std::string name = this->OutputFileExpr->Evaluate(lg, config, nullptr,
nullptr, nullptr, le);
cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(
name, false, cmSourceFileLocationKind::Known);
// Tell TraceDependencies that the file is not expected to exist
Source/cmGeneratorExpressionNode.cxx
+10 -9
View File
@@ -45,15 +45,16 @@
std::string cmGeneratorExpressionNode::EvaluateDependentExpression(
std::string const& prop, cmLocalGenerator* lg,
cmGeneratorExpressionContext* context, cmGeneratorTarget const* headTarget,
cmGeneratorTarget const* currentTarget,
cmGeneratorExpressionDAGChecker* dagChecker)
cmGeneratorExpressionDAGChecker* dagChecker,
cmGeneratorTarget const* currentTarget)
{
cmGeneratorExpression ge(context->Backtrace);
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem);
cge->SetQuiet(context->Quiet);
std::string result =
cge->Evaluate(lg, context->Config, context->Quiet, headTarget,
currentTarget, dagChecker, context->Language);
cge->Evaluate(lg, context->Config, headTarget, dagChecker, currentTarget,
context->Language);
if (cge->GetHadContextSensitiveCondition()) {
context->HadContextSensitiveCondition = true;
}
@@ -477,13 +478,13 @@ protected:
}
return this->EvaluateDependentExpression(
expression, context->LG, context, context->HeadTarget,
context->CurrentTarget, &dagChecker);
expression, context->LG, context, context->HeadTarget, &dagChecker,
context->CurrentTarget);
}
return this->EvaluateDependentExpression(
expression, context->LG, context, context->HeadTarget,
context->CurrentTarget, dagCheckerParent);
expression, context->LG, context, context->HeadTarget, dagCheckerParent,
context->CurrentTarget);
}
};
@@ -1331,7 +1332,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
if (!interfacePropertyName.empty()) {
result = this->EvaluateDependentExpression(result, context->LG, context,
target, target, &dagChecker);
target, &dagChecker, target);
std::string linkedTargetsContent = getLinkedTargetsContent(
target, interfacePropertyName, context, &dagChecker);
if (!linkedTargetsContent.empty()) {
Source/cmGeneratorExpressionNode.h
+2 -2
View File
@@ -43,8 +43,8 @@ struct cmGeneratorExpressionNode
static std::string EvaluateDependentExpression(
std::string const& prop, cmLocalGenerator* lg,
cmGeneratorExpressionContext* context, const cmGeneratorTarget* headTarget,
const cmGeneratorTarget* currentTarget,
cmGeneratorExpressionDAGChecker* dagChecker);
cmGeneratorExpressionDAGChecker* dagChecker,
const cmGeneratorTarget* currentTarget);
static const cmGeneratorExpressionNode* GetNode(
const std::string& identifier);
Source/cmGeneratorTarget.cxx
+38 -73
View File
@@ -84,16 +84,10 @@ public:
virtual ~TargetPropertyEntry() = default;
virtual const std::string& Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet = false,
cmGeneratorTarget const* headTarget = nullptr,
cmGeneratorTarget const* currentTarget = nullptr,
cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
std::string const& language = std::string()) const = 0;
virtual const std::string& Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet,
cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& language = std::string()) const = 0;
std::string const& language) const = 0;
virtual cmListFileBacktrace GetBacktrace() const = 0;
virtual std::string const& GetInput() const = 0;
@@ -113,23 +107,12 @@ public:
{
}
const std::string& Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet = false,
cmGeneratorTarget const* headTarget = nullptr,
cmGeneratorTarget const* currentTarget = nullptr,
cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
std::string const& language = std::string()) const override
const std::string& Evaluate(cmLocalGenerator* lg, const std::string& config,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& language) const override
{
return this->ge->Evaluate(lg, config, quiet, headTarget, currentTarget,
dagChecker, language);
}
const std::string& Evaluate(
cmLocalGenerator* lg, const std::string& config, bool quiet,
cmGeneratorTarget const* headTarget,
cmGeneratorExpressionDAGChecker* dagChecker,
std::string const& language = std::string()) const override
{
return this->ge->Evaluate(lg, config, quiet, headTarget, dagChecker,
return this->ge->Evaluate(lg, config, headTarget, dagChecker, nullptr,
language);
}
@@ -161,15 +144,7 @@ public:
{
}
const std::string& Evaluate(cmLocalGenerator*, const std::string&, bool,
cmGeneratorTarget const*,
cmGeneratorTarget const*,
cmGeneratorExpressionDAGChecker*,
std::string const&) const override
{
return this->PropertyValue;
}
const std::string& Evaluate(cmLocalGenerator*, const std::string&, bool,
const std::string& Evaluate(cmLocalGenerator*, const std::string&,
cmGeneratorTarget const*,
cmGeneratorExpressionDAGChecker*,
std::string const&) const override
@@ -198,7 +173,7 @@ cmGeneratorTarget::TargetPropertyEntry* CreateTargetPropertyEntry(
return new TargetPropertyEntryGenex(std::move(cge));
}
return new TargetPropertyEntryString(propertyValue, backtrace);
return new TargetPropertyEntryString(propertyValue, std::move(backtrace));
}
void CreatePropertyGeneratorExpressions(
@@ -245,7 +220,7 @@ EvaluatedTargetPropertyEntry EvaluateTargetPropertyEntry(
cmGeneratorTarget::TargetPropertyEntry* entry)
{
EvaluatedTargetPropertyEntry ee(entry->LinkImplItem, entry->GetBacktrace());
cmExpandList(entry->Evaluate(thisTarget->GetLocalGenerator(), config, false,
cmExpandList(entry->Evaluate(thisTarget->GetLocalGenerator(), config,
thisTarget, dagChecker, lang),
ee.Values);
if (entry->GetHadContextSensitiveCondition()) {
@@ -512,9 +487,8 @@ std::string cmGeneratorTarget::GetOutputName(
}
// Now evaluate genex and update the previously-prepared map entry.
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName);
i->second = cge->Evaluate(this->LocalGenerator, config);
i->second =
cmGeneratorExpression::Evaluate(outName, this->LocalGenerator, config);
} else if (i->second.empty()) {
// An empty map entry indicates we have been called recursively
// from the above block.
@@ -734,9 +708,8 @@ void handleSystemIncludesDep(cmLocalGenerator* lg,
{
if (const char* dirs =
depTgt->GetProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES")) {
cmGeneratorExpression ge;
cmExpandList(ge.Parse(dirs)->Evaluate(lg, config, false, headTarget,
depTgt, dagChecker, language),
cmExpandList(cmGeneratorExpression::Evaluate(dirs, lg, config, headTarget,
dagChecker, depTgt, language),
result);
}
if (!depTgt->IsImported() || excludeImported) {
@@ -745,9 +718,8 @@ void handleSystemIncludesDep(cmLocalGenerator* lg,
if (const char* dirs =
depTgt->GetProperty("INTERFACE_INCLUDE_DIRECTORIES")) {
cmGeneratorExpression ge;
cmExpandList(ge.Parse(dirs)->Evaluate(lg, config, false, headTarget,
depTgt, dagChecker, language),
cmExpandList(cmGeneratorExpression::Evaluate(dirs, lg, config, headTarget,
dagChecker, depTgt, language),
result);
}
}
@@ -1117,9 +1089,9 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(
std::vector<std::string> result;
for (std::string const& it : this->Target->GetSystemIncludeDirectories()) {
cmGeneratorExpression ge;
cmExpandList(ge.Parse(it)->Evaluate(this->LocalGenerator, config, false,
this, &dagChecker, language),
cmExpandList(cmGeneratorExpression::Evaluate(it, this->LocalGenerator,
config, this, &dagChecker,
nullptr, language),
result);
}
@@ -1225,7 +1197,7 @@ std::string cmGeneratorTarget::EvaluateInterfaceProperty(
if (const char* p = this->GetProperty(prop)) {
result = cmGeneratorExpressionNode::EvaluateDependentExpression(
p, context->LG, context, headTarget, this, &dagChecker);
p, context->LG, context, headTarget, &dagChecker, this);
}
if (cmLinkInterfaceLibraries const* iface =
@@ -1315,7 +1287,7 @@ void AddObjectEntries(cmGeneratorTarget const* headTarget,
EvaluatedTargetPropertyEntry ee(lib, lib.Backtrace);
cmExpandList(cge->Evaluate(headTarget->GetLocalGenerator(), config,
false, headTarget, dagChecker),
headTarget, dagChecker),
ee.Values);
if (cge->GetHadContextSensitiveCondition()) {
ee.ContextDependent = true;
@@ -2543,12 +2515,11 @@ void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string>& result,
if (!prop) {
return;
}
cmGeneratorExpression ge;
cmGeneratorExpressionDAGChecker dagChecker(this, "AUTOUIC_OPTIONS", nullptr,
nullptr);
cmExpandList(ge.Parse(prop)->Evaluate(this->LocalGenerator, config, false,
this, &dagChecker),
cmExpandList(cmGeneratorExpression::Evaluate(prop, this->LocalGenerator,
config, this, &dagChecker),
result);
}
@@ -2818,7 +2789,8 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
// Check for target references in generator expressions.
for (std::string const& cl : cCmdLine) {
const std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(cl);
cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true);
cge->SetQuiet(true);
cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "");
std::set<cmGeneratorTarget*> geTargets = cge->GetTargets();
targets.insert(geTargets.begin(), geTargets.end());
}
@@ -5314,9 +5286,9 @@ void cmGeneratorTarget::ExpandLinkItems(
}
std::vector<std::string> libs;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value);
cmExpandList(cge->Evaluate(this->LocalGenerator, config, false, headTarget,
this, &dagChecker),
libs);
cmExpandList(
cge->Evaluate(this->LocalGenerator, config, headTarget, &dagChecker, this),
libs);
this->LookupLinkItems(libs, cge->GetBacktrace(), items);
hadHeadSensitiveCondition = cge->GetHadHeadSensitiveCondition();
}
@@ -5579,18 +5551,15 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
// Select an output directory.
if (const char* config_outdir = this->GetProperty(configProp)) {
// Use the user-specified per-configuration output directory.
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(config_outdir);
out = cge->Evaluate(this->LocalGenerator, config);
out = cmGeneratorExpression::Evaluate(config_outdir, this->LocalGenerator,
config);
// Skip per-configuration subdirectory.
conf.clear();
} else if (const char* outdir = this->GetProperty(propertyName)) {
// Use the user-specified output directory.
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
out = cge->Evaluate(this->LocalGenerator, config);
out =
cmGeneratorExpression::Evaluate(outdir, this->LocalGenerator, config);
// Skip per-configuration subdirectory if the value contained a
// generator expression.
@@ -5658,18 +5627,15 @@ bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind,
// Select an output directory.
if (const char* config_outdir = this->GetProperty(configProp)) {
// Use the user-specified per-configuration output directory.
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(config_outdir);
out = cge->Evaluate(this->LocalGenerator, config);
out = cmGeneratorExpression::Evaluate(config_outdir, this->LocalGenerator,
config);
// Skip per-configuration subdirectory.
conf.clear();
} else if (const char* outdir = this->GetProperty(propertyName)) {
// Use the user-specified output directory.
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
out = cge->Evaluate(this->LocalGenerator, config);
out =
cmGeneratorExpression::Evaluate(outdir, this->LocalGenerator, config);
// Skip per-configuration subdirectory if the value contained a
// generator expression.
@@ -5724,8 +5690,7 @@ bool cmGeneratorTarget::GetRPATH(const std::string& config,
return false;
}
cmGeneratorExpression ge;
rpath = ge.Parse(value)->Evaluate(this->LocalGenerator, config);
rpath = cmGeneratorExpression::Evaluate(value, this->LocalGenerator, config);
return true;
}
@@ -6386,7 +6351,7 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
cmGeneratorExpression ge(*btIt);
std::unique_ptr<cmCompiledGeneratorExpression> const cge = ge.Parse(*le);
std::string const& evaluated =
cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker);
cge->Evaluate(this->LocalGenerator, config, head, &dagChecker);
cmExpandList(evaluated, llibs);
if (cge->GetHadHeadSensitiveCondition()) {
impl.HadHeadSensitiveCondition = true;
Source/cmGlobalVisualStudio7Generator.cxx
+2 -4
View File
@@ -663,10 +663,8 @@ std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
for (std::string const& i : configs) {
const char* propertyValue =
target->Target->GetMakefile()->GetDefinition(propertyName);
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(propertyValue);
if (cmIsOn(cge->Evaluate(target->GetLocalGenerator(), i))) {
if (cmIsOn(cmGeneratorExpression::Evaluate(
propertyValue, target->GetLocalGenerator(), i))) {
activeConfigs.insert(i);
}
}
Source/cmGlobalVisualStudio8Generator.cxx
+3 -5
View File
@@ -284,11 +284,9 @@ bool cmGlobalVisualStudio8Generator::DeployInhibited(
cmGeneratorTarget const& target, const char* config) const
{
bool rVal = false;
if (const char* propStr = target.GetProperty("VS_NO_SOLUTION_DEPLOY")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(propStr);
std::string prop = cge->Evaluate(target.LocalGenerator, config);
rVal = cmIsOn(prop);
if (const char* prop = target.GetProperty("VS_NO_SOLUTION_DEPLOY")) {
rVal = cmIsOn(
cmGeneratorExpression::Evaluate(prop, target.LocalGenerator, config));
}
return rVal;
}
Source/cmGlobalXCodeGenerator.cxx
+5 -8
View File
@@ -2381,10 +2381,8 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
std::string attribute = prop.substr(16);
this->FilterConfigurationAttribute(configName, attribute);
if (!attribute.empty()) {
cmGeneratorExpression ge;
std::string processed =
ge.Parse(gtgt->GetProperty(prop))
->Evaluate(this->CurrentLocalGenerator, configName);
std::string processed = cmGeneratorExpression::Evaluate(
gtgt->GetProperty(prop), this->CurrentLocalGenerator, configName);
buildSettings->AddAttribute(attribute,
this->CreateString(processed));
}
@@ -3118,10 +3116,9 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
std::string attribute = var.substr(22);
this->FilterConfigurationAttribute(config.first, attribute);
if (!attribute.empty()) {
cmGeneratorExpression ge;
std::string processed =
ge.Parse(this->CurrentMakefile->GetDefinition(var))
->Evaluate(this->CurrentLocalGenerator, config.first);
std::string processed = cmGeneratorExpression::Evaluate(
this->CurrentMakefile->GetDefinition(var),
this->CurrentLocalGenerator, config.first);
buildSettingsForCfg->AddAttribute(attribute,
this->CreateString(processed));
}
Source/cmInstallDirectoryGenerator.cxx
+4 -7
View File
@@ -9,8 +9,6 @@
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include <memory>
cmInstallDirectoryGenerator::cmInstallDirectoryGenerator(
std::vector<std::string> const& dirs, const char* dest,
const char* file_permissions, const char* dir_permissions,
@@ -64,10 +62,9 @@ void cmInstallDirectoryGenerator::GenerateScriptForConfig(
std::ostream& os, const std::string& config, Indent indent)
{
std::vector<std::string> dirs;
cmGeneratorExpression ge;
for (std::string const& d : this->Directories) {
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(d);
cmExpandList(cge->Evaluate(this->LocalGenerator, config), dirs);
cmExpandList(
cmGeneratorExpression::Evaluate(d, this->LocalGenerator, config), dirs);
}
// Make sure all dirs have absolute paths.
@@ -97,6 +94,6 @@ void cmInstallDirectoryGenerator::AddDirectoryInstallRule(
std::string cmInstallDirectoryGenerator::GetDestination(
std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)->Evaluate(this->LocalGenerator, config);
return cmGeneratorExpression::Evaluate(this->Destination,
this->LocalGenerator, config);
}
Source/cmInstallFilesGenerator.cxx
+4 -7
View File
@@ -6,8 +6,6 @@
#include "cmInstallType.h"
#include "cmStringAlgorithms.h"
#include <memory>
class cmLocalGenerator;
cmInstallFilesGenerator::cmInstallFilesGenerator(
@@ -51,8 +49,8 @@ bool cmInstallFilesGenerator::Compute(cmLocalGenerator* lg)
std::string cmInstallFilesGenerator::GetDestination(
std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)->Evaluate(this->LocalGenerator, config);
return cmGeneratorExpression::Evaluate(this->Destination,
this->LocalGenerator, config);
}
void cmInstallFilesGenerator::AddFilesInstallRule(
@@ -82,10 +80,9 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(
std::ostream& os, const std::string& config, Indent indent)
{
std::vector<std::string> files;
cmGeneratorExpression ge;
for (std::string const& f : this->Files) {
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(f);
cmExpandList(cge->Evaluate(this->LocalGenerator, config), files);
cmExpandList(
cmGeneratorExpression::Evaluate(f, this->LocalGenerator, config), files);
}
this->AddFilesInstallRule(os, config, indent, files);
}
Source/cmInstallScriptGenerator.cxx
+2 -5
View File
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmInstallScriptGenerator.h"
#include <memory>
#include <ostream>
#include <vector>
@@ -79,11 +78,9 @@ void cmInstallScriptGenerator::GenerateScriptForConfig(
std::ostream& os, const std::string& config, Indent indent)
{
if (this->AllowGenex) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(this->Script);
this->AddScriptInstallRule(os, indent,
cge->Evaluate(this->LocalGenerator, config));
cmGeneratorExpression::Evaluate(
this->Script, this->LocalGenerator, config));
} else {
this->AddScriptInstallRule(os, indent, this->Script);
}
Source/cmInstallTargetGenerator.cxx
+2 -4
View File
@@ -4,7 +4,6 @@
#include <cassert>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <utility>
@@ -375,9 +374,8 @@ void cmInstallTargetGenerator::GetInstallObjectNames(
std::string cmInstallTargetGenerator::GetDestination(
std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)
->Evaluate(this->Target->GetLocalGenerator(), config);
return cmGeneratorExpression::Evaluate(
this->Destination, this->Target->GetLocalGenerator(), config);
}
std::string cmInstallTargetGenerator::GetInstallFilename(
Source/cmJsonObjects.cxx
+4 -8
View File
@@ -32,7 +32,6 @@
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
@@ -357,10 +356,8 @@ static Json::Value DumpCTestInfo(cmLocalGenerator* lg, cmTest* testInfo,
}
// Remove any config specific variables from the output.
cmGeneratorExpression ge;
auto cge = ge.Parse(command);
const std::string& processed = cge->Evaluate(lg, config);
result[kCTEST_COMMAND] = processed;
result[kCTEST_COMMAND] =
cmGeneratorExpression::Evaluate(command, lg, config);
// Build up the list of properties that may have been specified
Json::Value properties = Json::arrayValue;
@@ -369,9 +366,8 @@ static Json::Value DumpCTestInfo(cmLocalGenerator* lg, cmTest* testInfo,
entry[kKEY_KEY] = prop.first;
// Remove config variables from the value too.
auto cge_value = ge.Parse(prop.second);
const std::string& processed_value = cge_value->Evaluate(lg, config);
entry[kVALUE_KEY] = processed_value;
entry[kVALUE_KEY] =
cmGeneratorExpression::Evaluate(prop.second, lg, config);
properties.append(entry);
}
result[kPROPERTIES_KEY] = properties;
Source/cmLocalGenerator.cxx
+4 -10
View File
@@ -48,7 +48,6 @@
#include <functional>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <sstream>
#include <unordered_set>
#include <utility>
@@ -925,10 +924,8 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
// to ON
if (char const* jmcExprGen =
target->GetProperty("VS_JUST_MY_CODE_DEBUGGING")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(jmcExprGen);
std::string isJMCEnabled = cge->Evaluate(this, config);
std::string isJMCEnabled =
cmGeneratorExpression::Evaluate(jmcExprGen, this, config);
if (cmIsOn(isJMCEnabled)) {
std::vector<std::string> optVec = cmExpandedList(jmc);
std::string jmcFlags;
@@ -1710,11 +1707,8 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
if (!msvcRuntimeLibraryValue) {
msvcRuntimeLibraryValue = msvcRuntimeLibraryDefault;
}
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(msvcRuntimeLibraryValue);
std::string const msvcRuntimeLibrary =
cge->Evaluate(this, config, false, target);
std::string const msvcRuntimeLibrary = cmGeneratorExpression::Evaluate(
msvcRuntimeLibraryValue, this, config, target);
if (!msvcRuntimeLibrary.empty()) {
if (const char* msvcRuntimeLibraryOptions =
this->Makefile->GetDefinition(
Source/cmLocalNinjaGenerator.cxx
+4 -6
View File
@@ -608,12 +608,10 @@ void cmLocalNinjaGenerator::AdditionalCleanFiles()
this->Makefile->GetProperty("ADDITIONAL_CLEAN_FILES")) {
std::vector<std::string> cleanFiles;
{
cmGeneratorExpression ge;
auto cge = ge.Parse(prop_value);
cmExpandList(
cge->Evaluate(this,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
cleanFiles);
cmExpandList(cmGeneratorExpression::Evaluate(
prop_value, this,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
cleanFiles);
}
std::string const& binaryDir = this->GetCurrentBinaryDirectory();
cmGlobalNinjaGenerator* gg = this->GetGlobalNinjaGenerator();
Source/cmLocalUnixMakefileGenerator3.cxx
+4 -6
View File
@@ -1083,12 +1083,10 @@ void cmLocalUnixMakefileGenerator3::AppendDirectoryCleanCommand(
// Look for additional files registered for cleaning in this directory.
if (const char* prop_value =
this->Makefile->GetProperty("ADDITIONAL_CLEAN_FILES")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop_value);
cmExpandList(
cge->Evaluate(this,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
cleanFiles);
cmExpandList(cmGeneratorExpression::Evaluate(
prop_value, this,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")),
cleanFiles);
}
if (cleanFiles.empty()) {
return;
Source/cmMakefileTargetGenerator.cxx
+4 -5
View File
@@ -154,11 +154,10 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
auto evaluatedFiles =
[this](const char* prop_value) -> std::vector<std::string> {
std::vector<std::string> files;
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop_value);
cmExpandList(cge->Evaluate(this->LocalGenerator, this->ConfigName, false,
this->GeneratorTarget, nullptr, nullptr),
files);
cmExpandList(
cmGeneratorExpression::Evaluate(prop_value, this->LocalGenerator,
this->ConfigName, this->GeneratorTarget),
files);
return files;
};
Source/cmNinjaTargetGenerator.cxx
+5 -8
View File
@@ -1317,14 +1317,11 @@ void cmNinjaTargetGenerator::AdditionalCleanFiles()
this->GeneratorTarget->GetProperty("ADDITIONAL_CLEAN_FILES")) {
cmLocalNinjaGenerator* lg = this->LocalGenerator;
std::vector<std::string> cleanFiles;
{
cmGeneratorExpression ge;
auto cge = ge.Parse(prop_value);
cmExpandList(cge->Evaluate(
lg, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"),
false, this->GeneratorTarget, nullptr, nullptr),
cleanFiles);
}
cmExpandList(cmGeneratorExpression::Evaluate(
prop_value, lg,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"),
this->GeneratorTarget),
cleanFiles);
std::string const& binaryDir = lg->GetCurrentBinaryDirectory();
cmGlobalNinjaGenerator* gg = lg->GetGlobalNinjaGenerator();
for (std::string const& cleanFile : cleanFiles) {
Source/cmVisualStudio10TargetGenerator.cxx
+16 -44
View File
@@ -1139,10 +1139,8 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues(Elem& e0)
std::string configType;
if (const char* vsConfigurationType =
this->GeneratorTarget->GetProperty("VS_CONFIGURATION_TYPE")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(vsConfigurationType);
configType = cge->Evaluate(this->LocalGenerator, c);
configType = cmGeneratorExpression::Evaluate(vsConfigurationType,
this->LocalGenerator, c);
} else {
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::SHARED_LIBRARY:
@@ -2447,49 +2445,32 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions(
if (ttype <= cmStateEnums::UTILITY) {
if (const char* workingDir = this->GeneratorTarget->GetProperty(
"VS_DEBUGGER_WORKING_DIRECTORY")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(workingDir);
std::string genWorkingDir =
cge->Evaluate(this->LocalGenerator, config);
std::string genWorkingDir = cmGeneratorExpression::Evaluate(
workingDir, this->LocalGenerator, config);
e1.WritePlatformConfigTag("LocalDebuggerWorkingDirectory", cond,
genWorkingDir);
}
if (const char* environment =
this->GeneratorTarget->GetProperty("VS_DEBUGGER_ENVIRONMENT")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(environment);
std::string genEnvironment =
cge->Evaluate(this->LocalGenerator, config);
std::string genEnvironment = cmGeneratorExpression::Evaluate(
environment, this->LocalGenerator, config);
e1.WritePlatformConfigTag("LocalDebuggerEnvironment", cond,
genEnvironment);
}
if (const char* debuggerCommand =
this->GeneratorTarget->GetProperty("VS_DEBUGGER_COMMAND")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(debuggerCommand);
std::string genDebuggerCommand =
cge->Evaluate(this->LocalGenerator, config);
std::string genDebuggerCommand = cmGeneratorExpression::Evaluate(
debuggerCommand, this->LocalGenerator, config);
e1.WritePlatformConfigTag("LocalDebuggerCommand", cond,
genDebuggerCommand);
}
if (const char* commandArguments = this->GeneratorTarget->GetProperty(
"VS_DEBUGGER_COMMAND_ARGUMENTS")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(commandArguments);
std::string genCommandArguments =
cge->Evaluate(this->LocalGenerator, config);
std::string genCommandArguments = cmGeneratorExpression::Evaluate(
commandArguments, this->LocalGenerator, config);
e1.WritePlatformConfigTag("LocalDebuggerCommandArguments", cond,
genCommandArguments);
}
@@ -3479,22 +3460,16 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
if (const char* nativeLibDirectoriesExpression =
this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(nativeLibDirectoriesExpression);
std::string nativeLibDirs =
cge->Evaluate(this->LocalGenerator, configName);
std::string nativeLibDirs = cmGeneratorExpression::Evaluate(
nativeLibDirectoriesExpression, this->LocalGenerator, configName);
e2.Element("NativeLibDirectories", nativeLibDirs);
}
if (const char* nativeLibDependenciesExpression =
this->GeneratorTarget->GetProperty(
"ANDROID_NATIVE_LIB_DEPENDENCIES")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(nativeLibDependenciesExpression);
std::string nativeLibDeps =
cge->Evaluate(this->LocalGenerator, configName);
std::string nativeLibDeps = cmGeneratorExpression::Evaluate(
nativeLibDependenciesExpression, this->LocalGenerator, configName);
e2.Element("NativeLibDependencies", nativeLibDeps);
}
@@ -3505,11 +3480,8 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
if (const char* jarDirectoriesExpression =
this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) {
cmGeneratorExpression ge;
std::unique_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(jarDirectoriesExpression);
std::string jarDirectories =
cge->Evaluate(this->LocalGenerator, configName);
std::string jarDirectories = cmGeneratorExpression::Evaluate(
jarDirectoriesExpression, this->LocalGenerator, configName);
e2.Element("JarDirectories", jarDirectories);
}