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

Merge topic 'cmMakefile-Configure' 

7657e8b1 cmMakefile: Introduce a local cmMakefile variable.
4e8f242d cmMakefile: Store unconfigured cmMakefiles.
d65e0123 cmMakefile: Implement ConfigureSubDirectory in terms of cmMakefile.
f059ed16 cmMakefile: Move Configure responsibility from cmLocalGenerator.
a653611d cmake: Replace CurrentLocalGenerator concept with CurrentMakefile.
69a038a9 cmMakefile: Refactor directories specified with the subdirs command.
08637970 cmLocalGenerator: ComputeObjectMaxPath just before generating.
27e11c6f Merge Configure state with GeneratingBuildSystem state.
363caa2f cmLocalGenerator: De-virtualize Configure().
This commit is contained in:
Brad King 2015-06-04 09:13:35 -04:00 committed by CMake Topic Stage
parent d6fe79f3ab 7657e8b1df
commit 0886880e3b
13 changed files with 115 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Source/cmGlobalGenerator.cxx
View File

@ -70,7 +70,7 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm)
this->TryCompileTimeout = 0;
this->ExtraGenerator = 0;
this->CurrentLocalGenerator = 0;
this->CurrentMakefile = 0;
this->TryCompileOuterMakefile = 0;
}
@ -1101,7 +1101,7 @@ void cmGlobalGenerator::Configure()
this->CMakeInstance->GetHomeOutputDirectory());
// now do it
lg->Configure();
lg->GetMakefile()->Configure();
// update the cache entry for the number of local generators, this is used
// for progress
@ -1218,6 +1218,7 @@ void cmGlobalGenerator::Generate()
this->CreateDefaultGlobalTargets(&globalTargets);
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
this->LocalGenerators[i]->ComputeObjectMaxPath();
cmMakefile* mf = this->LocalGenerators[i]->GetMakefile();
cmTargets* targets = &(mf->GetTargets());
cmTargets::iterator tit;
@ -1275,8 +1276,7 @@ void cmGlobalGenerator::Generate()
// Generate project files
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
this->LocalGenerators[i]->GetMakefile()->SetGeneratingBuildSystem();
this->SetCurrentLocalGenerator(this->LocalGenerators[i]);
this->SetCurrentMakefile(this->LocalGenerators[i]->GetMakefile());
this->LocalGenerators[i]->Generate();
if(!this->LocalGenerators[i]->GetMakefile()->IsOn(
"CMAKE_SKIP_INSTALL_RULES"))
@ -1288,7 +1288,7 @@ void cmGlobalGenerator::Generate()
(static_cast<float>(i)+1.0f)/
static_cast<float>(this->LocalGenerators.size()));
}
this->SetCurrentLocalGenerator(0);
this->SetCurrentMakefile(0);
if(!this->GenerateCPackPropertiesFile())
{

12
Source/cmGlobalGenerator.h
View File

@ -168,11 +168,13 @@ public:
const std::vector<cmLocalGenerator *>& GetLocalGenerators() const {
return this->LocalGenerators;}
cmLocalGenerator* GetCurrentLocalGenerator()
{return this->CurrentLocalGenerator;}
cmMakefile* GetCurrentMakefile() const
{
return this->CurrentMakefile;
}
void SetCurrentLocalGenerator(cmLocalGenerator* lg)
{this->CurrentLocalGenerator = lg;}
void SetCurrentMakefile(cmMakefile* mf)
{this->CurrentMakefile = mf;}
void AddLocalGenerator(cmLocalGenerator *lg);
@ -404,7 +406,7 @@ protected:
std::string ConfiguredFilesPath;
cmake *CMakeInstance;
std::vector<cmLocalGenerator *> LocalGenerators;
cmLocalGenerator* CurrentLocalGenerator;
cmMakefile* CurrentMakefile;
// map from project name to vector of local generators in that project
std::map<std::string, std::vector<cmLocalGenerator*> > ProjectMap;
std::map<cmLocalGenerator*, std::set<cmTarget const*> >

74
Source/cmLocalGenerator.cxx
View File

@ -59,7 +59,6 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg,
this->Makefile = new cmMakefile(this);
this->LinkScriptShell = false;
this->Configured = false;
this->EmitUniversalBinaryFlags = true;
this->BackwardsCompatibility = 0;
this->BackwardsCompatibilityFinal = false;
@ -75,72 +74,6 @@ bool cmLocalGenerator::IsRootMakefile() const
return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid();
}
//----------------------------------------------------------------------------
class cmLocalGeneratorCurrent
{
cmGlobalGenerator* GG;
cmLocalGenerator* LG;
cmState::Snapshot Snapshot;
public:
cmLocalGeneratorCurrent(cmLocalGenerator* lg)
{
this->GG = lg->GetGlobalGenerator();
this->LG = this->GG->GetCurrentLocalGenerator();
this->Snapshot = this->GG->GetCMakeInstance()->GetCurrentSnapshot();
this->GG->GetCMakeInstance()->SetCurrentSnapshot(lg->GetStateSnapshot());
this->GG->SetCurrentLocalGenerator(lg);
#if defined(CMAKE_BUILD_WITH_CMAKE)
this->GG->GetFileLockPool().PushFileScope();
#endif
}
~cmLocalGeneratorCurrent()
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
this->GG->GetFileLockPool().PopFileScope();
#endif
this->GG->SetCurrentLocalGenerator(this->LG);
this->GG->GetCMakeInstance()->SetCurrentSnapshot(this->Snapshot);
}
};
//----------------------------------------------------------------------------
void cmLocalGenerator::Configure()
{
// Manage the global generator's current local generator.
cmLocalGeneratorCurrent clg(this);
static_cast<void>(clg);
// make sure the CMakeFiles dir is there
std::string filesDir = this->StateSnapshot.GetCurrentBinaryDirectory();
filesDir += cmake::GetCMakeFilesDirectory();
cmSystemTools::MakeDirectory(filesDir.c_str());
std::string currentStart = this->StateSnapshot.GetCurrentSourceDirectory();
currentStart += "/CMakeLists.txt";
assert(cmSystemTools::FileExists(currentStart.c_str(), true));
this->Makefile->ProcessBuildsystemFile(currentStart.c_str());
// at the end of the ReadListFile handle any old style subdirs
// first get all the subdirectories
std::vector<cmLocalGenerator *> subdirs = this->GetChildren();
// for each subdir recurse
std::vector<cmLocalGenerator *>::iterator sdi = subdirs.begin();
for (; sdi != subdirs.end(); ++sdi)
{
if (!(*sdi)->Configured)
{
this->Makefile->ConfigureSubDirectory(*sdi);
}
}
this->Makefile->AddCMakeDependFilesFromUser();
this->ComputeObjectMaxPath();
this->Configured = true;
}
//----------------------------------------------------------------------------
void cmLocalGenerator::ComputeObjectMaxPath()
{
@ -3179,11 +3112,6 @@ bool cmLocalGenerator::IsNMake() const
return this->GetState()->UseNMake();
}
void cmLocalGenerator::SetConfiguredCMP0014(bool configured)
{
this->Configured = configured;
}
//----------------------------------------------------------------------------
std::string
cmLocalGenerator
@ -3465,7 +3393,7 @@ cmIML_INT_uint64_t cmLocalGenerator::GetBackwardsCompatibility()
}
}
this->BackwardsCompatibility = CMake_VERSION_ENCODE(major, minor, patch);
this->BackwardsCompatibilityFinal = this->Configured;
this->BackwardsCompatibilityFinal = this->Makefile->IsConfigured();
}
return this->BackwardsCompatibility;

