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

Merge topic 'refactor-evaluation-files' 

12c3f248 cmGeneratorExpressionEvaluationFile: Require generator context.
6c0e9ee2 cmMakefile: Store EvaluationFiles.
This commit is contained in:
Brad King 2015-08-06 09:38:22 -04:00 committed by CMake Topic Stage
parent 4f0a6d462e 12c3f24827
commit 370e2c6785
10 changed files with 129 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Source/cmFileCommand.cxx
View File

@ -3573,11 +3573,8 @@ void cmFileCommand::AddEvaluationFile(const std::string &inputName,
cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge
= conditionGe.Parse(condition);
this->Makefile->GetGlobalGenerator()->AddEvaluationFile(inputName,
outputCge,
this->Makefile,
conditionCge,
inputIsContent);
this->Makefile->AddEvaluationFile(inputName, outputCge,
conditionCge, inputIsContent);
}
//----------------------------------------------------------------------------

40
Source/cmGeneratorExpressionEvaluationFile.cxx
View File

@ -25,19 +25,18 @@
cmGeneratorExpressionEvaluationFile::cmGeneratorExpressionEvaluationFile(
const std::string &input,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
cmMakefile *makefile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent)
: Input(input),
OutputFileExpr(outputFileExpr),
Makefile(makefile),
Condition(condition),
InputIsContent(inputIsContent)
{
}
//----------------------------------------------------------------------------
void cmGeneratorExpressionEvaluationFile::Generate(const std::string& config,
void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg,
const std::string& config,
const std::string& lang,
cmCompiledGeneratorExpression* inputExpression,
std::map<std::string, std::string> &outputFiles, mode_t perm)
@ -45,7 +44,8 @@ void cmGeneratorExpressionEvaluationFile::Generate(const std::string& config,
std::string rawCondition = this->Condition->GetInput();
if (!rawCondition.empty())
{
std::string condResult = this->Condition->Evaluate(this->Makefile, config,
std::string condResult = this->Condition->Evaluate(lg->GetMakefile(),
config,
false, 0, 0, 0, lang);
if (condResult == "0")
{
@ -56,16 +56,17 @@ void cmGeneratorExpressionEvaluationFile::Generate(const std::string& config,
std::ostringstream e;
e << "Evaluation file condition \"" << rawCondition << "\" did "
"not evaluate to valid content. Got \"" << condResult << "\".";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
lg->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}
}
const std::string outputFileName
= this->OutputFileExpr->Evaluate(this->Makefile, config,
= this->OutputFileExpr->Evaluate(lg->GetMakefile(), config,
false, 0, 0, 0, lang);
const std::string outputContent
= inputExpression->Evaluate(this->Makefile, config,
= inputExpression->Evaluate(lg->GetMakefile(),
config,
false, 0, 0, 0, lang);
std::map<std::string, std::string>::iterator it
@ -81,11 +82,11 @@ void cmGeneratorExpressionEvaluationFile::Generate(const std::string& config,
e << "Evaluation file to be written multiple times for different "
"configurations or languages with different content:\n "
<< outputFileName;
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
lg->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}
this->Makefile->AddCMakeOutputFile(outputFileName.c_str());
lg->GetMakefile()->AddCMakeOutputFile(outputFileName.c_str());
this->Files.push_back(outputFileName);
outputFiles[outputFileName] = outputContent;
@ -100,18 +101,19 @@ void cmGeneratorExpressionEvaluationFile::Generate(const std::string& config,
//----------------------------------------------------------------------------
void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
std::string const& config)
cmLocalGenerator *lg, std::string const& config)
{
std::vector<std::string> enabledLanguages;
cmGlobalGenerator *gg = this->Makefile->GetGlobalGenerator();
cmGlobalGenerator *gg = lg->GetGlobalGenerator();
gg->GetEnabledLanguages(enabledLanguages);
for(std::vector<std::string>::const_iterator le = enabledLanguages.begin();
le != enabledLanguages.end(); ++le)
{
std::string name = this->OutputFileExpr->Evaluate(this->Makefile, config,
std::string name = this->OutputFileExpr->Evaluate(lg->GetMakefile(),
config,
false, 0, 0, 0, *le);
cmSourceFile* sf = this->Makefile->GetOrCreateSource(name);
cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name);
sf->SetProperty("GENERATED", "1");
gg->SetFilenameTargetDepends(sf,
@ -120,7 +122,7 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
}
//----------------------------------------------------------------------------
void cmGeneratorExpressionEvaluationFile::Generate()
void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator *lg)
{
mode_t perm = 0;
std::string inputContent;
@ -130,14 +132,14 @@ void cmGeneratorExpressionEvaluationFile::Generate()
}
else
{
this->Makefile->AddCMakeDependFile(this->Input.c_str());
lg->GetMakefile()->AddCMakeDependFile(this->Input.c_str());
cmSystemTools::GetPermissions(this->Input.c_str(), perm);
cmsys::ifstream fin(this->Input.c_str());
if(!fin)
{
std::ostringstream e;
e << "Evaluation file \"" << this->Input << "\" cannot be read.";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
lg->GetMakefile()->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}
@ -159,7 +161,7 @@ void cmGeneratorExpressionEvaluationFile::Generate()
std::map<std::string, std::string> outputFiles;
std::vector<std::string> allConfigs;
this->Makefile->GetConfigurations(allConfigs);
lg->GetMakefile()->GetConfigurations(allConfigs);
if (allConfigs.empty())
{
@ -167,7 +169,7 @@ void cmGeneratorExpressionEvaluationFile::Generate()
}
std::vector<std::string> enabledLanguages;
cmGlobalGenerator *gg = this->Makefile->GetGlobalGenerator();
cmGlobalGenerator *gg = lg->GetGlobalGenerator();
gg->GetEnabledLanguages(enabledLanguages);
for(std::vector<std::string>::const_iterator le = enabledLanguages.begin();
@ -176,7 +178,7 @@ void cmGeneratorExpressionEvaluationFile::Generate()
for(std::vector<std::string>::const_iterator li = allConfigs.begin();
li != allConfigs.end(); ++li)
{
this->Generate(*li, *le, inputExpression.get(), outputFiles, perm);
this->Generate(lg, *li, *le, inputExpression.get(), outputFiles, perm);
if(cmSystemTools::GetFatalErrorOccured())
{
return;

11
Source/cmGeneratorExpressionEvaluationFile.h
View File

@ -18,31 +18,32 @@
#include "cmGeneratorExpression.h"
class cmLocalGenerator;
//----------------------------------------------------------------------------
class cmGeneratorExpressionEvaluationFile
{
public:
cmGeneratorExpressionEvaluationFile(const std::string &input,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
cmMakefile *makefile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
void Generate();
void Generate(cmLocalGenerator* lg);
std::vector<std::string> GetFiles() const { return this->Files; }
void CreateOutputFile(std::string const& config);
void CreateOutputFile(cmLocalGenerator* lg, std::string const& config);
private:
void Generate(const std::string& config, const std::string& lang,
void Generate(cmLocalGenerator* lg, const std::string& config,
const std::string& lang,
cmCompiledGeneratorExpression* inputExpression,
std::map<std::string, std::string> &outputFiles, mode_t perm);
private:
const std::string Input;
const cmsys::auto_ptr<cmCompiledGeneratorExpression> OutputFileExpr;
cmMakefile *Makefile;
const cmsys::auto_ptr<cmCompiledGeneratorExpression> Condition;
std::vector<std::string> Files;
const bool InputIsContent;

56
Source/cmGlobalGenerator.cxx
View File

@ -44,7 +44,6 @@ typedef struct {
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGeneratorExpression.h"
#include "cmGeneratorExpressionEvaluationFile.h"
#include "cmExportBuildFileGenerator.h"
#include "cmCPackPropertiesGenerator.h"
#include "cmAlgorithms.h"
@ -1597,9 +1596,6 @@ void cmGlobalGenerator::ClearGeneratorMembers()
cmDeleteAll(this->GeneratorTargets);
this->GeneratorTargets.clear();
cmDeleteAll(this->EvaluationFiles);
this->EvaluationFiles.clear();
cmDeleteAll(this->BuildExportSets);
this->BuildExportSets.clear();
@ -3068,61 +3064,21 @@ cmGlobalGenerator::GetFilenameTargetDepends(cmSourceFile* sf) const {
void cmGlobalGenerator::CreateEvaluationSourceFiles(
std::string const& config) const
{
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = this->EvaluationFiles.begin();
li != this->EvaluationFiles.end();
++li)
unsigned int i;
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
(*li)->CreateOutputFile(config);
this->LocalGenerators[i]->CreateEvaluationFileOutputs(config);
}
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::AddEvaluationFile(const std::string &inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputExpr,
cmMakefile *makefile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent)
{
this->EvaluationFiles.push_back(
new cmGeneratorExpressionEvaluationFile(inputFile, outputExpr,
makefile, condition,
inputIsContent));
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::ProcessEvaluationFiles()
{
std::vector<std::string> generatedFiles;
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = this->EvaluationFiles.begin();
li != this->EvaluationFiles.end();
++li)
unsigned int i;
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
(*li)->Generate();
if (cmSystemTools::GetFatalErrorOccured())
{
return;
}
std::vector<std::string> files = (*li)->GetFiles();
std::sort(files.begin(), files.end());
std::vector<std::string> intersection;
std::set_intersection(files.begin(), files.end(),
generatedFiles.begin(), generatedFiles.end(),
std::back_inserter(intersection));
if (!intersection.empty())
{
cmSystemTools::Error("Files to be generated by multiple different "
"commands: ", cmWrap('"', intersection, '"', " ").c_str());
return;
}
generatedFiles.insert(generatedFiles.end(),
files.begin(), files.end());
std::vector<std::string>::iterator newIt =
generatedFiles.end() - files.size();
std::inplace_merge(generatedFiles.begin(), newIt, generatedFiles.end());
this->LocalGenerators[i]->ProcessEvaluationFiles(generatedFiles);
}
}

8
Source/cmGlobalGenerator.h
View File

@ -34,7 +34,6 @@
class cmake;
class cmGeneratorTarget;
class cmGeneratorExpressionEvaluationFile;
class cmMakefile;
class cmLocalGenerator;
class cmExternalMakefileProjectGenerator;
@ -334,12 +333,6 @@ public:
static std::string EscapeJSON(const std::string& s);
void AddEvaluationFile(const std::string &inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
cmMakefile *makefile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
void ProcessEvaluationFiles();
std::map<std::string, cmExportBuildFileGenerator*>& GetBuildExportSets()
@ -436,7 +429,6 @@ protected:
TargetMap TotalTargets;
TargetMap AliasTargets;
TargetMap ImportedTargets;
std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles;
const char* GetPredefinedTargetsFolder();
virtual bool UseFolderProperty();

16
Source/cmGlobalNinjaGenerator.cxx
View File

@ -1055,23 +1055,21 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
{
knownDependencies.insert( ng->ConvertToNinjaPath( *j ) );
}
}
knownDependencies.insert( "CMakeCache.txt" );
std::vector<cmGeneratorExpressionEvaluationFile*> const& ef =
(*i)->GetMakefile()->GetEvaluationFiles();
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = this->EvaluationFiles.begin();
li != this->EvaluationFiles.end();
++li)
li = ef.begin(); li != ef.end(); ++li)
{
//get all the files created by generator expressions and convert them
//to ninja paths
std::vector<std::string> files = (*li)->GetFiles();
typedef std::vector<std::string>::const_iterator vect_it;
for(vect_it j = files.begin(); j != files.end(); ++j)
std::vector<std::string> evaluationFiles = (*li)->GetFiles();
for(vect_it j = evaluationFiles.begin(); j != evaluationFiles.end(); ++j)
{
knownDependencies.insert( ng->ConvertToNinjaPath( *j ) );
}
}
}
knownDependencies.insert( "CMakeCache.txt" );
for(TargetAliasMap::const_iterator i= this->TargetAliases.begin();
i != this->TargetAliases.end();

48
Source/cmLocalGenerator.cxx
View File

@ -16,6 +16,7 @@
#include "cmGlobalGenerator.h"
#include "cmInstallGenerator.h"
#include "cmInstallFilesGenerator.h"
#include "cmGeneratorExpressionEvaluationFile.h"
#include "cmInstallScriptGenerator.h"
#include "cmInstallTargetGenerator.h"
#include "cmMakefile.h"
@ -212,6 +213,53 @@ void cmLocalGenerator::GenerateTestFiles()
}
}
void cmLocalGenerator::CreateEvaluationFileOutputs(std::string const& config)
{
std::vector<cmGeneratorExpressionEvaluationFile*> ef =
this->Makefile->GetEvaluationFiles();
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = ef.begin(); li != ef.end(); ++li)
{
(*li)->CreateOutputFile(this, config);
}
}
void cmLocalGenerator::ProcessEvaluationFiles(
std::vector<std::string>& generatedFiles)
{
std::vector<cmGeneratorExpressionEvaluationFile*> ef =
this->Makefile->GetEvaluationFiles();
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = ef.begin();
li != ef.end();
++li)
{
(*li)->Generate(this);
if (cmSystemTools::GetFatalErrorOccured())
{
return;
}
std::vector<std::string> files = (*li)->GetFiles();
std::sort(files.begin(), files.end());
std::vector<std::string> intersection;
std::set_intersection(files.begin(), files.end(),
generatedFiles.begin(), generatedFiles.end(),
std::back_inserter(intersection));
if (!intersection.empty())
{
cmSystemTools::Error("Files to be generated by multiple different "
"commands: ", cmWrap('"', intersection, '"', " ").c_str());
return;
}
generatedFiles.insert(generatedFiles.end(), files.begin(), files.end());
std::vector<std::string>::iterator newIt =
generatedFiles.end() - files.size();
std::inplace_merge(generatedFiles.begin(), newIt, generatedFiles.end());
}
}
//----------------------------------------------------------------------------
void cmLocalGenerator::GenerateInstallRules()
{

2
Source/cmLocalGenerator.h
View File

@ -305,6 +305,8 @@ public:
void IssueMessage(cmake::MessageType t, std::string const& text) const;
void CreateEvaluationFileOutputs(const std::string& config);
void ProcessEvaluationFiles(std::vector<std::string>& generatedFiles);
void ComputeObjectMaxPath();
protected:

21
Source/cmMakefile.cxx
View File

@ -21,6 +21,7 @@
#include "cmState.h"
#include "cmOutputConverter.h"
#include "cmFunctionBlocker.h"
#include "cmGeneratorExpressionEvaluationFile.h"
#include "cmListFileCache.h"
#include "cmCommandArgumentParserHelper.h"
#include "cmGeneratorExpression.h"
@ -235,6 +236,9 @@ cmMakefile::~cmMakefile()
cmDeleteAll(this->ImportedTargetsOwned);
cmDeleteAll(this->FinalPassCommands);
cmDeleteAll(this->FunctionBlockers);
cmDeleteAll(this->EvaluationFiles);
this->EvaluationFiles.clear();
this->FunctionBlockers.clear();
if (this->PolicyStack.size() != 1)
{
@ -777,6 +781,23 @@ void cmMakefile::EnforceDirectoryLevelRules() const
}
}
void cmMakefile::AddEvaluationFile(const std::string& inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent)
{
this->EvaluationFiles.push_back(
new cmGeneratorExpressionEvaluationFile(inputFile, outputName,
condition,
inputIsContent));
}
std::vector<cmGeneratorExpressionEvaluationFile*>
cmMakefile::GetEvaluationFiles() const
{
return this->EvaluationFiles;
}
namespace
{
struct file_not_persistent

9
Source/cmMakefile.h
View File

@ -52,6 +52,7 @@ class cmVariableWatch;
class cmake;
class cmMakefileCall;
class cmCMakePolicyCommand;
class cmGeneratorExpressionEvaluationFile;
/** \class cmMakefile
* \brief Process the input CMakeLists.txt file.
@ -799,6 +800,12 @@ public:
void EnforceDirectoryLevelRules() const;
void AddEvaluationFile(const std::string &inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const;
protected:
// add link libraries and directories to the target
void AddGlobalLinkInformation(const std::string& name, cmTarget& target);
@ -895,6 +902,8 @@ private:
std::vector<cmMakefile*> UnConfiguredDirectories;
std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles;
cmPropertyMap Properties;
std::vector<cmCommandContext const*> ContextStack;