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

Merge topic 'constify' 

2cbf0311 cmGlobalGenerator: Make SelectMakeProgram const.
b4ff38a5 cmGlobalGenerator: Make CheckALLOW_DUPLICATE_CUSTOM_TARGETS const
8aeddf1f cmGlobalGenerator: Make some API const.
8fd0f2a7 cmGeneratorTarget: Hold a const global generator.
46315320 cmComputeLinkDepends: Hold a const global generator.
This commit is contained in:
Brad King 2014-01-13 10:25:32 -05:00 committed by CMake Topic Stage
parent b003f56f85 2cbf031190
commit 8d989d1788
9 changed files with 73 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmComputeLinkDepends.h
View File

@ -63,7 +63,7 @@ private:
cmTarget const* HeadTarget;
cmMakefile* Makefile;
cmLocalGenerator* LocalGenerator;
cmGlobalGenerator* GlobalGenerator;
cmGlobalGenerator const* GlobalGenerator;
cmake* CMakeInstance;
bool DebugMode;

2
Source/cmGeneratorTarget.cxx
View File

@ -469,7 +469,7 @@ private:
cmTarget* Target;
cmGeneratorTarget* GeneratorTarget;
cmMakefile* Makefile;
cmGlobalGenerator* GlobalGenerator;
cmGlobalGenerator const* GlobalGenerator;
typedef cmGeneratorTarget::SourceEntry SourceEntry;
SourceEntry* CurrentEntry;
std::queue<cmSourceFile*> SourceQueue;

2
Source/cmGeneratorTarget.h
View File

@ -50,7 +50,7 @@ public:
cmTarget* Target;
cmMakefile* Makefile;
cmLocalGenerator* LocalGenerator;
cmGlobalGenerator* GlobalGenerator;
cmGlobalGenerator const* GlobalGenerator;
std::string ModuleDefinitionFile;

86
Source/cmGlobalGenerator.cxx
View File