11
Source/cmLocalGenerator.h
View File

@ -46,12 +46,6 @@ public:
*/
virtual void Generate() {}
/**
* Process the CMakeLists files for this directory to fill in the
* Makefile ivar
*/
virtual void Configure();
/**
* Calls TraceVSDependencies() on all targets of this generator.
*/
@ -383,8 +377,7 @@ public:
bool IsMinGWMake() const;
bool IsNMake() const;
void SetConfiguredCMP0014(bool configured);
void ComputeObjectMaxPath();
protected:
///! put all the libraries for a target on into the given stream
void OutputLinkLibraries(std::string& linkLibraries,
@ -430,7 +423,6 @@ protected:
std::string& CreateSafeUniqueObjectFileName(const std::string& sin,
std::string const& dir_max);
void ComputeObjectMaxPath();
virtual std::string ConvertToLinkReference(std::string const& lib,
OutputFormat format = SHELL);
@ -451,7 +443,6 @@ protected:
std::set<cmTarget const*> WarnCMP0063;
bool LinkScriptShell;
bool Configured;
bool EmitUniversalBinaryFlags;
// Hack for ExpandRuleVariable until object-oriented version is

28
Source/cmLocalNinjaGenerator.cxx
View File

@ -41,6 +41,15 @@ cmLocalNinjaGenerator::~cmLocalNinjaGenerator()
void cmLocalNinjaGenerator::Generate()
{
// Compute the path to use when referencing the current output
// directory from the top output directory.
this->HomeRelativeOutputPath =
this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT);
if(this->HomeRelativeOutputPath == ".")
{
this->HomeRelativeOutputPath = "";
}
this->SetConfigName();
this->WriteProcessedMakefile(this->GetBuildFileStream());
@ -91,25 +100,6 @@ void cmLocalNinjaGenerator::Generate()
this->WriteCustomCommandBuildStatements();
}
// Implemented in:
// cmLocalUnixMakefileGenerator3.
// Used in:
// Source/cmMakefile.cxx
// Source/cmGlobalGenerator.cxx
void cmLocalNinjaGenerator::Configure()
{
// Compute the path to use when referencing the current output
// directory from the top output directory.
this->HomeRelativeOutputPath =
this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT);
if(this->HomeRelativeOutputPath == ".")
{
this->HomeRelativeOutputPath = "";
}
this->cmLocalGenerator::Configure();
}
// TODO: Picked up from cmLocalUnixMakefileGenerator3. Refactor it.
std::string cmLocalNinjaGenerator
::GetTargetDirectory(cmTarget const& target) const

