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.

26 files changed, 63 insertions, 59 deletions

diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx
index a7ffded2bc..b55334f859 100644
--- a/Source/cmAddDependenciesCommand.cxx
+++ b/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)
       {
diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx
index a352be04e5..62b666766d 100644
--- a/Source/cmAddExecutableCommand.cxx
+++ b/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
diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
index 2627445600..a29f784209 100644
--- a/Source/cmAddLibraryCommand.cxx
+++ b/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
diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx
index a848e4faf2..6511510ca7 100644
--- a/Source/cmComputeTargetDepends.cxx
+++ b/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);
         }
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index 78bb9a67f1..bbdb3a1d83 100644
--- a/Source/cmCoreTryCompile.cxx
+++ b/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())
           {
diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx
index f2f77eea04..f24dfa212e 100644
--- a/Source/cmCustomCommandGenerator.cxx
+++ b/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")))
     {
diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx
index b669cd110b..858f76cad8 100644
--- a/Source/cmExportBuildFileGenerator.cxx
+++ b/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)
diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx
index 7c97d8ddfe..db56aaf418 100644
--- a/Source/cmExportCommand.cxx
+++ b/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
diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
index 13bff19f84..4a161eef7a 100644
--- a/Source/cmExportFileGenerator.cxx
+++ b/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;
diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx
index 8d37b622f4..a8a91d6d94 100644
--- a/Source/cmExportTryCompileFileGenerator.cxx
+++ b/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);
diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx
index 4ce1ea592f..4dd81be961 100644
--- a/Source/cmFLTKWrapUICommand.cxx
+++ b/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 =
diff --git a/Source/cmGeneratorExpressionEvaluator.cxx b/Source/cmGeneratorExpressionEvaluator.cxx
index 1feb03ab09..7036992d85 100644
--- a/Source/cmGeneratorExpressionEvaluator.cxx
+++ b/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(),
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 0fcee3eec3..2573c85a16 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/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)
         {
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index a1454a32d0..33c43caf6e 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/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()));
     }