@ -90,7 +90,7 @@ bool cmGlobalGenerator::SetGeneratorToolset(std::string const& ts)
}
std::string cmGlobalGenerator::SelectMakeProgram(const char* makeProgram,
std::string makeDefault)
std::string makeDefault) const
{
if(cmSystemTools::IsOff(makeProgram))
{
@ -111,7 +111,7 @@ std::string cmGlobalGenerator::SelectMakeProgram(const char* makeProgram,
void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
cmMakefile *mf,
bool optional)
bool optional) const
{
std::string langComp = "CMAKE_";
langComp += lang;
@ -723,7 +723,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
//----------------------------------------------------------------------------
void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
std::string lang,
const char* envVar)
const char* envVar) const
{
// Subclasses override this method if they do not support this advice.
os <<
@ -744,7 +744,7 @@ void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
//----------------------------------------------------------------------------
void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
std::string lang)
std::string lang) const
{
std::string compilerIdVar = "CMAKE_" + lang + "_COMPILER_ID";
const char* compilerId = mf->GetDefinition(compilerIdVar.c_str());
@ -782,13 +782,16 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
//----------------------------------------------------------------------------
const char*
cmGlobalGenerator::GetLanguageOutputExtension(cmSourceFile const& source)
cmGlobalGenerator::GetLanguageOutputExtension(cmSourceFile const& source) const
{
if(const char* lang = source.GetLanguage())
{
if(this->LanguageToOutputExtension.count(lang) > 0)
std::map<cmStdString, cmStdString>::const_iterator it =
this->LanguageToOutputExtension.find(lang);
if(it != this->LanguageToOutputExtension.end())
{
return this->LanguageToOutputExtension[lang].c_str();
return it->second.c_str();
}
}
else
@ -809,7 +812,7 @@ cmGlobalGenerator::GetLanguageOutputExtension(cmSourceFile const& source)
}
const char* cmGlobalGenerator::GetLanguageFromExtension(const char* ext)
const char* cmGlobalGenerator::GetLanguageFromExtension(const char* ext) const
{
// if there is an extension and it starts with . then move past the
// . because the extensions are not stored with a . in the map
@ -817,9 +820,11 @@ const char* cmGlobalGenerator::GetLanguageFromExtension(const char* ext)
{
++ext;
}
if(this->ExtensionToLanguage.count(ext) > 0)
std::map<cmStdString, cmStdString>::const_iterator it
= this->ExtensionToLanguage.find(ext);
if(it != this->ExtensionToLanguage.end())
{
return this->ExtensionToLanguage[ext].c_str();
return it->second.c_str();
}
return 0;
}
@ -943,7 +948,7 @@ void cmGlobalGenerator::FillExtensionToLanguageMap(const char* l,
}
}
bool cmGlobalGenerator::IgnoreFile(const char* l)
bool cmGlobalGenerator::IgnoreFile(const char* l) const
{
if(this->GetLanguageFromExtension(l))
{
@ -966,15 +971,22 @@ bool cmGlobalGenerator::IsDependedOn(const char* project,
cmTarget const* targetIn)
{
// Get all local gens for this project
std::vector<cmLocalGenerator*>* gens = &this->ProjectMap[project];
// loop over local gens and get the targets for each one
for(unsigned int i = 0; i < gens->size(); ++i)
std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator it =
this->ProjectMap.find(project);
if (it == this->ProjectMap.end())
{
cmTargets& targets = (*gens)[i]->GetMakefile()->GetTargets();
for (cmTargets::iterator l = targets.begin();
return false;
}
// loop over local gens and get the targets for each one
for(std::vector<cmLocalGenerator*>::const_iterator geIt = it->second.begin();
geIt != it->second.end(); ++geIt)
{
cmTargets const& targets = (*geIt)->GetMakefile()->GetTargets();
for (cmTargets::const_iterator l = targets.begin();
l != targets.end(); l++)
{
cmTarget& target = l->second;
cmTarget const& target = l->second;
TargetDependSet const& tgtdeps = this->GetTargetDirectDepends(target);
if(tgtdeps.count(targetIn))
{
@ -1064,7 +1076,7 @@ void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target)
this->CMP0042WarnTargets.insert(target);
}
bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS()
bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
{
// If the property is not enabled then okay.
if(!this->CMakeInstance
@ -1899,7 +1911,7 @@ void cmGlobalGenerator::SetConfiguredFilesPath(cmGlobalGenerator* gen)
}
bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
cmLocalGenerator* gen)
cmLocalGenerator* gen) const
{
if(!gen || gen == root)
{
@ -1919,7 +1931,7 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
}
bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
cmTarget& target)
cmTarget const& target) const
{
if(target.GetType() == cmTarget::INTERFACE_LIBRARY
|| target.GetPropertyAsBool("EXCLUDE_FROM_ALL"))
@ -1935,16 +1947,17 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
}
}
void cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang)
void
cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
{
for(std::map<cmStdString, bool>::iterator i =
for(std::map<cmStdString, bool>::const_iterator i =
this->LanguageEnabled.begin(); i != this->LanguageEnabled.end(); ++i)
{
lang.push_back(i->first);
}
}
int cmGlobalGenerator::GetLinkerPreference(const char* lang)
int cmGlobalGenerator::GetLinkerPreference(const char* lang) const
{
std::map<cmStdString, int>::const_iterator it =
this->LanguageToLinkerPreference.find(lang);
@ -1990,10 +2003,10 @@ void cmGlobalGenerator::FillLocalGeneratorToTargetMap()
{
cmLocalGenerator* lg = *lgi;
cmMakefile* mf = lg->GetMakefile();
cmTargets& targets = mf->GetTargets();
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
cmTargets const& targets = mf->GetTargets();
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t)
{
cmTarget& target = t->second;
cmTarget const& target = t->second;
// Consider the directory containing the target and all its
// parents until something excludes the target.
@ -2022,15 +2035,16 @@ void cmGlobalGenerator::FillLocalGeneratorToTargetMap()
///! Find a local generator by its startdirectory
cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(const char* start_dir)
cmLocalGenerator*
cmGlobalGenerator::FindLocalGenerator(const char* start_dir) const
{
std::vector<cmLocalGenerator*>* gens = &this->LocalGenerators;
for(unsigned int i = 0; i < gens->size(); ++i)
for(std::vector<cmLocalGenerator*>::const_iterator it =
this->LocalGenerators.begin(); it != this->LocalGenerators.end(); ++it)
{
std::string sd = (*gens)[i]->GetMakefile()->GetStartDirectory();
std::string sd = (*it)->GetMakefile()->GetStartDirectory();
if (sd == start_dir)
{
return (*gens)[i];
return *it;
}
}
return 0;
@ -2513,11 +2527,13 @@ cmGlobalGenerator::GenerateRuleFile(std::string const& output) const
//----------------------------------------------------------------------------
std::string cmGlobalGenerator::GetSharedLibFlagsForLanguage(
std::string const& l)
std::string const& l) const
{
if(this->LanguageToOriginalSharedLibFlags.count(l) > 0)
std::map<cmStdString, cmStdString>::const_iterator it =
this->LanguageToOriginalSharedLibFlags.find(l);
if(it != this->LanguageToOriginalSharedLibFlags.end())
{
return this->LanguageToOriginalSharedLibFlags[l];
return it->second;
}
return "";
}
@ -2648,7 +2664,7 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
}
//----------------------------------------------------------------------------
bool cmGlobalGenerator::IsRootOnlyTarget(cmTarget* target)
bool cmGlobalGenerator::IsRootOnlyTarget(cmTarget* target) const
{
return (target->GetType() == cmTarget::GLOBAL_TARGET ||
strcmp(target->GetName(), this->GetAllTargetName()) == 0);

30
Source/cmGlobalGenerator.h
View File

@ -80,7 +80,7 @@ public:
void SetLanguageEnabled(const char*, cmMakefile* mf);
bool GetLanguageEnabled(const char*) const;
void ClearEnabledLanguages();
void GetEnabledLanguages(std::vector<std::string>& lang);
void GetEnabledLanguages(std::vector<std::string>& lang) const;
/**
* Try to determine system infomation such as shared library
* extension, pthreads, byte order etc.
@ -93,7 +93,7 @@ public:
* Intended to be called from EnableLanguage.
*/
void ResolveLanguageCompiler(const std::string &lang, cmMakefile *mf,
bool optional);
bool optional) const;
/**
* Try to determine system infomation, get it from another generator
@ -182,13 +182,13 @@ public:
bool GetToolSupportsColor() const { return this->ToolSupportsColor; }
///! return the language for the given extension
const char* GetLanguageFromExtension(const char* ext);
const char* GetLanguageFromExtension(const char* ext) const;
///! is an extension to be ignored
bool IgnoreFile(const char* ext);
bool IgnoreFile(const char* ext) const;
///! What is the preference for linkers and this language (None or Prefered)
int GetLinkerPreference(const char* lang);
int GetLinkerPreference(const char* lang) const;
///! What is the object file extension for a given source file?
const char* GetLanguageOutputExtension(cmSourceFile const&);
const char* GetLanguageOutputExtension(cmSourceFile const&) const;
///! What is the configurations directory variable called?
virtual const char* GetCMakeCFGIntDir() const { return "."; }
@ -220,7 +220,7 @@ public:
target in the project */
bool IsDependedOn(const char* project, cmTarget const* target);
///! Find a local generator by its startdirectory
cmLocalGenerator* FindLocalGenerator(const char* start_dir);
cmLocalGenerator* FindLocalGenerator(const char* start_dir) const;
/** Append the subdirectory for the given configuration. If anything is
appended the given prefix and suffix will be appended around it, which
@ -293,7 +293,7 @@ public:
i.e. "Can I build Debug and Release in the same tree?" */
virtual bool IsMultiConfig() { return false; }
std::string GetSharedLibFlagsForLanguage(std::string const& lang);
std::string GetSharedLibFlagsForLanguage(std::string const& lang) const;
/** Generate an <output>.rule file path for a given command output. */
virtual std::string GenerateRuleFile(std::string const& output) const;
@ -325,7 +325,7 @@ protected:
virtual void GetTargetSets(TargetDependSet& projectTargets,
TargetDependSet& originalTargets,
cmLocalGenerator* root, GeneratorVector const&);
virtual bool IsRootOnlyTarget(cmTarget* target);
bool IsRootOnlyTarget(cmTarget* target) const;
void AddTargetDepends(cmTarget const* target,
TargetDependSet& projectTargets);
void SetLanguageEnabledFlag(const char* l, cmMakefile* mf);
@ -334,7 +334,7 @@ protected:
virtual bool ComputeTargetDepends();
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS();
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const;
bool CheckTargets();
typedef std::vector<std::pair<cmQtAutoGenerators,
@ -342,14 +342,14 @@ protected:
void CreateQtAutoGeneratorsTargets(AutogensType& autogens);
std::string SelectMakeProgram(const char* makeProgram,
std::string makeDefault = "");
std::string makeDefault = "") const;
// Fill the ProjectMap, this must be called after LocalGenerators
// has been populated.
void FillProjectMap();
void CheckLocalGenerators();
bool IsExcluded(cmLocalGenerator* root, cmLocalGenerator* gen);
bool IsExcluded(cmLocalGenerator* root, cmTarget& target);
bool IsExcluded(cmLocalGenerator* root, cmLocalGenerator* gen) const;
bool IsExcluded(cmLocalGenerator* root, cmTarget const& target) const;
void FillLocalGeneratorToTargetMap();
void CreateDefaultGlobalTargets(cmTargets* targets);
cmTarget CreateGlobalTarget(const char* name, const char* message,
@ -418,8 +418,8 @@ private:
void FinalizeTargetCompileInfo();
virtual void PrintCompilerAdvice(std::ostream& os, std::string lang,
const char* envVar);
void CheckCompilerIdCompatibility(cmMakefile* mf, std::string lang);
const char* envVar) const;
void CheckCompilerIdCompatibility(cmMakefile* mf, std::string lang) const;
cmExternalMakefileProjectGenerator* ExtraGenerator;

2
Source/cmGlobalNinjaGenerator.h
View File

@ -304,7 +304,7 @@ protected:
/// Overloaded methods.
/// @see cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS()
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() { return true; }
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; }
private:

2
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -161,7 +161,7 @@ protected:
const char* GetRebuildCacheTargetName() const { return "rebuild_cache"; }
const char* GetCleanTargetName() const { return "clean"; }
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() { return true; }
virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; }
// Some make programs (Borland) do not keep a rule if there are no
// dependencies or commands. This is a problem for creating rules

2
Source/cmGlobalVisualStudioGenerator.h
View File

@ -110,7 +110,7 @@ protected:
private:
virtual std::string GetVSMakeProgram() = 0;
void PrintCompilerAdvice(std::ostream&, std::string, const char*) {}
void PrintCompilerAdvice(std::ostream&, std::string, const char*) const {}
void ComputeTargetObjects(cmGeneratorTarget* gt) const;
void FollowLinkDepends(cmTarget const* target,

2
Source/cmGlobalXCodeGenerator.h
View File

@ -212,7 +212,7 @@ protected:
std::vector<cmXCodeObject*> XCodeObjects;
cmXCodeObject* RootObject;
private:
void PrintCompilerAdvice(std::ostream&, std::string, const char*) {}
void PrintCompilerAdvice(std::ostream&, std::string, const char*) const {}
void ComputeTargetObjects(cmGeneratorTarget* gt) const;
std::string GetObjectsNormalDirectory(