2
Source/cmLocalNinjaGenerator.h
View File

@ -38,8 +38,6 @@ public:
virtual void Generate();
virtual void Configure();
virtual std::string GetTargetDirectory(cmTarget const& target) const;
const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const;

7
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -98,7 +98,7 @@ cmLocalUnixMakefileGenerator3::~cmLocalUnixMakefileGenerator3()
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::Configure()
void cmLocalUnixMakefileGenerator3::Generate()
{
// Compute the path to use when referencing the current output
// directory from the top output directory.
@ -112,12 +112,7 @@ void cmLocalUnixMakefileGenerator3::Configure()
{
this->HomeRelativeOutputPath += "/";
}
this->cmLocalGenerator::Configure();
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::Generate()
{
// Store the configuration name that will be generated.
if(const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
{

6
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -39,12 +39,6 @@ public:
cmState::Snapshot snapshot);
virtual ~cmLocalUnixMakefileGenerator3();
/**
* Process the CMakeLists files for this directory to fill in the
* Makefile ivar
*/
virtual void Configure();
/**
* Generate the makefile for this directory.
*/

85
Source/cmMakefile.cxx
View File

@ -146,7 +146,7 @@ cmMakefile::cmMakefile(cmLocalGenerator* localGenerator)
this->WarnUnused = this->GetCMakeInstance()->GetWarnUnused();
this->CheckSystemVars = this->GetCMakeInstance()->GetCheckSystemVars();
this->GeneratingBuildSystem = false;
this->Configured = false;
this->SuppressWatches = false;
// Setup the default include file regular expression (match everything).
@ -1562,10 +1562,68 @@ void cmMakefile::InitializeFromParent()
this->ImportedTargets = parent->ImportedTargets;
}
void cmMakefile::ConfigureSubDirectory(cmLocalGenerator *lg2)
//----------------------------------------------------------------------------
class cmMakefileCurrent
{
lg2->GetMakefile()->InitializeFromParent();
std::string currentStart = lg2->GetMakefile()->GetCurrentSourceDirectory();
cmGlobalGenerator* GG;
cmMakefile* MF;
cmState::Snapshot Snapshot;
public:
cmMakefileCurrent(cmMakefile* mf)
{
this->GG = mf->GetGlobalGenerator();
this->MF = this->GG->GetCurrentMakefile();
this->Snapshot = this->GG->GetCMakeInstance()->GetCurrentSnapshot();
this->GG->GetCMakeInstance()->SetCurrentSnapshot(
this->GG->GetCMakeInstance()->GetCurrentSnapshot());
this->GG->SetCurrentMakefile(mf);
#if defined(CMAKE_BUILD_WITH_CMAKE)
this->GG->GetFileLockPool().PushFileScope();
#endif
}
~cmMakefileCurrent()
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
this->GG->GetFileLockPool().PopFileScope();
#endif
this->GG->SetCurrentMakefile(this->MF);
this->GG->GetCMakeInstance()->SetCurrentSnapshot(this->Snapshot);
}
};
//----------------------------------------------------------------------------
void cmMakefile::Configure()
{
cmMakefileCurrent cmf(this);
// make sure the CMakeFiles dir is there
std::string filesDir = this->StateSnapshot.GetCurrentBinaryDirectory();
filesDir += cmake::GetCMakeFilesDirectory();
cmSystemTools::MakeDirectory(filesDir.c_str());
std::string currentStart = this->StateSnapshot.GetCurrentSourceDirectory();
currentStart += "/CMakeLists.txt";
assert(cmSystemTools::FileExists(currentStart.c_str(), true));
this->ProcessBuildsystemFile(currentStart.c_str());
// at the end handle any old style subdirs
std::vector<cmMakefile*> subdirs = this->UnConfiguredDirectories;
// for each subdir recurse
std::vector<cmMakefile*>::iterator sdi = subdirs.begin();
for (; sdi != subdirs.end(); ++sdi)
{
this->ConfigureSubDirectory(*sdi);
}
this->AddCMakeDependFilesFromUser();
this->SetConfigured();
}
void cmMakefile::ConfigureSubDirectory(cmMakefile *mf)
{
mf->InitializeFromParent();
std::string currentStart = mf->GetCurrentSourceDirectory();
if (this->GetCMakeInstance()->GetDebugOutput())
{
std::string msg=" Entering ";
@ -1603,11 +1661,12 @@ void cmMakefile::ConfigureSubDirectory(cmLocalGenerator *lg2)
// NEW behavior prints the error.
this->IssueMessage(cmake::FATAL_ERROR, e.str());
}
lg2->SetConfiguredCMP0014(true);
mf->SetConfigured();
return;
}
// finally configure the subdir
lg2->Configure();
mf->Configure();
if (this->GetCMakeInstance()->GetDebugOutput())
{
std::string msg=" Returning to ";
@ -1635,17 +1694,23 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath,
->MakeLocalGenerator(newSnapshot, this->LocalGenerator);
this->GetGlobalGenerator()->AddLocalGenerator(lg2);
cmMakefile* subMf = lg2->GetMakefile();
// set the subdirs start dirs
lg2->GetMakefile()->SetCurrentSourceDirectory(srcPath);
lg2->GetMakefile()->SetCurrentBinaryDirectory(binPath);
subMf->SetCurrentSourceDirectory(srcPath);
subMf->SetCurrentBinaryDirectory(binPath);
if(excludeFromAll)
{
lg2->GetMakefile()->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
subMf->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
}
if (immediate)
{
this->ConfigureSubDirectory(lg2);
this->ConfigureSubDirectory(subMf);
}
else
{
this->UnConfiguredDirectories.push_back(subMf);
}
}

12
Source/cmMakefile.h
View File

@ -270,10 +270,12 @@ public:
bool excludeFromAll,
bool immediate);
void Configure();
/**
* Configure a subdirectory
*/
void ConfigureSubDirectory(cmLocalGenerator *);
void ConfigureSubDirectory(cmMakefile* mf);
/**
* Add an include directory to the build.
@ -782,8 +784,8 @@ public:
return this->CompileDefinitionsEntries;
}
bool IsGeneratingBuildSystem() const { return this->GeneratingBuildSystem; }
void SetGeneratingBuildSystem(){ this->GeneratingBuildSystem = true; }
bool IsConfigured() const { return this->Configured; }
void SetConfigured(){ this->Configured = true; }
void AddQtUiFileWithOptions(cmSourceFile *sf);
std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const;
@ -921,6 +923,8 @@ private:
mutable cmsys::RegularExpression cmAtVarRegex;
mutable cmsys::RegularExpression cmNamedCurly;
std::vector<cmMakefile*> UnConfiguredDirectories;
cmPropertyMap Properties;
// Unused variable flags
@ -995,7 +999,7 @@ private:
long line,
bool removeEmpty,
bool replaceAt) const;
bool GeneratingBuildSystem;
bool Configured;
/**
* Old version of GetSourceFileWithOutput(const std::string&) kept for
* backward-compatibility. It implements a linear search and support

2
Source/cmQtAutoGenerators.cxx
View File

@ -1215,7 +1215,7 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory,
cmLocalGenerator* lg = gg.MakeLocalGenerator();
lg->GetMakefile()->SetCurrentBinaryDirectory(targetDirectory);
lg->GetMakefile()->SetCurrentSourceDirectory(targetDirectory);
gg.SetCurrentLocalGenerator(lg);
gg.SetCurrentMakefile(lg->GetMakefile());
this->ReadAutogenInfoFile(lg->GetMakefile(), targetDirectory, config);
this->ReadOldMocDefinitionsFile(lg->GetMakefile(), targetDirectory);

12
Source/cmTarget.cxx
View File

@ -764,7 +764,7 @@ void cmTarget::GetSourceFiles(std::vector<std::string> &files,
"SOURCES")
!= debugProperties.end();
if (this->Makefile->IsGeneratingBuildSystem())
if (this->Makefile->IsConfigured())
{
this->DebugSourcesDone = true;
}
@ -2106,7 +2106,7 @@ cmTarget::GetIncludeDirectories(const std::string& config,
"INCLUDE_DIRECTORIES")
!= debugProperties.end();
if (this->Makefile->IsGeneratingBuildSystem())
if (this->Makefile->IsConfigured())
{
this->DebugIncludesDone = true;
}
@ -2277,7 +2277,7 @@ void cmTarget::GetCompileOptions(std::vector<std::string> &result,
"COMPILE_OPTIONS")
!= debugProperties.end();
if (this->Makefile->IsGeneratingBuildSystem())
if (this->Makefile->IsConfigured())
{
this->DebugCompileOptionsDone = true;
}
@ -2348,7 +2348,7 @@ void cmTarget::GetCompileDefinitions(std::vector<std::string> &list,
"COMPILE_DEFINITIONS")
!= debugProperties.end();
if (this->Makefile->IsGeneratingBuildSystem())
if (this->Makefile->IsConfigured())
{
this->DebugCompileDefinitionsDone = true;
}
@ -2449,7 +2449,7 @@ void cmTarget::GetCompileFeatures(std::vector<std::string> &result,
"COMPILE_FEATURES")
!= debugProperties.end();
if (this->Makefile->IsGeneratingBuildSystem())
if (this->Makefile->IsConfigured())
{
this->DebugCompileFeaturesDone = true;
}
@ -4857,7 +4857,7 @@ cmTarget::ReportPropertyOrigin(const std::string &p,
p)
!= debugProperties.end();
if (this->Makefile->IsGeneratingBuildSystem())
if (this->Makefile->IsConfigured())
{
this->DebugCompatiblePropertiesDone[p] = true;
}

7
Source/cmakemain.cxx
View File

@ -113,12 +113,7 @@ static cmMakefile* cmakemainGetMakefile(void *clientdata)
cmGlobalGenerator* gg=cm->GetGlobalGenerator();
if (gg)
{
cmLocalGenerator* lg=gg->GetCurrentLocalGenerator();
if (lg)
{
cmMakefile* mf = lg->GetMakefile();
return mf;
}
return gg->GetCurrentMakefile();
}
}
return 0;