cmMakefile: make some methods take const std::string& instead of const char*

Most callers already have a std::string, on which they called c_str() to pass it
into these methods, which internally converted it back to std::string. Pass a
std::string directly to these methods now, avoiding all these conversions.
Those methods that only pass in a const char* will get the conversion to
std::string now only once.

Source/cmAddDependenciesCommand.cxx

@@ -24,14 +24,14 @@ bool cmAddDependenciesCommand
     }
 
   std::string target_name = args[0];
-  if(this->Makefile->IsAlias(target_name.c_str()))
+  if(this->Makefile->IsAlias(target_name))
     {
     cmOStringStream e;
     e << "Cannot add target-level dependencies to alias target \""
       << target_name << "\".\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     }
-  if(cmTarget* target = this->Makefile->FindTargetToUse(target_name.c_str()))
+  if(cmTarget* target = this->Makefile->FindTargetToUse(target_name))
     {
     if (target->GetType() == cmTarget::INTERFACE_LIBRARY)
       {

Source/cmAddExecutableCommand.cxx

@@ -201,7 +201,7 @@ bool cmAddExecutableCommand
   if(importTarget)
     {
     // Make sure the target does not already exist.
-    if(this->Makefile->FindTargetToUse(exename.c_str()))
+    if(this->Makefile->FindTargetToUse(exename))
       {
       cmOStringStream e;
       e << "cannot create imported target \"" << exename

Source/cmAddLibraryCommand.cxx

@@ -363,7 +363,7 @@ bool cmAddLibraryCommand
       }
 
     // Make sure the target does not already exist.
-    if(this->Makefile->FindTargetToUse(libName.c_str()))
+    if(this->Makefile->FindTargetToUse(libName))
       {
       cmOStringStream e;
       e << "cannot create imported target \"" << libName

Source/cmComputeTargetDepends.cxx

@@ -411,7 +411,7 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
         i != utils.end(); ++i)
       {
       if(cmTarget const* transitive_dependee =
-         dependee->GetMakefile()->FindTargetToUse(i->c_str()))
+         dependee->GetMakefile()->FindTargetToUse(*i))
         {
         this->AddTargetDepend(depender_index, transitive_dependee, false);
         }

Source/cmCoreTryCompile.cxx

@@ -93,7 +93,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
     else if(doing == DoingLinkLibraries)
       {
       libsToLink += "\"" + cmSystemTools::TrimWhitespace(argv[i]) + "\" ";
-      if(cmTarget *tgt = this->Makefile->FindTargetToUse(argv[i].c_str()))
+      if(cmTarget *tgt = this->Makefile->FindTargetToUse(argv[i]))
         {
         switch(tgt->GetType())
           {

Source/cmCustomCommandGenerator.cxx

@@ -41,7 +41,7 @@ unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
 std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
 {
   std::string const& argv0 = this->CC.GetCommandLines()[c][0];
-  cmTarget* target = this->Makefile->FindTargetToUse(argv0.c_str());
+  cmTarget* target = this->Makefile->FindTargetToUse(argv0);
   if(target && target->GetType() == cmTarget::EXECUTABLE &&
      (target->IsImported() || !this->Makefile->IsOn("CMAKE_CROSSCOMPILING")))
     {

Source/cmExportBuildFileGenerator.cxx

@@ -35,7 +35,7 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
         tei = targets.begin();
       tei != targets.end(); ++tei)
     {
-    cmTarget *te = this->Makefile->FindTargetToUse(tei->c_str());
+    cmTarget *te = this->Makefile->FindTargetToUse(*tei);
     expectedTargets += sep + this->Namespace + te->GetExportName();
     sep = " ";
     if(this->ExportedTargets.insert(te).second)

Source/cmExportCommand.cxx

@@ -159,7 +159,7 @@ bool cmExportCommand
         currentTarget != this->Targets.GetVector().end();
         ++currentTarget)
       {
-      if (this->Makefile->IsAlias(currentTarget->c_str()))
+      if (this->Makefile->IsAlias(*currentTarget))
         {
         cmOStringStream e;
         e << "given ALIAS target \"" << *currentTarget

Source/cmExportFileGenerator.cxx

@@ -534,7 +534,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input,
 {
   cmMakefile *mf = target->GetMakefile();
 
-  cmTarget *tgt = mf->FindTargetToUse(input.c_str());
+  cmTarget *tgt = mf->FindTargetToUse(input);
   if (!tgt)
     {
     return false;

Source/cmExportTryCompileFileGenerator.cxx

@@ -109,7 +109,7 @@ cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target,
       for(std::vector<std::string>::const_iterator li = depends.begin();
           li != depends.end(); ++li)
         {
-        cmTarget *tgt = target->GetMakefile()->FindTargetToUse(li->c_str());
+        cmTarget *tgt = target->GetMakefile()->FindTargetToUse(*li);
         if(tgt && emitted.insert(tgt).second)
           {
           this->Exports.push_back(tgt);

Source/cmFLTKWrapUICommand.cxx

@@ -120,7 +120,7 @@ void cmFLTKWrapUICommand::FinalPass()
   // people should add the srcs to the target themselves, but the old command
   // didn't support that, so check and see if they added the files in and if
   // they didn;t then print a warning and add then anyhow
-  cmTarget* target = this->Makefile->FindTarget(this->Target.c_str());
+  cmTarget* target = this->Makefile->FindTarget(this->Target);
   if(!target)
     {
     std::string msg =

Source/cmGeneratorExpressionEvaluator.cxx

@@ -822,7 +822,7 @@ std::string getLinkedTargetsContent(const std::vector<std::string> &libraries,
       // self-referencing loop.
       continue;
       }
-    if (context->Makefile->FindTargetToUse(it->c_str()))
+    if (context->Makefile->FindTargetToUse(*it))
       {
       depString +=
         sep + "$<TARGET_PROPERTY:" + *it + "," + interfacePropertyName + ">";
@@ -912,18 +912,16 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
         }
       if(propertyName == "ALIASED_TARGET")
         {
-        if(context->Makefile->IsAlias(targetName.c_str()))
+        if(context->Makefile->IsAlias(targetName))
           {
-          if(cmTarget* tgt =
-                      context->Makefile->FindTargetToUse(targetName.c_str()))
+          if(cmTarget* tgt = context->Makefile->FindTargetToUse(targetName))
             {
             return tgt->GetName();
             }
           }
         return "";
         }
-      target = context->Makefile->FindTargetToUse(
-                                                targetName.c_str());
+      target = context->Makefile->FindTargetToUse(targetName);
 
       if (!target)
         {
@@ -1476,7 +1474,7 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode
                     "Expression syntax not recognized.");
       return std::string();
       }
-    cmTarget* target = context->Makefile->FindTargetToUse(name.c_str());
+    cmTarget* target = context->Makefile->FindTargetToUse(name);
     if(!target)
       {
       ::reportError(context, content->GetOriginalExpression(),

Source/cmGeneratorTarget.cxx

@@ -68,7 +68,7 @@ static void handleSystemIncludesDep(cmMakefile *mf, const std::string &name,
                                   std::vector<std::string>& result,
                                   bool excludeImported)
 {
-  cmTarget* depTgt = mf->FindTargetToUse(name.c_str());
+  cmTarget* depTgt = mf->FindTargetToUse(name);
 
   if (!depTgt)
     {
@@ -230,7 +230,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const char *dir,
       {
       if (uniqueDeps.insert(*li).second)
         {
-        cmTarget* tgt = this->Makefile->FindTargetToUse(li->c_str());
+        cmTarget* tgt = this->Makefile->FindTargetToUse(*li);
 
         if (!tgt)
           {
@@ -394,7 +394,7 @@ void cmGeneratorTarget::LookupObjectLibraries()
       oli != objLibs.end(); ++oli)
     {
     std::string const& objLibName = *oli;
-    if(cmTarget* objLib = this->Makefile->FindTargetToUse(objLibName.c_str()))
+    if(cmTarget* objLib = this->Makefile->FindTargetToUse(objLibName))
       {
       if(objLib->GetType() == cmTarget::OBJECT_LIBRARY)
         {
@@ -607,7 +607,7 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
     }
 
   // Check for a target with this name.
-  if(cmTarget* t = this->Makefile->FindTargetToUse(util.c_str()))
+  if(cmTarget* t = this->Makefile->FindTargetToUse(util))
     {
     // If we find the target and the dep was given as a full path,
     // then make sure it was not a full path to something else, and
@@ -661,7 +661,7 @@ cmTargetTraceDependencies
     {
     std::string const& command = *cit->begin();
     // Check for a target with this name.
-    if(cmTarget* t = this->Makefile->FindTargetToUse(command.c_str()))
+    if(cmTarget* t = this->Makefile->FindTargetToUse(command))
       {
       if(t->GetType() == cmTarget::EXECUTABLE)
         {

Source/cmGetPropertyCommand.cxx

@@ -290,17 +290,17 @@ bool cmGetPropertyCommand::HandleTargetMode()
 
   if(this->PropertyName == "ALIASED_TARGET")
     {
-    if(this->Makefile->IsAlias(this->Name.c_str()))
+    if(this->Makefile->IsAlias(this->Name))
       {
       if(cmTarget* target =
-                          this->Makefile->FindTargetToUse(this->Name.c_str()))
+                          this->Makefile->FindTargetToUse(this->Name))
         {
         return this->StoreResult(target->GetName());
         }
       }
     return this->StoreResult((this->Variable + "-NOTFOUND").c_str());
     }
-  if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name.c_str()))
+  if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name))
     {
     return this->StoreResult(target->GetProperty(this->PropertyName.c_str()));
     }

Source/cmGetTargetPropertyCommand.cxx

@@ -21,7 +21,7 @@ bool cmGetTargetPropertyCommand
     return false;
     }
   std::string var = args[0].c_str();
-  const char* targetName = args[1].c_str();
+  const std::string& targetName = args[1];
   const char *prop = 0;
 
   if(args[2] == "ALIASED_TARGET")

Source/cmIfCommand.cxx

@@ -543,7 +543,7 @@ namespace
       if (*arg == "TARGET" && argP1 != newArgs.end())
         {
         HandlePredicate(
-          makefile->FindTargetToUse((argP1)->c_str())? true:false,
+          makefile->FindTargetToUse(*argP1)?true:false,
           reducible, arg, newArgs, argP1, argP2);
         }
       // is a variable defined

Source/cmInstallCommand.cxx

@@ -363,7 +363,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
       ++targetIt)
     {
 
-    if (this->Makefile->IsAlias(targetIt->c_str()))
+    if (this->Makefile->IsAlias(*targetIt))
       {
       cmOStringStream e;
       e << "TARGETS given target \"" << (*targetIt)
@@ -372,7 +372,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
       return false;
       }
     // Lookup this target in the current directory.
-    if(cmTarget* target=this->Makefile->FindTarget(targetIt->c_str()))
+    if(cmTarget* target=this->Makefile->FindTarget(*targetIt))
       {
       // Found the target.  Check its type.
       if(target->GetType() != cmTarget::EXECUTABLE &&

Source/cmLocalGenerator.cxx

@@ -2021,7 +2021,7 @@ bool cmLocalGenerator::GetRealDependency(const char* inName,
     }
 
   // Look for a CMake target with the given name.
-  if(cmTarget* target = this->Makefile->FindTargetToUse(name.c_str()))
+  if(cmTarget* target = this->Makefile->FindTargetToUse(name))
     {
     // make sure it is not just a coincidence that the target name
     // found is part of the inName

Source/cmMakefile.cxx

@@ -3859,7 +3859,8 @@ const char* cmMakefile::GetFeature(const char* feature, const char* config)
   return 0;
 }
 
-cmTarget* cmMakefile::FindTarget(const char* name, bool excludeAliases) const
+cmTarget* cmMakefile::FindTarget(const std::string& name,
+                                 bool excludeAliases) const
 {
   if (!excludeAliases)
     {
@@ -4063,7 +4064,8 @@ cmMakefile::AddImportedTarget(const char* name, cmTarget::TargetType type,
 }
 
 //----------------------------------------------------------------------------
-cmTarget* cmMakefile::FindTargetToUse(const char* name, bool excludeAliases)
+cmTarget* cmMakefile::FindTargetToUse(const std::string& name,
+                                      bool excludeAliases)
 {
   // Look for an imported target.  These take priority because they
   // are more local in scope and do not have to be globally unique.
@@ -4081,16 +4083,18 @@ cmTarget* cmMakefile::FindTargetToUse(const char* name, bool excludeAliases)
     }
 
   // Look for a target built in this project.
-  return this->LocalGenerator->GetGlobalGenerator()->FindTarget(0, name,
+  return this->LocalGenerator->GetGlobalGenerator()->FindTarget(0,
+                                                              name.c_str(),
                                                               excludeAliases);
 }
 
 //----------------------------------------------------------------------------
-bool cmMakefile::IsAlias(const char *name)
+bool cmMakefile::IsAlias(const std::string& name)
 {
   if (this->AliasTargets.find(name) != this->AliasTargets.end())
     return true;
-  return this->GetLocalGenerator()->GetGlobalGenerator()->IsAlias(name);
+  return this->GetLocalGenerator()->GetGlobalGenerator()->IsAlias(
+                                                              name.c_str());
 }
 
 //----------------------------------------------------------------------------
@@ -4107,7 +4111,7 @@ cmGeneratorTarget* cmMakefile::FindGeneratorTargetToUse(const char* name)
 bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
                                    bool isCustom)
 {
-  if(this->IsAlias(name.c_str()))
+  if(this->IsAlias(name))
     {
     cmOStringStream e;
     e << "cannot create target \"" << name
@@ -4115,7 +4119,7 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
     msg = e.str();
     return false;
     }
-  if(cmTarget* existing = this->FindTargetToUse(name.c_str()))
+  if(cmTarget* existing = this->FindTargetToUse(name))
     {
     // The name given conflicts with an existing target.  Produce an
     // error in a compatible way.

Source/cmMakefile.h

@@ -533,12 +533,14 @@ public:
       this->GeneratorTargets = targets;
     }
 
-  cmTarget* FindTarget(const char* name, bool excludeAliases = false) const;
+  cmTarget* FindTarget(const std::string& name,
+                       bool excludeAliases = false) const;
 
   /** Find a target to use in place of the given name.  The target
       returned may be imported or built within the project.  */
-  cmTarget* FindTargetToUse(const char* name, bool excludeAliases = false);
-  bool IsAlias(const char *name);
+  cmTarget* FindTargetToUse(const std::string& name,
+                            bool excludeAliases = false);
+  bool IsAlias(const std::string& name);
   cmGeneratorTarget* FindGeneratorTargetToUse(const char* name);
 
   /**