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.

Source/cmComputeLinkDepends.h

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

Source/cmGeneratorTarget.cxx

@@ -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;

Source/cmGeneratorTarget.h

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

Source/cmGlobalGenerator.cxx

@@ -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];
+  std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator it =
+                                              this->ProjectMap.find(project);
+  if (it == this->ProjectMap.end())
+    {
+    return false;
+    }
+
   // loop over local gens and get the targets for each one
-  for(unsigned int i = 0; i < gens->size(); ++i)
+  for(std::vector<cmLocalGenerator*>::const_iterator geIt = it->second.begin();
+      geIt != it->second.end(); ++geIt)
     {
-    cmTargets& targets = (*gens)[i]->GetMakefile()->GetTargets();
-    for (cmTargets::iterator l = targets.begin();
+    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);

Source/cmGlobalGenerator.h

@@ -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;
 

Source/cmGlobalNinjaGenerator.h

@@ -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:

Source/cmGlobalUnixMakefileGenerator3.h

@@ -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

Source/cmGlobalVisualStudioGenerator.h

@@ -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,

Source/cmGlobalXCodeGenerator.h

@@ -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(