diff --git a/Source/cmGetTargetPropertyCommand.cxx b/Source/cmGetTargetPropertyCommand.cxx
index 488cc288d9..4aa49fe9c4 100644
--- a/Source/cmGetTargetPropertyCommand.cxx
+++ b/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")
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 57cec5bbbd..ee95c05919 100644
--- a/Source/cmIfCommand.cxx
+++ b/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
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index 10578f2076..6f2dd653fc 100644
--- a/Source/cmInstallCommand.cxx
+++ b/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 &&
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 3effe38241..bd910e2707 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/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
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 479e712e7b..222cdb64e8 100644
--- a/Source/cmMakefile.cxx
+++ b/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.
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index d9fc93c75b..0232ffe64f 100644
--- a/Source/cmMakefile.h
+++ b/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);
 
   /**
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index 42078605a6..1a6f1d63ff 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -244,12 +244,12 @@ bool cmSetPropertyCommand::HandleTargetMode()
   for(std::set<cmStdString>::const_iterator ni = this->Names.begin();
       ni != this->Names.end(); ++ni)
     {
-    if (this->Makefile->IsAlias(ni->c_str()))
+    if (this->Makefile->IsAlias(*ni))
       {
       this->SetError("can not be used on an ALIAS target.");
       return false;
       }
-    if(cmTarget* target = this->Makefile->FindTargetToUse(ni->c_str()))
+    if(cmTarget* target = this->Makefile->FindTargetToUse(*ni))
       {
       // Handle the current target.
       if(!this->HandleTarget(target))
diff --git a/Source/cmSetTargetPropertiesCommand.cxx b/Source/cmSetTargetPropertiesCommand.cxx
index 78ef393cc7..dab4180e5f 100644
--- a/Source/cmSetTargetPropertiesCommand.cxx
+++ b/Source/cmSetTargetPropertiesCommand.cxx
@@ -72,7 +72,7 @@ bool cmSetTargetPropertiesCommand
   int i;
   for(i = 0; i < numFiles; ++i)
     {
-    if (this->Makefile->IsAlias(args[i].c_str()))
+    if (this->Makefile->IsAlias(args[i]))
       {
       this->SetError("can not be used on an ALIAS target.");
       return false;
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 24fa0c519a..21f8d4cd34 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -1681,14 +1681,14 @@ static void processIncludeDirectories(cmTarget const* tgt,
       evaluatedTargetName = cge->Evaluate(mf, config, false, tgt, 0, 0);
       }
 
-      cmTarget *dependentTarget = mf->FindTargetToUse(targetName.c_str());
+      cmTarget *dependentTarget = mf->FindTargetToUse(targetName);
 
       const bool fromImported = dependentTarget
                              && dependentTarget->IsImported();
 
       cmTarget *evaluatedDependentTarget =
         (targetName != evaluatedTargetName)
-          ? mf->FindTargetToUse(evaluatedTargetName.c_str())
+          ? mf->FindTargetToUse(evaluatedTargetName)
           : 0;
 
       targetName = evaluatedTargetName;
@@ -1860,7 +1860,7 @@ cmTarget::GetIncludeDirectories(const char *config) const
                                                         ge.Parse(it->Value);
       std::string result = cge->Evaluate(this->Makefile, config,
                                         false, this, 0, 0);
-      if (!this->Makefile->FindTargetToUse(result.c_str()))
+      if (!this->Makefile->FindTargetToUse(result))
         {
         continue;
         }
@@ -2089,7 +2089,7 @@ void cmTarget::GetCompileOptions(std::vector<std::string> &result,
                                                         ge.Parse(it->Value);
       std::string targetResult = cge->Evaluate(this->Makefile, config,
                                         false, this, 0, 0);
-      if (!this->Makefile->FindTargetToUse(targetResult.c_str()))
+      if (!this->Makefile->FindTargetToUse(targetResult))
         {
         continue;
         }
@@ -2202,7 +2202,7 @@ void cmTarget::GetCompileDefinitions(std::vector<std::string> &list,
                                                         ge.Parse(it->Value);
       std::string targetResult = cge->Evaluate(this->Makefile, config,
                                         false, this, 0, 0);
-      if (!this->Makefile->FindTargetToUse(targetResult.c_str()))
+      if (!this->Makefile->FindTargetToUse(targetResult))
         {
         continue;
         }
@@ -2861,7 +2861,7 @@ public:
     for(std::vector<std::string>::const_iterator
           li = iface->Libraries.begin(); li != iface->Libraries.end(); ++li)
       {
-      this->Visit(mf->FindTargetToUse(li->c_str()));
+      this->Visit(mf->FindTargetToUse(*li));
       }
     }
 private:
@@ -2969,7 +2969,7 @@ void cmTarget::ComputeLinkClosure(const char* config, LinkClosure& lc,
   for(std::vector<std::string>::const_iterator li = impl->Libraries.begin();
       li != impl->Libraries.end(); ++li)
     {
-    cll.Visit(this->Makefile->FindTargetToUse(li->c_str()));
+    cll.Visit(this->Makefile->FindTargetToUse(*li));
     }
 
   // Store the transitive closure of languages.
@@ -5414,7 +5414,7 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
           {
           if(emitted.insert(*li).second)
             {
-            if(cmTarget* tgt = this->Makefile->FindTargetToUse(li->c_str()))
+            if(cmTarget* tgt = this->Makefile->FindTargetToUse(*li))
               {
               // This is a runtime dependency on another shared library.
               if(tgt->GetType() == cmTarget::SHARED_LIBRARY)
@@ -5624,7 +5624,7 @@ void cmTarget::ComputeLinkImplementation(const char* config,
         }
       continue;
       }
-    cmTarget *tgt = this->Makefile->FindTargetToUse(li->c_str());
+    cmTarget *tgt = this->Makefile->FindTargetToUse(*li);
 
     if(!tgt && std::string(item).find("::") != std::string::npos)
       {
@@ -5695,7 +5695,7 @@ void cmTarget::ComputeLinkImplementation(const char* config,
       i = this->ObjectLibraries.begin();
       i != this->ObjectLibraries.end(); ++i)
     {
-    if(cmTarget* objLib = this->Makefile->FindTargetToUse(i->c_str()))
+    if(cmTarget* objLib = this->Makefile->FindTargetToUse(*i))
       {
       if(objLib->GetType() == cmTarget::OBJECT_LIBRARY)
         {
diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx
index 209609d20c..02da933abb 100644
--- a/Source/cmTargetLinkLibrariesCommand.cxx
+++ b/Source/cmTargetLinkLibrariesCommand.cxx
@@ -31,7 +31,7 @@ bool cmTargetLinkLibrariesCommand
     return false;
     }
 
-  if (this->Makefile->IsAlias(args[0].c_str()))
+  if (this->Makefile->IsAlias(args[0]))
     {
     this->SetError("can not be used on an ALIAS target.");
     return false;
diff --git a/Source/cmTargetPropCommandBase.cxx b/Source/cmTargetPropCommandBase.cxx
index e7b699932b..195690e7f1 100644
--- a/Source/cmTargetPropCommandBase.cxx
+++ b/Source/cmTargetPropCommandBase.cxx
@@ -26,7 +26,7 @@ bool cmTargetPropCommandBase
     }
 
   // Lookup the target for which libraries are specified.
-  if (this->Makefile->IsAlias(args[0].c_str()))
+  if (this->Makefile->IsAlias(args[0]))
     {
     this->SetError("can not be used on an ALIAS target.");
     return false;
@@ -36,7 +36,7 @@ bool cmTargetPropCommandBase
     ->GetGlobalGenerator()->FindTarget(0, args[0].c_str());
   if(!this->Target)
     {
-    this->Target = this->Makefile->FindTargetToUse(args[0].c_str());
+    this->Target = this->Makefile->FindTargetToUse(args[0]);
     }
   if(!this->Target)
     {
diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx
index d962fb2a67..5dc3e6042e 100644
--- a/Source/cmTestGenerator.cxx
+++ b/Source/cmTestGenerator.cxx
@@ -82,7 +82,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
   // be translated.
   std::string exe = command[0];
   cmMakefile* mf = this->Test->GetMakefile();
-  cmTarget* target = mf->FindTargetToUse(exe.c_str());
+  cmTarget* target = mf->FindTargetToUse(exe);
   if(target && target->GetType() == cmTarget::EXECUTABLE)
     {
     // Use the target file on disk.