reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-12-14 07:09:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

cmGlobalGenerator: Make some API const.

Browse Source
This commit is contained in:
Stephen Kelly 2014-01-10 13:21:15 +01:00
parent 8fd0f2a718
commit 8aeddf1f03
2 changed files with 56 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
Source/cmGlobalGenerator.cxx
View File

@ -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))
{
@ -1897,7 +1909,7 @@ void cmGlobalGenerator::SetConfiguredFilesPath(cmGlobalGenerator* gen)
}
bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
cmLocalGenerator* gen)
cmLocalGenerator* gen) const
{
if(!gen || gen == root)
{
@ -1917,7 +1929,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"))
@ -1933,16 +1945,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);
@ -1988,10 +2001,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.
@ -2020,15 +2033,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;
@ -2511,11 +2525,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 "";
}
@ -2646,7 +2662,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);

20
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.
@ -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);
@ -348,8 +348,8 @@ protected:
// 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,