strings: Remove cmStdString references

Casts from std::string -> cmStdString were high on the list of things
taking up time. Avoid such implicit casts across function calls by just
using std::string everywhere.

The comment that the symbol name is too long is no longer relevant since
modern debuggers alias the templates anyways and the size is a
non-issue since the underlying methods are generated since it's
inherited.

Source/CPack/cmCPackGeneratorFactory.h

@@ -42,7 +42,7 @@ public:
 
   void SetLogger(cmCPackLog* logger) { this->Logger = logger; }
 
-  typedef std::map<cmStdString, cmStdString> DescriptionsMap;
+  typedef std::map<std::string, std::string> DescriptionsMap;
   const DescriptionsMap& GetGeneratorsList() const
     { return this->GeneratorDescriptions; }
 
@@ -50,7 +50,7 @@ private:
   cmCPackGenerator* NewGeneratorInternal(const std::string& name);
   std::vector<cmCPackGenerator*> Generators;
 
-  typedef std::map<cmStdString, CreateGeneratorCall*> t_GeneratorCreatorsMap;
+  typedef std::map<std::string, CreateGeneratorCall*> t_GeneratorCreatorsMap;
   t_GeneratorCreatorsMap GeneratorCreators;
   DescriptionsMap GeneratorDescriptions;
   cmCPackLog* Logger;

Source/CPack/cpack.cxx

@@ -68,7 +68,7 @@ int cpackUnknownArgument(const char*, void*)
 //----------------------------------------------------------------------------
 struct cpackDefinitions
 {
-  typedef std::map<cmStdString, cmStdString> MapType;
+  typedef std::map<std::string, std::string> MapType;
   MapType Map;
   cmCPackLog *Log;
 };

Source/CTest/cmCTestBZR.cxx

@@ -409,7 +409,7 @@ bool cmCTestBZR::UpdateImpl()
     {
     opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
     }
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
 
@@ -418,7 +418,7 @@ bool cmCTestBZR::UpdateImpl()
   bzr_update.push_back(this->CommandLineTool.c_str());
   bzr_update.push_back("pull");
 
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     bzr_update.push_back(ai->c_str());

Source/CTest/cmCTestBuildAndTestHandler.h

@@ -54,7 +54,7 @@ protected:
                std::string &cmakeOutString,
                std::string &cwd, cmake *cm);
 
-  cmStdString  Output;
+  std::string  Output;
 
   std::string              BuildGenerator;
   std::string              BuildGeneratorToolset;

Source/CTest/cmCTestBuildHandler.cxx

@@ -380,7 +380,7 @@ int cmCTestBuildHandler::ProcessHandler()
 
   // Create lists of regular expression strings for errors, error exceptions,
   // warnings and warning exceptions.
-  std::vector<cmStdString>::size_type cc;
+  std::vector<std::string>::size_type cc;
   for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
     {
     this->CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
@@ -400,7 +400,7 @@ int cmCTestBuildHandler::ProcessHandler()
     }
 
   // Pre-compile regular expressions objects for all regular expressions
-  std::vector<cmStdString>::iterator it;
+  std::vector<std::string>::iterator it;
 
 #define cmCTestBuildHandlerPopulateRegexVector(strings, regexes) \
   regexes.clear(); \
@@ -602,7 +602,7 @@ void cmCTestBuildHandler::GenerateXMLLaunched(std::ostream& os)
   // Sort XML fragments in chronological order.
   cmFileTimeComparison ftc;
   FragmentCompare fragmentCompare(&ftc);
-  typedef std::set<cmStdString, FragmentCompare> Fragments;
+  typedef std::set<std::string, FragmentCompare> Fragments;
   Fragments fragments(fragmentCompare);
 
   // Identify fragments on disk.
@@ -889,7 +889,7 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
   int* retVal, const char* dir, int timeout, std::ostream& ofs)
 {
   // First generate the command and arguments
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
   if(args.size() < 1)
     {
@@ -897,7 +897,7 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
     }
 
   std::vector<const char*> argv;
-  for(std::vector<cmStdString>::const_iterator a = args.begin();
+  for(std::vector<std::string>::const_iterator a = args.begin();
     a != args.end(); ++a)
     {
     argv.push_back(a->c_str());
@@ -1133,7 +1133,7 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
         errorwarning.PostContext = "";
 
         // Copy pre-context to report
-        std::deque<cmStdString>::iterator pcit;
+        std::deque<std::string>::iterator pcit;
         for ( pcit = this->PreContext.begin();
           pcit != this->PreContext.end();
           ++pcit )

Source/CTest/cmCTestBuildHandler.h

@@ -97,10 +97,10 @@ private:
   double                  StartBuildTime;
   double                  EndBuildTime;
 
-  std::vector<cmStdString> CustomErrorMatches;
+  std::vector<std::string> CustomErrorMatches;
-  std::vector<cmStdString> CustomErrorExceptions;
+  std::vector<std::string> CustomErrorExceptions;
-  std::vector<cmStdString> CustomWarningMatches;
+  std::vector<std::string> CustomWarningMatches;
-  std::vector<cmStdString> CustomWarningExceptions;
+  std::vector<std::string> CustomWarningExceptions;
   std::vector<std::string> ReallyCustomWarningMatches;
   std::vector<std::string> ReallyCustomWarningExceptions;
   std::vector<cmCTestCompileErrorWarningRex> ErrorWarningFileLineRegex;
@@ -121,8 +121,8 @@ private:
   size_t                                BuildOutputLogSize;
   std::vector<char>                     CurrentProcessingLine;
 
-  cmStdString                           SimplifySourceDir;
+  std::string                           SimplifySourceDir;
-  cmStdString                           SimplifyBuildDir;
+  std::string                           SimplifyBuildDir;
   size_t                                OutputLineCounter;
   typedef std::vector<cmCTestBuildErrorWarning> t_ErrorsAndWarningsVector;
   t_ErrorsAndWarningsVector             ErrorsAndWarnings;
@@ -130,7 +130,7 @@ private:
   size_t                                PostContextCount;
   size_t                                MaxPreContext;
   size_t                                MaxPostContext;
-  std::deque<cmStdString>               PreContext;
+  std::deque<std::string>               PreContext;
 
   int                                   TotalErrors;
   int                                   TotalWarnings;

Source/CTest/cmCTestCVS.cxx

@@ -99,7 +99,7 @@ bool cmCTestCVS::UpdateImpl()
       opts = "-dP";
       }
     }
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // Specify the start time for nightly testing.
   if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
@@ -112,7 +112,7 @@ bool cmCTestCVS::UpdateImpl()
   cvs_update.push_back(this->CommandLineTool.c_str());
   cvs_update.push_back("-z3");
   cvs_update.push_back("update");
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     cvs_update.push_back(ai->c_str());
@@ -308,7 +308,7 @@ bool cmCTestCVS::WriteXMLUpdates(std::ostream& xml)
              "   Gathering version information (one . per updated file):\n"
              "    " << std::flush);
 
-  for(std::map<cmStdString, Directory>::const_iterator
+  for(std::map<std::string, Directory>::const_iterator
         di = this->Dirs.begin(); di != this->Dirs.end(); ++di)
     {
     this->WriteXMLDirectory(xml, di->first, di->second);

Source/CTest/cmCTestCVS.h

@@ -32,8 +32,8 @@ private:
   virtual bool WriteXMLUpdates(std::ostream& xml);
 
   // Update status for files in each directory.
-  class Directory: public std::map<cmStdString, PathStatus> {};
+  class Directory: public std::map<std::string, PathStatus> {};
-  std::map<cmStdString, Directory> Dirs;
+  std::map<std::string, Directory> Dirs;
 
   std::string ComputeBranchFlag(std::string const& dir);
   void LoadRevisions(std::string const& file, const char* branchFlag,

Source/CTest/cmCTestCoverageCommand.h

@@ -56,7 +56,7 @@ protected:
   };
 
   bool LabelsMentioned;
-  std::set<cmStdString> Labels;
+  std::set<std::string> Labels;
 };
 
 

Source/CTest/cmCTestCoverageHandler.cxx

@@ -363,7 +363,7 @@ int cmCTestCoverageHandler::ProcessHandler()
 
   // setup the regex exclude stuff
   this->CustomCoverageExcludeRegex.clear();
-  std::vector<cmStdString>::iterator rexIt;
+  std::vector<std::string>::iterator rexIt;
   for ( rexIt = this->CustomCoverageExclude.begin();
     rexIt != this->CustomCoverageExclude.end();
     ++ rexIt )
@@ -713,7 +713,7 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
                                 this->CustomCoverageExclude);
   this->CTest->PopulateCustomVector(mf, "CTEST_EXTRA_COVERAGE_GLOB",
                                 this->ExtraCoverageGlobs);
-  std::vector<cmStdString>::iterator it;
+  std::vector<std::string>::iterator it;
   for ( it = this->CustomCoverageExclude.begin();
     it != this->CustomCoverageExclude.end();
     ++ it )
@@ -989,8 +989,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
       << "--------------------------------------------------------------"
       << std::endl);
 
-    std::vector<cmStdString> lines;
+    std::vector<std::string> lines;
-    std::vector<cmStdString>::iterator line;
+    std::vector<std::string>::iterator line;
 
     cmSystemTools::Split(output.c_str(), lines);
 
@@ -1504,7 +1504,7 @@ namespace
 //----------------------------------------------------------------------
 int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
   cmCTestCoverageHandlerContainer* cont,
-  std::set<cmStdString>& coveredFileNames,
+  std::set<std::string>& coveredFileNames,
   std::vector<std::string>& files,
   std::vector<std::string>& filesFullPath)
 {
@@ -1545,7 +1545,7 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
                outputFile.c_str() << std::endl);
     return 0;
     }
-  std::map<cmStdString, cmStdString> fileMap;
+  std::map<std::string, std::string> fileMap;
   std::vector<std::string>::iterator fp = filesFullPath.begin();
   for(std::vector<std::string>::iterator f =  files.begin();
       f != files.end(); ++f, ++fp)
@@ -1558,7 +1558,7 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
   std::string lineIn;
   bool valid = false; // are we in a valid output file
   int line = 0; // line of the current file
-  cmStdString file;
+  std::string file;
   while(cmSystemTools::GetLineFromStream(fin, lineIn))
     {
     bool startFile = false;
@@ -1593,7 +1593,7 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
           }
         count++; // move on one
         }
-      std::map<cmStdString, cmStdString>::iterator
+      std::map<std::string, std::string>::iterator
         i = fileMap.find(file);
       // if the file should be covered write out the header for that file
       if(i != fileMap.end())
@@ -1758,7 +1758,7 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
                outputFile.c_str() << std::endl);
     return 0;
     }
-  std::set<cmStdString> coveredFileNames;
+  std::set<std::string> coveredFileNames;
   while(cmSystemTools::GetLineFromStream(fin, stdline))
     {
     // if we have a line of output from stdout
@@ -2105,10 +2105,10 @@ void cmCTestCoverageHandler::WriteXMLLabels(std::ostream& os,
 
 //----------------------------------------------------------------------------
 void
-cmCTestCoverageHandler::SetLabelFilter(std::set<cmStdString> const& labels)
+cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels)
 {
   this->LabelFilter.clear();
-  for(std::set<cmStdString>::const_iterator li = labels.begin();
+  for(std::set<std::string>::const_iterator li = labels.begin();
       li != labels.end(); ++li)
     {
     this->LabelFilter.insert(this->GetLabelId(*li));
@@ -2158,7 +2158,7 @@ std::set<std::string> cmCTestCoverageHandler::FindUncoveredFiles(
 {
   std::set<std::string> extraMatches;
 
-  for(std::vector<cmStdString>::iterator i = this->ExtraCoverageGlobs.begin();
+  for(std::vector<std::string>::iterator i = this->ExtraCoverageGlobs.begin();
       i != this->ExtraCoverageGlobs.end(); ++i)
     {
     cmsys::Glob gl;

Source/CTest/cmCTestCoverageHandler.h

@@ -55,7 +55,7 @@ public:
   void PopulateCustomVectors(cmMakefile *mf);
 
   /** Report coverage only for sources with these labels.  */
-  void SetLabelFilter(std::set<cmStdString> const& labels);
+  void SetLabelFilter(std::set<std::string> const& labels);
 
 private:
   bool ShouldIDoCoverage(const char* file, const char* srcDir,
@@ -81,7 +81,7 @@ private:
   int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
   int RunBullseyeSourceSummary(cmCTestCoverageHandlerContainer* cont);
   int RunBullseyeCoverageBranch(cmCTestCoverageHandlerContainer* cont,
-                                std::set<cmStdString>& coveredFileNames,
+                                std::set<std::string>& coveredFileNames,
                                 std::vector<std::string>& files,
                                 std::vector<std::string>& filesFullPath);
 
@@ -112,19 +112,19 @@ private:
 
   std::set<std::string> FindUncoveredFiles(
     cmCTestCoverageHandlerContainer* cont);
-  std::vector<cmStdString> CustomCoverageExclude;
+  std::vector<std::string> CustomCoverageExclude;
   std::vector<cmsys::RegularExpression> CustomCoverageExcludeRegex;
-  std::vector<cmStdString> ExtraCoverageGlobs;
+  std::vector<std::string> ExtraCoverageGlobs;
 
 
   // Map from source file to label ids.
   class LabelSet: public std::set<int> {};
-  typedef std::map<cmStdString, LabelSet> LabelMapType;
+  typedef std::map<std::string, LabelSet> LabelMapType;
   LabelMapType SourceLabels;
   LabelMapType TargetDirs;
 
   // Map from label name to label id.
-  typedef std::map<cmStdString, int> LabelIdMapType;
+  typedef std::map<std::string, int> LabelIdMapType;
   LabelIdMapType LabelIdMap;
   std::vector<std::string> Labels;
   int GetLabelId(std::string const& label);

Source/CTest/cmCTestGIT.cxx

@@ -179,8 +179,8 @@ bool cmCTestGIT::UpdateByFetchAndReset()
     {
     opts = this->CTest->GetCTestConfiguration("GITUpdateOptions");
     }
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     git_fetch.push_back(ai->c_str());

Source/CTest/cmCTestGenericHandler.h

@@ -71,7 +71,7 @@ public:
   cmCTestGenericHandler();
   virtual ~cmCTestGenericHandler();
 
-  typedef std::map<cmStdString,cmStdString> t_StringToString;
+  typedef std::map<std::string,std::string> t_StringToString;
 
 
   void SetPersistentOption(const std::string& op, const char* value);

Source/CTest/cmCTestGlobalVC.cxx

@@ -132,7 +132,7 @@ bool cmCTestGlobalVC::WriteXMLUpdates(std::ostream& xml)
 
   this->WriteXMLGlobal(xml);
 
-  for(std::map<cmStdString, Directory>::const_iterator
+  for(std::map<std::string, Directory>::const_iterator
         di = this->Dirs.begin(); di != this->Dirs.end(); ++di)
     {
     this->WriteXMLDirectory(xml, di->first, di->second);

Source/CTest/cmCTestGlobalVC.h

@@ -39,8 +39,8 @@ protected:
   };
 
   // Update status for files in each directory.
-  class Directory: public std::map<cmStdString, File> {};
+  class Directory: public std::map<std::string, File> {};
-  std::map<cmStdString, Directory> Dirs;
+  std::map<std::string, Directory> Dirs;
 
   // Old and new repository revisions.
   std::string OldRevision;

Source/CTest/cmCTestHG.cxx

@@ -149,8 +149,8 @@ bool cmCTestHG::UpdateImpl()
     {
     opts = this->CTest->GetCTestConfiguration("HGUpdateOptions");
     }
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     hg_update.push_back(ai->c_str());

Source/CTest/cmCTestLaunch.cxx

@@ -567,7 +567,7 @@ void cmCTestLaunch::WriteXMLLabels(std::ostream& fxml)
     fxml << "\n";
     fxml << "\t\t<!-- Interested parties -->\n";
     fxml << "\t\t<Labels>\n";
-    for(std::set<cmStdString>::const_iterator li = this->Labels.begin();
+    for(std::set<std::string>::const_iterator li = this->Labels.begin();
         li != this->Labels.end(); ++li)
       {
       fxml << "\t\t\t<Label>" << cmXMLSafe(*li) << "</Label>\n";

Source/CTest/cmCTestLaunch.h

@@ -73,7 +73,7 @@ private:
   bool HaveErr;
 
   // Labels associated with the build rule.
-  std::set<cmStdString> Labels;
+  std::set<std::string> Labels;
   void LoadLabels();
   bool SourceMatches(std::string const& lhs,
                      std::string const& rhs);

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -246,8 +246,8 @@ int cmCTestMemCheckHandler::PostProcessHandler()
 void cmCTestMemCheckHandler::GenerateTestCommand(
   std::vector<std::string>& args, int test)
 {
-  std::vector<cmStdString>::size_type pp;
+  std::vector<std::string>::size_type pp;
-  cmStdString index;
+  std::string index;
   cmOStringStream stream;
   std::string memcheckcommand
     = cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str());
@@ -255,9 +255,9 @@ void cmCTestMemCheckHandler::GenerateTestCommand(
   index = stream.str();
   for ( pp = 0; pp < this->MemoryTesterDynamicOptions.size(); pp ++ )
     {
-    cmStdString arg = this->MemoryTesterDynamicOptions[pp];
+      std::string arg = this->MemoryTesterDynamicOptions[pp];
-    cmStdString::size_type pos = arg.find("??");
+      std::string::size_type pos = arg.find("??");
-    if (pos != cmStdString::npos)
+    if (pos != std::string::npos)
       {
       arg.replace(pos, 2, index);
       }
@@ -580,7 +580,7 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
       return false;
     }
 
-  std::vector<cmStdString>::size_type cc;
+  std::vector<std::string>::size_type cc;
   for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ )
     {
     this->MemoryTesterGlobalResults[cc] = 0;
@@ -627,7 +627,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
   const std::string& str, std::string& log,
   int* results)
 {
-  std::vector<cmStdString> lines;
+  std::vector<std::string> lines;
   cmSystemTools::Split(str.c_str(), lines);
   cmOStringStream ostr;
   log = "";
@@ -636,7 +636,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
 
   int defects = 0;
 
-  for( std::vector<cmStdString>::iterator i = lines.begin();
+  for( std::vector<std::string>::iterator i = lines.begin();
        i != lines.end(); ++i)
     {
     int failure = cmCTestMemCheckHandler::NO_MEMORY_FAULT;
@@ -681,7 +681,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
   const std::string& str, std::string& log,
   int* results)
 {
-  std::vector<cmStdString> lines;
+  std::vector<std::string> lines;
   cmSystemTools::Split(str.c_str(), lines);
   bool unlimitedOutput = false;
   if(str.find("CTEST_FULL_OUTPUT") != str.npos ||
@@ -864,10 +864,10 @@ bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput(
 {
   log = "";
   double sttime = cmSystemTools::GetTime();
-  std::vector<cmStdString> lines;
+  std::vector<std::string> lines;
   cmSystemTools::Split(str.c_str(), lines);
   cmCTestLog(this->CTest, DEBUG, "Start test: " << lines.size() << std::endl);
-  std::vector<cmStdString>::size_type cc;
+  std::vector<std::string>::size_type cc;
   for ( cc = 0; cc < lines.size(); cc ++ )
     {
     if(lines[cc] == BOUNDS_CHECKER_MARKER)
@@ -923,7 +923,7 @@ cmCTestMemCheckHandler::PostProcessBoundsCheckerTest(cmCTestTestResult& res,
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
              "PostProcessBoundsCheckerTest for : "
              << res.Name.c_str() << std::endl);
-  cmStdString ofile = testOutputFileName(test);
+  std::string ofile = testOutputFileName(test);
   if ( ofile.empty() )
     {
     return;
@@ -979,7 +979,7 @@ void
 cmCTestMemCheckHandler::appendMemTesterOutput(cmCTestTestResult& res,
                                               int test)
 {
-  cmStdString ofile = testOutputFileName(test);
+  std::string ofile = testOutputFileName(test);
 
   if ( ofile.empty() )
     {
@@ -1000,15 +1000,15 @@ cmCTestMemCheckHandler::appendMemTesterOutput(cmCTestTestResult& res,
     }
 }
 
-cmStdString
+std::string
 cmCTestMemCheckHandler::testOutputFileName(int test)
 {
-  cmStdString index;
+  std::string index;
   cmOStringStream stream;
   stream << test;
   index = stream.str();
-  cmStdString ofile = this->MemoryTesterOutputFile;
+  std::string ofile = this->MemoryTesterOutputFile;
-  cmStdString::size_type pos = ofile.find("??");
+  std::string::size_type pos = ofile.find("??");
   ofile.replace(pos, 2, index);
 
   if ( !cmSystemTools::FileExists(ofile.c_str()) )

Source/CTest/cmCTestMemCheckHandler.h

@@ -89,8 +89,8 @@ private:
   std::string              BoundsCheckerDPBDFile;
   std::string              BoundsCheckerXMLFile;
   std::string              MemoryTester;
-  std::vector<cmStdString> MemoryTesterDynamicOptions;
+  std::vector<std::string> MemoryTesterDynamicOptions;
-  std::vector<cmStdString> MemoryTesterOptions;
+  std::vector<std::string> MemoryTesterOptions;
   int                      MemoryTesterStyle;
   std::string              MemoryTesterOutputFile;
   int                      MemoryTesterGlobalResults[NO_MEMORY_FAULT];
@@ -103,8 +103,8 @@ private:
    */
   void GenerateDartOutput(std::ostream& os);
 
-  std::vector<cmStdString> CustomPreMemCheck;
+  std::vector<std::string> CustomPreMemCheck;
-  std::vector<cmStdString> CustomPostMemCheck;
+  std::vector<std::string> CustomPostMemCheck;
 
   //! Parse Valgrind/Purify/Bounds Checker result out of the output
   //string. After running, log holds the output and results hold the
@@ -127,7 +127,7 @@ private:
                              int test);
 
   ///! generate the output filename for the given test index
-  cmStdString testOutputFileName(int test);
+  std::string testOutputFileName(int test);
 };
 
 #endif

Source/CTest/cmCTestMultiProcessHandler.cxx

@@ -369,7 +369,7 @@ void cmCTestMultiProcessHandler::UpdateCostData()
 
   // Write list of failed tests
   fout << "---\n";
-  for(std::vector<cmStdString>::iterator i = this->Failed->begin();
+  for(std::vector<std::string>::iterator i = this->Failed->begin();
       i != this->Failed->end(); ++i)
     {
     fout << i->c_str() << "\n";

Source/CTest/cmCTestMultiProcessHandler.h

@@ -41,8 +41,8 @@ public:
   void PrintTestList();
   void PrintLabels();
 
-  void SetPassFailVectors(std::vector<cmStdString>* passed,
+  void SetPassFailVectors(std::vector<std::string>* passed,
-                          std::vector<cmStdString>* failed)
+                          std::vector<std::string>* failed)
     {
     this->Passed = passed;
     this->Failed = failed;
@@ -107,9 +107,9 @@ protected:
   PropertiesMap Properties;
   std::map<int, bool> TestRunningMap;
   std::map<int, bool> TestFinishMap;
-  std::map<int, cmStdString> TestOutput;
+  std::map<int, std::string> TestOutput;
-  std::vector<cmStdString>* Passed;
+  std::vector<std::string>* Passed;
-  std::vector<cmStdString>* Failed;
+  std::vector<std::string>* Failed;
   std::vector<std::string> LastTestsFailed;
   std::set<std::string> LockedResources;
   std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults;

Source/CTest/cmCTestP4.cxx

@@ -346,10 +346,10 @@ void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions)
     //The CTEST_P4_OPTIONS variable adds additional Perforce command line
     //options before the main command
     std::string opts = this->CTest->GetCTestConfiguration("P4Options");
-    std::vector<cmStdString> args =
+    std::vector<std::string> args =
             cmSystemTools::ParseArguments(opts.c_str());
 
-    for(std::vector<cmStdString>::const_iterator ai = args.begin();
+    for(std::vector<std::string>::const_iterator ai = args.begin();
         ai != args.end(); ++ai)
       {
       P4Options.push_back(ai->c_str());
@@ -538,8 +538,8 @@ bool cmCTestP4::UpdateImpl()
     {
     opts = this->CTest->GetCTestConfiguration("P4UpdateOptions");
     }
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     p4_sync.push_back(ai->c_str());

Source/CTest/cmCTestSVN.cxx

@@ -277,7 +277,7 @@ bool cmCTestSVN::UpdateImpl()
     {
     opts = this->CTest->GetCTestConfiguration("SVNUpdateOptions");
     }
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(opts.c_str());
+  std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // Specify the start time for nightly testing.
   if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
@@ -287,7 +287,7 @@ bool cmCTestSVN::UpdateImpl()
 
   std::vector<char const*> svn_update;
   svn_update.push_back("update");
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     svn_update.push_back(ai->c_str());
@@ -314,9 +314,9 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
   std::string userOptions =
     this->CTest->GetCTestConfiguration("SVNOptions");
 
-  std::vector<cmStdString> parsedUserOptions =
+  std::vector<std::string> parsedUserOptions =
     cmSystemTools::ParseArguments(userOptions.c_str());
-  for(std::vector<cmStdString>::iterator i = parsedUserOptions.begin();
+  for(std::vector<std::string>::iterator i = parsedUserOptions.begin();
       i != parsedUserOptions.end(); ++i)
     {
     args.push_back(i->c_str());

Source/CTest/cmCTestScriptHandler.cxx

@@ -231,7 +231,7 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
              cmSystemTools::GetCTestCommand() << "\n");
 
   // now pass through all the other arguments
-  std::vector<cmStdString> &initArgs =
+  std::vector<std::string> &initArgs =
     this->CTest->GetInitialCommandLineArguments();
   //*** need to make sure this does not have the current script ***
   for(size_t i=1; i < initArgs.size(); ++i)
@@ -766,7 +766,7 @@ int cmCTestScriptHandler::PerformExtraUpdates()
 
   // do an initial cvs update as required
   command = this->UpdateCmd;
-  std::vector<cmStdString>::iterator it;
+  std::vector<std::string>::iterator it;
   for (it = this->ExtraUpdates.begin();
     it != this->ExtraUpdates.end();
     ++ it )

Source/CTest/cmCTestScriptHandler.h

@@ -138,26 +138,26 @@ private:
   // Try to remove the binary directory once
   static bool TryToRemoveBinaryDirectoryOnce(const std::string& directoryPath);
 
-  std::vector<cmStdString> ConfigurationScripts;
+  std::vector<std::string> ConfigurationScripts;
   std::vector<bool> ScriptProcessScope;
 
   bool Backup;
   bool EmptyBinDir;
   bool EmptyBinDirOnce;
 
-  cmStdString SourceDir;
+  std::string SourceDir;
-  cmStdString BinaryDir;
+  std::string BinaryDir;
-  cmStdString BackupSourceDir;
+  std::string BackupSourceDir;
-  cmStdString BackupBinaryDir;
+  std::string BackupBinaryDir;
-  cmStdString CTestRoot;
+  std::string CTestRoot;
-  cmStdString CVSCheckOut;
+  std::string CVSCheckOut;
-  cmStdString CTestCmd;
+  std::string CTestCmd;
-  cmStdString UpdateCmd;
+  std::string UpdateCmd;
-  cmStdString CTestEnv;
+  std::string CTestEnv;
-  cmStdString InitialCache;
+  std::string InitialCache;
-  cmStdString CMakeCmd;
+  std::string CMakeCmd;
-  cmStdString CMOutFile;
+  std::string CMOutFile;
-  std::vector<cmStdString> ExtraUpdates;
+  std::vector<std::string> ExtraUpdates;
 
   double MinimumInterval;
   double ContinuousDuration;

Source/CTest/cmCTestSubmitCommand.cxx

@@ -72,7 +72,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
   if (notesFilesVariable)
     {
     std::vector<std::string> notesFiles;
-    std::vector<cmStdString> newNotesFiles;
+    cmCTest::VectorOfStrings newNotesFiles;
     cmSystemTools::ExpandListArgument(notesFilesVariable,notesFiles);
     std::vector<std::string>::iterator it;
     for ( it = notesFiles.begin();
@@ -89,7 +89,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
   if (extraFilesVariable)
     {
     std::vector<std::string> extraFiles;
-    std::vector<cmStdString> newExtraFiles;
+    cmCTest::VectorOfStrings newExtraFiles;
     cmSystemTools::ExpandListArgument(extraFilesVariable,extraFiles);
     std::vector<std::string>::iterator it;
     for ( it = extraFiles.begin();
@@ -222,7 +222,7 @@ bool cmCTestSubmitCommand::CheckArgumentValue(std::string const& arg)
 
   if(this->ArgumentDoing == ArgumentDoingFiles)
     {
-    cmStdString filename(arg);
+    std::string filename(arg);
     if(cmSystemTools::FileExists(filename.c_str()))
       {
       this->Files.insert(filename);

Source/CTest/cmCTestSubmitHandler.cxx

@@ -170,10 +170,10 @@ void cmCTestSubmitHandler::Initialize()
 }
 
 //----------------------------------------------------------------------------
-bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
+bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
-  const std::set<cmStdString>& files,
+  const std::set<std::string>& files,
-  const cmStdString& remoteprefix,
+  const std::string& remoteprefix,
-  const cmStdString& url)
+  const std::string& url)
 {
   CURL *curl;
   CURLcode res;
@@ -217,12 +217,12 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
 
       ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
 
-      cmStdString local_file = *file;
+      std::string local_file = *file;
       if ( !cmSystemTools::FileExists(local_file.c_str()) )
         {
         local_file = localprefix + "/" + *file;
         }
-      cmStdString upload_as
+      std::string upload_as
         = url + "/" + remoteprefix + cmSystemTools::GetFilenameName(*file);
 
       struct stat st;
@@ -324,10 +324,10 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
 
 //----------------------------------------------------------------------------
 // Uploading files is simpler
-bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
+bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
-  const std::set<cmStdString>& files,
+  const std::set<std::string>& files,
-  const cmStdString& remoteprefix,
+  const std::string& remoteprefix,
-  const cmStdString& url)
+  const std::string& url)
 {
   CURL *curl;
   CURLcode res;
@@ -336,8 +336,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
 
   /* In windows, this will init the winsock stuff */
   ::curl_global_init(CURL_GLOBAL_ALL);
-  cmStdString dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
+  std::string dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
-  cmStdString curlopt(this->CTest->GetCTestConfiguration("CurlOptions"));
+  std::string curlopt(this->CTest->GetCTestConfiguration("CurlOptions"));
   std::vector<std::string> args;
   cmSystemTools::ExpandListArgument(curlopt.c_str(), args);
   bool verifyPeerOff = false;
@@ -354,7 +354,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
       verifyHostOff = true;
       }
     }
-  cmStdString::size_type kk;
+  std::string::size_type kk;
   cmCTest::SetOfStrings::const_iterator file;
   for ( file = files.begin(); file != files.end(); ++file )
     {
@@ -414,18 +414,18 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
       ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
       ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 
-      cmStdString local_file = *file;
+      std::string local_file = *file;
       if ( !cmSystemTools::FileExists(local_file.c_str()) )
         {
         local_file = localprefix + "/" + *file;
         }
-      cmStdString remote_file
+      std::string remote_file
         = remoteprefix + cmSystemTools::GetFilenameName(*file);
 
       *this->LogFile << "\tUpload file: " << local_file.c_str() << " to "
           << remote_file.c_str() << std::endl;
 
-      cmStdString ofile = "";
+      std::string ofile = "";
       for ( kk = 0; kk < remote_file.size(); kk ++ )
         {
         char c = remote_file[kk];
@@ -448,8 +448,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
           ofile.append(hexCh);
           }
         }
-      cmStdString upload_as
+      std::string upload_as
-        = url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
+        = url + ((url.find("?",0) == std::string::npos) ? "?" : "&")
         + "FileName=" + ofile;
 
       upload_as += "&MD5=";
@@ -666,9 +666,9 @@ void cmCTestSubmitHandler
 
 //----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::TriggerUsingHTTP(
-  const std::set<cmStdString>& files,
+  const std::set<std::string>& files,
-  const cmStdString& remoteprefix,
+  const std::string& remoteprefix,
-  const cmStdString& url)
+  const std::string& url)
 {
   CURL *curl;
   char error_buffer[1024];
@@ -721,10 +721,10 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
       ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
       ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
 
-      cmStdString rfile
+      std::string rfile
         = remoteprefix + cmSystemTools::GetFilenameName(*file);
-      cmStdString ofile = "";
+      std::string ofile = "";
-      cmStdString::iterator kk;
+      std::string::iterator kk;
       for ( kk = rfile.begin(); kk < rfile.end(); ++ kk)
         {
         char c = *kk;
@@ -747,8 +747,8 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
           ofile.append(hexCh);
           }
         }
-      cmStdString turl
+      std::string turl
-        = url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
+        = url + ((url.find("?",0) == std::string::npos) ? "?" : "&")
         + "xmlfile=" + ofile;
       *this->LogFile << "Trigger url: " << turl.c_str() << std::endl;
       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Trigger url: "
@@ -805,11 +805,11 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
 
 //----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::SubmitUsingSCP(
-  const cmStdString& scp_command,
+  const std::string& scp_command,
-  const cmStdString& localprefix,
+  const std::string& localprefix,
-  const std::set<cmStdString>& files,
+  const std::set<std::string>& files,
-  const cmStdString& remoteprefix,
+  const std::string& remoteprefix,
-  const cmStdString& url)
+  const std::string& url)
 {
   if ( !scp_command.size() || !localprefix.size() ||
     !files.size() || !remoteprefix.size() || !url.size() )
@@ -906,10 +906,10 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
 
 //----------------------------------------------------------------------------
 bool cmCTestSubmitHandler::SubmitUsingCP(
-  const cmStdString& localprefix,
+  const std::string& localprefix,
-  const std::set<cmStdString>& files,
+  const std::set<std::string>& files,
-  const cmStdString& remoteprefix,
+  const std::string& remoteprefix,
-  const cmStdString& destination)
+  const std::string& destination)
 {
   if ( !localprefix.size() ||
     !files.size() || !remoteprefix.size() || !destination.size() )
@@ -947,17 +947,17 @@ bool cmCTestSubmitHandler::SubmitUsingCP(
 
 //----------------------------------------------------------------------------
 #if defined(CTEST_USE_XMLRPC)
-bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
+bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const std::string& localprefix,
-  const std::set<cmStdString>& files,
+  const std::set<std::string>& files,
-  const cmStdString& remoteprefix,
+  const std::string& remoteprefix,
-  const cmStdString& url)
+  const std::string& url)
 {
   xmlrpc_env env;
   char ctestString[] = "CTest";
   std::string ctestVersionString = cmVersion::GetCMakeVersion();
   char* ctestVersion = const_cast<char*>(ctestVersionString.c_str());
 
-  cmStdString realURL = url + "/" + remoteprefix + "/Command/";
+  std::string realURL = url + "/" + remoteprefix + "/Command/";
 
   /* Start up our XML-RPC client library. */
   xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, ctestString, ctestVersion);
@@ -973,7 +973,7 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
     {
     xmlrpc_value *result;
 
-    cmStdString local_file = *file;
+    std::string local_file = *file;
     if ( !cmSystemTools::FileExists(local_file.c_str()) )
       {
       local_file = localprefix + "/" + *file;
@@ -1045,10 +1045,10 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
   return true;
 }
 #else
-bool cmCTestSubmitHandler::SubmitUsingXMLRPC(cmStdString const&,
+bool cmCTestSubmitHandler::SubmitUsingXMLRPC(std::string const&,
-                                             std::set<cmStdString> const&,
+                                             std::set<std::string> const&,
-                                             cmStdString const&,
+                                             std::string const&,
-                                             cmStdString const&)
+                                             std::string const&)
 {
   return false;
 }
@@ -1085,7 +1085,7 @@ int cmCTestSubmitHandler::ProcessHandler()
       }
     if ( getenv("HTTP_PROXY_TYPE") )
       {
-      cmStdString type = getenv("HTTP_PROXY_TYPE");
+      std::string type = getenv("HTTP_PROXY_TYPE");
       // HTTP/SOCKS4/SOCKS5
       if ( type == "HTTP" )
         {
@@ -1122,7 +1122,7 @@ int cmCTestSubmitHandler::ProcessHandler()
       }
     if ( getenv("FTP_PROXY_TYPE") )
       {
-      cmStdString type = getenv("FTP_PROXY_TYPE");
+      std::string type = getenv("FTP_PROXY_TYPE");
       // HTTP/SOCKS4/SOCKS5
       if ( type == "HTTP" )
         {
@@ -1178,7 +1178,7 @@ int cmCTestSubmitHandler::ProcessHandler()
   this->CTest->AddIfExists(cmCTest::PartTest, "Test.xml");
   if(this->CTest->AddIfExists(cmCTest::PartCoverage, "Coverage.xml"))
     {
-    cmCTest::VectorOfStrings gfiles;
+    std::vector<std::string> gfiles;
     std::string gpath
       = buildDirectory + "/Testing/" + this->CTest->GetCurrentTag();
     std::string::size_type glen = gpath.size() + 1;
@@ -1247,7 +1247,7 @@ int cmCTestSubmitHandler::ProcessHandler()
     }
   this->SetLogFile(&ofs);
 
-  cmStdString dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
+  std::string dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
 
   if ( dropMethod == "" || dropMethod == "ftp" )
     {

Source/CTest/cmCTestSubmitHandler.h

@@ -47,33 +47,33 @@ private:
   /**
    * Submit file using various ways
    */
-  bool SubmitUsingFTP(const cmStdString& localprefix,
+  bool SubmitUsingFTP(const std::string& localprefix,
-                      const std::set<cmStdString>& files,
+                      const std::set<std::string>& files,
-                      const cmStdString& remoteprefix,
+                      const std::string& remoteprefix,
-                      const cmStdString& url);
+                      const std::string& url);
-  bool SubmitUsingHTTP(const cmStdString& localprefix,
+  bool SubmitUsingHTTP(const std::string& localprefix,
-                       const std::set<cmStdString>& files,
+                       const std::set<std::string>& files,
-                       const cmStdString& remoteprefix,
+                       const std::string& remoteprefix,
-                       const cmStdString& url);
+                       const std::string& url);
-  bool SubmitUsingSCP(const cmStdString& scp_command,
+  bool SubmitUsingSCP(const std::string& scp_command,
-                      const cmStdString& localprefix,
+                      const std::string& localprefix,
-                      const std::set<cmStdString>& files,
+                      const std::set<std::string>& files,
-                      const cmStdString& remoteprefix,
+                      const std::string& remoteprefix,
-                      const cmStdString& url);
+                      const std::string& url);
 
-  bool SubmitUsingCP( const cmStdString& localprefix,
+  bool SubmitUsingCP( const std::string& localprefix,
-                      const std::set<cmStdString>& files,
+                      const std::set<std::string>& files,
-                      const cmStdString& remoteprefix,
+                      const std::string& remoteprefix,
-                      const cmStdString& url);
+                      const std::string& url);
 
-  bool TriggerUsingHTTP(const std::set<cmStdString>& files,
+  bool TriggerUsingHTTP(const std::set<std::string>& files,
-                        const cmStdString& remoteprefix,
+                        const std::string& remoteprefix,
-                        const cmStdString& url);
+                        const std::string& url);
 
-  bool SubmitUsingXMLRPC(const cmStdString& localprefix,
+  bool SubmitUsingXMLRPC(const std::string& localprefix,
-                       const std::set<cmStdString>& files,
+                       const std::set<std::string>& files,
-                       const cmStdString& remoteprefix,
+                       const std::string& remoteprefix,
-                       const cmStdString& url);
+                       const std::string& url);
 
   typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
 
@@ -82,10 +82,10 @@ private:
   std::string GetSubmitResultsPrefix();
 
   class         ResponseParser;
-  cmStdString   HTTPProxy;
+  std::string   HTTPProxy;
   int           HTTPProxyType;
-  cmStdString   HTTPProxyAuth;
+  std::string   HTTPProxyAuth;
-  cmStdString   FTPProxy;
+  std::string   FTPProxy;
   int           FTPProxyType;
   std::ostream* LogFile;
   bool SubmitPart[cmCTest::PartCount];

Source/CTest/cmCTestTestHandler.cxx

@@ -540,8 +540,8 @@ int cmCTestTestHandler::ProcessHandler()
   this->StartLogFile((this->MemCheck ? "DynamicAnalysis" : "Test"), mLogFile);
   this->LogFile = &mLogFile;
 
-  std::vector<cmStdString> passed;
+  std::vector<std::string> passed;
-  std::vector<cmStdString> failed;
+  std::vector<std::string> failed;
   int total;
 
   //start the real time clock
@@ -569,7 +569,7 @@ int cmCTestTestHandler::ProcessHandler()
       {
       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
         << "The following tests passed:" << std::endl);
-      for(std::vector<cmStdString>::iterator j = passed.begin();
+      for(std::vector<std::string>::iterator j = passed.begin();
           j != passed.end(); ++j)
         {
         cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j
@@ -661,8 +661,8 @@ void cmCTestTestHandler::PrintLabelSummary()
   cmCTestTestHandler::ListOfTests::iterator it = this->TestList.begin();
   cmCTestTestHandler::TestResultsVector::iterator ri =
     this->TestResults.begin();
-  std::map<cmStdString, double> labelTimes;
+  std::map<std::string, double> labelTimes;
-  std::set<cmStdString> labels;
+  std::set<std::string> labels;
   // initialize maps
   std::string::size_type maxlen = 0;
   for(; it != this->TestList.end(); ++it)
@@ -702,7 +702,7 @@ void cmCTestTestHandler::PrintLabelSummary()
     {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:");
     }
-  for(std::set<cmStdString>::const_iterator i = labels.begin();
+  for(std::set<std::string>::const_iterator i = labels.begin();
       i != labels.end(); ++i)
     {
     std::string label = *i;
@@ -1050,8 +1050,8 @@ bool cmCTestTestHandler::GetValue(const char* tag,
 }
 
 //---------------------------------------------------------------------
-void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
+void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
-                                         std::vector<cmStdString> &failed)
+                                         std::vector<std::string> &failed)
 {
   this->ComputeTestList();
   this->StartTest = this->CTest->CurrentTime();
@@ -1216,7 +1216,7 @@ void cmCTestTestHandler::GenerateDartOutput(std::ostream& os)
       << "name=\"Command Line\"><Value>"
       << cmXMLSafe(result->FullCommandLine)
       << "</Value></NamedMeasurement>\n";
-    std::map<cmStdString,cmStdString>::iterator measureIt;
+    std::map<std::string,std::string>::iterator measureIt;
     for ( measureIt = result->Properties->Measurements.begin();
       measureIt != result->Properties->Measurements.end();
       ++ measureIt )
@@ -1328,9 +1328,9 @@ void cmCTestTestHandler::AttachFiles(std::ostream& os,
 }
 
 //----------------------------------------------------------------------
-int cmCTestTestHandler::ExecuteCommands(std::vector<cmStdString>& vec)
+int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec)
 {
-  std::vector<cmStdString>::iterator it;
+  std::vector<std::string>::iterator it;
   for ( it = vec.begin(); it != vec.end(); ++it )
     {
     int retVal = 0;
@@ -2112,7 +2112,7 @@ bool cmCTestTestHandler::SetTestsProperties(
   const std::vector<std::string>& args)
 {
   std::vector<std::string>::const_iterator it;
-  std::vector<cmStdString> tests;
+  std::vector<std::string> tests;
   bool found = false;
   for ( it = args.begin(); it != args.end(); ++ it )
     {
@@ -2137,7 +2137,7 @@ bool cmCTestTestHandler::SetTestsProperties(
       break;
       }
     std::string val = *it;
-    std::vector<cmStdString>::const_iterator tit;
+    std::vector<std::string>::const_iterator tit;
     for ( tit = tests.begin(); tit != tests.end(); ++ tit )
       {
       cmCTestTestHandler::ListOfTests::iterator rtit;
@@ -2319,7 +2319,7 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
     }
   if ( this->MemCheck )
     {
-    std::vector<cmStdString>::iterator it;
+    std::vector<std::string>::iterator it;
     bool found = false;
     for ( it = this->CustomTestsIgnore.begin();
       it != this->CustomTestsIgnore.end(); ++ it )
@@ -2339,7 +2339,7 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
     }
   else
     {
-    std::vector<cmStdString>::iterator it;
+    std::vector<std::string>::iterator it;
     bool found = false;
     for ( it = this->CustomTestsIgnore.begin();
       it != this->CustomTestsIgnore.end(); ++ it )

Source/CTest/cmCTestTestHandler.h

@@ -87,8 +87,8 @@ public:
   // ctest -j N will break for that feature
   struct cmCTestTestProperties
   {
-    cmStdString Name;
+    std::string Name;
-    cmStdString Directory;
+    std::string Directory;
     std::vector<std::string> Args;
     std::vector<std::string> RequiredFiles;
     std::vector<std::string> Depends;
@@ -98,7 +98,7 @@ public:
                           std::string> > ErrorRegularExpressions;
     std::vector<std::pair<cmsys::RegularExpression,
                           std::string> > RequiredRegularExpressions;
-    std::map<cmStdString, cmStdString> Measurements;
+    std::map<std::string, std::string> Measurements;
     bool IsInBasedOnREOptions;
     bool WillFail;
     float Cost;
@@ -162,7 +162,7 @@ protected:
   virtual int PreProcessHandler();
   virtual int PostProcessHandler();
   virtual void GenerateTestCommand(std::vector<std::string>& args, int test);
-  int ExecuteCommands(std::vector<cmStdString>& vec);
+  int ExecuteCommands(std::vector<std::string>& vec);
 
   void WriteTestResultHeader(std::ostream& os, cmCTestTestResult* result);
   void WriteTestResultFooter(std::ostream& os, cmCTestTestResult* result);
@@ -177,7 +177,7 @@ protected:
   typedef std::vector<cmCTestTestResult> TestResultsVector;
   TestResultsVector    TestResults;
 
-  std::vector<cmStdString> CustomTestsIgnore;
+  std::vector<std::string> CustomTestsIgnore;
   std::string             StartTest;
   std::string             EndTest;
   unsigned int            StartTestTime;
@@ -210,8 +210,8 @@ private:
   /**
    * Run the tests for a directory and any subdirectories
    */
-  void ProcessDirectory(std::vector<cmStdString> &passed,
+  void ProcessDirectory(std::vector<std::string> &passed,
-                        std::vector<cmStdString> &failed);
+                        std::vector<std::string> &failed);
 
   /**
    * Get the list of tests in directory and subdirectories.
@@ -251,8 +251,8 @@ private:
   void ExpandTestsToRunInformation(size_t numPossibleTests);
   void ExpandTestsToRunInformationForRerunFailed();
 
-  std::vector<cmStdString> CustomPreTest;
+  std::vector<std::string> CustomPreTest;
-  std::vector<cmStdString> CustomPostTest;
+  std::vector<std::string> CustomPostTest;
 
   std::vector<int>        TestsToRun;
 

Source/CTest/cmCTestUploadCommand.cxx

@@ -47,7 +47,7 @@ bool cmCTestUploadCommand::CheckArgumentValue(std::string const& arg)
 {
   if(this->ArgumentDoing == ArgumentDoingFiles)
     {
-    cmStdString filename(arg);
+    std::string filename(arg);
     if(cmSystemTools::FileExists(filename.c_str()))
       {
       this->Files.insert(filename);

Source/CTest/cmCTestVC.cxx

@@ -63,9 +63,9 @@ bool cmCTestVC::InitialCheckout(const char* command)
     }
 
   // Construct the initial checkout command line.
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
   std::vector<char const*> vc_co;
-  for(std::vector<cmStdString>::const_iterator ai = args.begin();
+  for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     vc_co.push_back(ai->c_str());

Source/CTest/cmParseGTMCoverage.cxx

@@ -182,7 +182,7 @@ bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
   //          ( file  , entry ) = "number_executed:timing_info"
   // ^COVERAGE("%RSEL","init",8,"FOR_LOOP",1)=1
   //          ( file  , entry, line, IGNORE ) =number_executed
-  std::vector<cmStdString> args;
+  std::vector<std::string> args;
   std::string::size_type pos = line.find('(', 0);
   // if no ( is found, then return line has no coverage
   if(pos == std::string::npos)

Source/CTest/cmParseMumpsCoverage.cxx

@@ -140,7 +140,7 @@ bool cmParseMumpsCoverage::LoadPackages(const char* d)
 bool cmParseMumpsCoverage::FindMumpsFile(std::string const& routine,
                                          std::string& filepath)
 {
-  std::map<cmStdString, cmStdString>::iterator i =
+  std::map<std::string, std::string>::iterator i =
     this->RoutineToDirectory.find(routine);
   if(i != this->RoutineToDirectory.end())
     {

Source/CTest/cmParseMumpsCoverage.h

@@ -44,7 +44,7 @@ protected:
   bool FindMumpsFile(std::string const& routine,
                      std::string& filepath);
 protected:
-  std::map<cmStdString, cmStdString> RoutineToDirectory;
+  std::map<std::string, std::string> RoutineToDirectory;
   cmCTestCoverageHandlerContainer& Coverage;
   cmCTest* CTest;
 };

Source/CTest/cmParsePHPCoverage.cxx

@@ -34,7 +34,7 @@ bool cmParsePHPCoverage::ReadUntil(std::istream& in, char until)
   return true;
 }
 bool cmParsePHPCoverage::ReadCoverageArray(std::istream& in,
-                                           cmStdString const& fileName)
+                                           std::string const& fileName)
 {
   cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector
     = this->Coverage.TotalCoverage[fileName];
@@ -166,7 +166,7 @@ bool cmParsePHPCoverage::ReadFileInformation(std::istream& in)
     // read the string data
     in.read(s, size-1);
     s[size-1] = 0;
-    cmStdString fileName = s;
+    std::string fileName = s;
     delete [] s;
     // read close quote
     if(in.get(c) && c != '"')

Source/CTest/cmParsePHPCoverage.h

@@ -35,7 +35,7 @@ private:
   bool ReadArraySize(std::istream& in, int& size);
   bool ReadFileInformation(std::istream& in);
   bool ReadInt(std::istream& in, int& v);
-  bool ReadCoverageArray(std::istream& in, cmStdString const&);
+  bool ReadCoverageArray(std::istream& in, std::string const&);
   bool ReadUntil(std::istream& in, char until);
   cmCTestCoverageHandlerContainer& Coverage;
   cmCTest* CTest;

Source/CursesDialog/cmCursesPathWidget.cxx

@@ -57,7 +57,7 @@ void cmCursesPathWidget::OnTab(cmCursesMainForm* fm, WINDOW* w)
     {
     glob = cstr + "*";
     }
-  std::vector<cmStdString> dirs;
+  std::vector<std::string> dirs;
 
   cmSystemTools::SimpleGlob(glob.c_str(), dirs, (this->Type == cmCacheManager::PATH?-1:0));
   if ( this->CurrentIndex < dirs.size() )

Source/cmCTest.cxx

@@ -1153,7 +1153,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
   int* retVal, const char* dir, int timeout, std::ostream& ofs)
 {
   // First generate the command and arguments
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
   if(args.size() < 1)
     {
@@ -1161,7 +1161,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
     }
 
   std::vector<const char*> argv;
-  for(std::vector<cmStdString>::const_iterator a = args.begin();
+  for(std::vector<std::string>::const_iterator a = args.begin();
     a != args.end(); ++a)
     {
     argv.push_back(a->c_str());
@@ -1637,7 +1637,7 @@ int cmCTest::GenerateCTestNotesOutput(std::ostream& os,
 }
 
 //----------------------------------------------------------------------
-int cmCTest::GenerateNotesFile(const std::vector<cmStdString> &files)
+int cmCTest::GenerateNotesFile(const VectorOfStrings &files)
 {
   cmGeneratedFileStream ofs;
   if ( !this->OpenOutputFile(this->CurrentTag, "Notes.xml", ofs) )
@@ -1658,7 +1658,7 @@ int cmCTest::GenerateNotesFile(const char* cfiles)
     return 1;
     }
 
-  std::vector<cmStdString> files;
+  VectorOfStrings files;
 
   cmCTestLog(this, OUTPUT, "Create notes file" << std::endl);
 
@@ -1675,7 +1675,7 @@ int cmCTest::GenerateNotesFile(const char* cfiles)
 std::string cmCTest::Base64GzipEncodeFile(std::string file)
 {
   std::string tarFile = file + "_temp.tar.gz";
-  std::vector<cmStdString> files;
+  std::vector<std::string> files;
   files.push_back(file);
 
   if(!cmSystemTools::CreateTar(tarFile.c_str(), files, true, false, false))
@@ -1722,9 +1722,9 @@ std::string cmCTest::Base64EncodeFile(std::string file)
 
 
 //----------------------------------------------------------------------
-bool cmCTest::SubmitExtraFiles(const std::vector<cmStdString> &files)
+bool cmCTest::SubmitExtraFiles(const VectorOfStrings &files)
 {
-  std::vector<cmStdString>::const_iterator it;
+  VectorOfStrings::const_iterator it;
   for ( it = files.begin();
     it != files.end();
     ++ it )
@@ -1749,7 +1749,7 @@ bool cmCTest::SubmitExtraFiles(const char* cfiles)
     return 1;
     }
 
-  std::vector<cmStdString> files;
+  VectorOfStrings files;
 
   cmCTestLog(this, OUTPUT, "Submit extra files" << std::endl);
 
@@ -2594,7 +2594,7 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
 
 //----------------------------------------------------------------------
 void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
-  VectorOfStrings& vec)
+  std::vector<std::string>& vec)
 {
   const char* dval = mf->GetDefinition(def);
   if ( !dval )
@@ -2892,7 +2892,7 @@ bool cmCTest::RunCommand(
   const char* dir,
   double timeout)
 {
-  std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
+  std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
   if(args.size() < 1)
     {
@@ -2900,7 +2900,7 @@ bool cmCTest::RunCommand(
     }
 
   std::vector<const char*> argv;
-  for(std::vector<cmStdString>::const_iterator a = args.begin();
+  for(std::vector<std::string>::const_iterator a = args.begin();
       a != args.end(); ++a)
     {
     argv.push_back(a->c_str());

Source/cmCTest.h

@@ -101,8 +101,8 @@ public:
       if the string does not name a valid part.  */
   Part GetPartFromName(const char* name);
 
-  typedef std::vector<cmStdString> VectorOfStrings;
+  typedef std::vector<cmsys::String> VectorOfStrings;
-  typedef std::set<cmStdString> SetOfStrings;
+  typedef std::set<std::string> SetOfStrings;
 
   ///! Process Command line arguments
   int Run(std::vector<std::string> &, std::string* output = 0);
@@ -186,7 +186,7 @@ public:
   void SetNotesFiles(const char* notes);
 
   void PopulateCustomVector(cmMakefile* mf, const std::string& definition,
-    VectorOfStrings& vec);
+    std::vector<std::string>& vec);
   void PopulateCustomInteger(cmMakefile* mf, const std::string& def,
     int& val);
 
@@ -352,11 +352,11 @@ public:
   void AddCTestConfigurationOverwrite(const std::string& encstr);
 
   //! Create XML file that contains all the notes specified
-  int GenerateNotesFile(const std::vector<cmStdString> &files);
+  int GenerateNotesFile(const VectorOfStrings &files);
 
   //! Submit extra files to the server
   bool SubmitExtraFiles(const char* files);
-  bool SubmitExtraFiles(const std::vector<cmStdString> &files);
+  bool SubmitExtraFiles(const VectorOfStrings &files);
 
   //! Set the output log file name
   void SetOutputLogFileName(const char* name);
@@ -391,7 +391,7 @@ public:
   //! Read the custom configuration files and apply them to the current ctest
   int ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf);
 
-  std::vector<cmStdString> &GetInitialCommandLineArguments()
+  std::vector<std::string> &GetInitialCommandLineArguments()
   { return this->InitialCommandLineArguments; };
 
   //! Set the track to submit to
@@ -447,13 +447,13 @@ private:
   void DetermineNextDayStop();
 
   // these are helper classes
-  typedef std::map<cmStdString,cmCTestGenericHandler*> t_TestingHandlers;
+  typedef std::map<std::string,cmCTestGenericHandler*> t_TestingHandlers;
   t_TestingHandlers TestingHandlers;
 
   bool ShowOnly;
 
   //! Map of configuration properties
-  typedef std::map<cmStdString, cmStdString> CTestConfigurationMap;
+  typedef std::map<std::string, std::string> CTestConfigurationMap;
 
   std::string             CTestConfigFile;
   // TODO: The ctest configuration should be a hierarchy of
@@ -463,7 +463,7 @@ private:
   CTestConfigurationMap CTestConfiguration;
   CTestConfigurationMap CTestConfigurationOverwrites;
   PartInfo                Parts[PartCount];
-  typedef std::map<cmStdString, Part> PartMapType;
+  typedef std::map<std::string, Part> PartMapType;
   PartMapType             PartMap;
 
   std::string             CurrentTag;
@@ -556,7 +556,7 @@ private:
   int  DartVersion;
   bool DropSiteCDash;
 
-  std::vector<cmStdString> InitialCommandLineArguments;
+  std::vector<std::string> InitialCommandLineArguments;
 
   int SubmitIndex;
 

Source/cmCacheManager.cxx

@@ -90,7 +90,7 @@ bool cmCacheManager::LoadCache(const std::string& path)
 bool cmCacheManager::LoadCache(const std::string& path,
                                bool internal)
 {
-  std::set<cmStdString> emptySet;
+  std::set<std::string> emptySet;
   return this->LoadCache(path, internal, emptySet, emptySet);
 }
 
@@ -195,8 +195,8 @@ void cmCacheManager::CleanCMakeFiles(const std::string& path)
 
 bool cmCacheManager::LoadCache(const std::string& path,
                                bool internal,
-                               std::set<cmStdString>& excludes,
+                               std::set<std::string>& excludes,
-                               std::set<cmStdString>& includes)
+                               std::set<std::string>& includes)
 {
   std::string cacheFile = path;
   cacheFile += "/CMakeCache.txt";
@@ -500,7 +500,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
   fout << "########################\n";
   fout << "\n";
 
-  for( std::map<cmStdString, CacheEntry>::const_iterator i =
+  for( std::map<std::string, CacheEntry>::const_iterator i =
          this->Cache.begin(); i != this->Cache.end(); ++i)
     {
     const CacheEntry& ce = (*i).second;
@@ -693,7 +693,7 @@ void cmCacheManager::PrintCache(std::ostream& out) const
 {
   out << "=================================================" << std::endl;
   out << "CMakeCache Contents:" << std::endl;
-  for(std::map<cmStdString, CacheEntry>::const_iterator i =
+  for(std::map<std::string, CacheEntry>::const_iterator i =
         this->Cache.begin(); i != this->Cache.end(); ++i)
     {
     if((*i).second.Type != INTERNAL)

Source/cmCacheManager.h

@@ -72,7 +72,7 @@ public:
     void SetType(CacheEntryType ty) { this->GetEntry().Type = ty; }
     bool Initialized() { return this->GetEntry().Initialized; }
     cmCacheManager &Container;
-    std::map<cmStdString, CacheEntry>::iterator Position;
+    std::map<std::string, CacheEntry>::iterator Position;
     CacheIterator(cmCacheManager &cm) : Container(cm) {
       this->Begin();
     }
@@ -111,8 +111,8 @@ public:
   bool LoadCache(const std::string& path);
   bool LoadCache(const std::string& path, bool internal);
   bool LoadCache(const std::string& path, bool internal,
-                 std::set<cmStdString>& excludes,
+                 std::set<std::string>& excludes,
-                 std::set<cmStdString>& includes);
+                 std::set<std::string>& includes);
 
   ///! Save cache for given makefile.  Saves to ouput home CMakeCache.txt.
   bool SaveCache(cmMakefile*) ;
@@ -166,7 +166,7 @@ protected:
   unsigned int CacheMinorVersion;
 private:
   cmake* CMakeInstance;
-  typedef  std::map<cmStdString, CacheEntry> CacheEntryMap;
+  typedef  std::map<std::string, CacheEntry> CacheEntryMap;
   static void OutputHelpString(std::ostream& fout,
                                const std::string& helpString);
   static void OutputKey(std::ostream& fout, std::string const& key);

Source/cmCommandArgumentParserHelper.h

@@ -77,8 +77,8 @@ public:
   char BSLASHVariable[3];
 
 private:
-  cmStdString::size_type InputBufferPos;
+  std::string::size_type InputBufferPos;
-  cmStdString InputBuffer;
+  std::string InputBuffer;
   std::vector<char> OutputBuffer;
   int CurrentLine;
   int Verbose;

Source/cmComputeLinkDepends.cxx

@@ -279,12 +279,12 @@ cmComputeLinkDepends::Compute()
 }
 
 //----------------------------------------------------------------------------
-std::map<cmStdString, int>::iterator
+std::map<std::string, int>::iterator
 cmComputeLinkDepends::AllocateLinkEntry(std::string const& item)
 {
-  std::map<cmStdString, int>::value_type
+  std::map<std::string, int>::value_type
     index_entry(item, static_cast<int>(this->EntryList.size()));
-  std::map<cmStdString, int>::iterator
+  std::map<std::string, int>::iterator
     lei = this->LinkEntryIndex.insert(index_entry).first;
   this->EntryList.push_back(LinkEntry());
   this->InferredDependSets.push_back(0);
@@ -297,7 +297,7 @@ int cmComputeLinkDepends::AddLinkEntry(int depender_index,
                                        std::string const& item)
 {
   // Check if the item entry has already been added.
-  std::map<cmStdString, int>::iterator lei = this->LinkEntryIndex.find(item);
+  std::map<std::string, int>::iterator lei = this->LinkEntryIndex.find(item);
   if(lei != this->LinkEntryIndex.end())
     {
     // Yes.  We do not need to follow the item's dependencies again.
@@ -423,7 +423,7 @@ cmComputeLinkDepends
 void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
 {
   // Check if the target already has an entry.
-  std::map<cmStdString, int>::iterator lei =
+  std::map<std::string, int>::iterator lei =
     this->LinkEntryIndex.find(dep.Item);
   if(lei == this->LinkEntryIndex.end())
     {

Source/cmComputeLinkDepends.h

@@ -76,7 +76,7 @@ private:
 
   typedef cmTarget::LinkLibraryVectorType LinkLibraryVectorType;
 
-  std::map<cmStdString, int>::iterator
+  std::map<std::string, int>::iterator
   AllocateLinkEntry(std::string const& item);
   int AddLinkEntry(int depender_index, std::string const& item);
   void AddVarLinkEntries(int depender_index, const char* value);
@@ -88,7 +88,7 @@ private:
 
   // One entry for each unique item.
   std::vector<LinkEntry> EntryList;
-  std::map<cmStdString, int> LinkEntryIndex;
+  std::map<std::string, int> LinkEntryIndex;
 
   // BFS of initial dependencies.
   struct BFSEntry

Source/cmComputeLinkInformation.cxx

@@ -902,7 +902,7 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
   // be the library name.  Match index 3 will be the library
   // extension.
   reg = "^(";
-  for(std::set<cmStdString>::iterator p = this->LinkPrefixes.begin();
+  for(std::set<std::string>::iterator p = this->LinkPrefixes.begin();
       p != this->LinkPrefixes.end(); ++p)
     {
     reg += *p;
@@ -1640,7 +1640,7 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
 
   // List the paths old behavior is adding.
   os << "and other libraries with known full path:\n";
-  std::set<cmStdString> emitted;
+  std::set<std::string> emitted;
   for(std::vector<std::string>::const_iterator
         i = this->OldLinkDirItems.begin();
       i != this->OldLinkDirItems.end(); ++i)
@@ -1856,7 +1856,7 @@ cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath)
 //----------------------------------------------------------------------------
 static void cmCLI_ExpandListUnique(const char* str,
                                    std::vector<std::string>& out,
-                                   std::set<cmStdString>& emitted)
+                                   std::set<std::string>& emitted)
 {
   std::vector<std::string> tmp;
   cmSystemTools::ExpandListArgument(str, tmp);
@@ -1894,7 +1894,7 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
     this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH");
 
   // Construct the RPATH.
-  std::set<cmStdString> emitted;
+  std::set<std::string> emitted;
   if(use_install_rpath)
     {
     const char* install_rpath = this->Target->GetProperty("INSTALL_RPATH");

Source/cmComputeLinkInformation.h

@@ -126,7 +126,7 @@ private:
   std::vector<std::string> StaticLinkExtensions;
   std::vector<std::string> SharedLinkExtensions;
   std::vector<std::string> LinkExtensions;
-  std::set<cmStdString> LinkPrefixes;
+  std::set<std::string> LinkPrefixes;
   cmsys::RegularExpression ExtractStaticLibraryName;
   cmsys::RegularExpression ExtractSharedLibraryName;
   cmsys::RegularExpression ExtractAnyLibraryName;
@@ -153,7 +153,7 @@ private:
   // Framework info.
   void ComputeFrameworkInfo();
   void AddFrameworkPath(std::string const& p);
-  std::set<cmStdString> FrameworkPathsEmmitted;
+  std::set<std::string> FrameworkPathsEmmitted;
   cmsys::RegularExpression SplitFramework;
 
   // Linker search path computation.
@@ -165,14 +165,14 @@ private:
   void LoadImplicitLinkInfo();
   void AddImplicitLinkInfo();
   void AddImplicitLinkInfo(std::string const& lang);
-  std::set<cmStdString> ImplicitLinkDirs;
+  std::set<std::string> ImplicitLinkDirs;
-  std::set<cmStdString> ImplicitLinkLibs;
+  std::set<std::string> ImplicitLinkLibs;
 
   // Additional paths configured by the runtime linker
   std::vector<std::string> RuntimeLinkDirs;
 
   // Linker search path compatibility mode.
-  std::set<cmStdString> OldLinkDirMask;
+  std::set<std::string> OldLinkDirMask;
   std::vector<std::string> OldLinkDirItems;
   std::vector<std::string> OldUserFlagItems;
   bool OldLinkDirMode;

Source/cmComputeTargetDepends.cxx

@@ -211,7 +211,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
   // dependencies in all targets, because the generated build-systems can't
   // deal with config-specific dependencies.
   {
-  std::set<cmStdString> emitted;
+  std::set<std::string> emitted;
   {
   std::vector<std::string> tlibs;
   depender->GetDirectLinkLibraries(0, tlibs, depender);
@@ -255,11 +255,11 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
 
   // Loop over all utility dependencies.
   {
-  std::set<cmStdString> const& tutils = depender->GetUtilities();
+  std::set<std::string> const& tutils = depender->GetUtilities();
-  std::set<cmStdString> emitted;
+  std::set<std::string> emitted;
   // A target should not depend on itself.
   emitted.insert(depender->GetName());
-  for(std::set<cmStdString>::const_iterator util = tutils.begin();
+  for(std::set<std::string>::const_iterator util = tutils.begin();
       util != tutils.end(); ++util)
     {
     // Don't emit the same utility twice for this target.
@@ -275,7 +275,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
 void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
                                                  cmTarget const* dependee,
                                                  const char *config,
-                                               std::set<cmStdString> &emitted)
+                                               std::set<std::string> &emitted)
 {
   cmTarget const* depender = this->Targets[depender_index];
   if(cmTarget::LinkInterface const* iface =
@@ -300,7 +300,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
 void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
                                              const std::string& dependee_name,
                                              bool linking,
-                                             std::set<cmStdString> &emitted)
+                                             std::set<std::string> &emitted)
 {
   cmTarget const* depender = this->Targets[depender_index];
   cmTarget const* dependee =
@@ -406,8 +406,8 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
   if(dependee->IsImported())
     {
     // Skip imported targets but follow their utility dependencies.
-    std::set<cmStdString> const& utils = dependee->GetUtilities();
+    std::set<std::string> const& utils = dependee->GetUtilities();
-    for(std::set<cmStdString>::const_iterator i = utils.begin();
+    for(std::set<std::string>::const_iterator i = utils.begin();
         i != utils.end(); ++i)
       {
       if(cmTarget const* transitive_dependee =

Source/cmComputeTargetDepends.h

@@ -53,10 +53,10 @@ private:
   bool ComputeFinalDepends(cmComputeComponentGraph const& ccg);
   void AddInterfaceDepends(int depender_index,
                            const std::string& dependee_name,
-                           bool linking, std::set<cmStdString> &emitted);
+                           bool linking, std::set<std::string> &emitted);
   void AddInterfaceDepends(int depender_index, cmTarget const* dependee,
                            const char *config,
-                           std::set<cmStdString> &emitted);
+                           std::set<std::string> &emitted);
   cmGlobalGenerator* GlobalGenerator;
   bool DebugMode;
   bool NoCycles;

Source/cmCoreTryCompile.cxx

@@ -566,7 +566,7 @@ void cmCoreTryCompile::CleanupFiles(const char* binDir)
   cmsys::Directory dir;
   dir.Load(binDir);
   size_t fileNum;
-  std::set<cmStdString> deletedFiles;
+  std::set<std::string> deletedFiles;
   for (fileNum = 0; fileNum <  dir.GetNumberOfFiles(); ++fileNum)
     {
     if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") &&

Source/cmCustomCommand.h

@@ -72,7 +72,7 @@ public:
   /** Backtrace of the command that created this custom command.  */
   cmListFileBacktrace const& GetBacktrace() const;
 
-  typedef std::pair<cmStdString, cmStdString> ImplicitDependsPair;
+  typedef std::pair<std::string, std::string> ImplicitDependsPair;
   class ImplicitDependsList: public std::vector<ImplicitDependsPair> {};
   void SetImplicitDepends(ImplicitDependsList const&);
   void AppendImplicitDepends(ImplicitDependsList const&);

Source/cmDefinitions.cxx

@@ -85,9 +85,9 @@ const char* cmDefinitions::Set(const std::string& key, const char* value)
 }
 
 //----------------------------------------------------------------------------
-std::set<cmStdString> cmDefinitions::LocalKeys() const
+std::set<std::string> cmDefinitions::LocalKeys() const
 {
-  std::set<cmStdString> keys;
+  std::set<std::string> keys;
   // Consider local definitions.
   for(MapType::const_iterator mi = this->Map.begin();
       mi != this->Map.end(); ++mi)
@@ -110,12 +110,12 @@ cmDefinitions cmDefinitions::Closure() const
 cmDefinitions::cmDefinitions(ClosureTag const&, cmDefinitions const* root):
   Up(0)
 {
-  std::set<cmStdString> undefined;
+  std::set<std::string> undefined;
   this->ClosureImpl(undefined, root);
 }
 
 //----------------------------------------------------------------------------
-void cmDefinitions::ClosureImpl(std::set<cmStdString>& undefined,
+void cmDefinitions::ClosureImpl(std::set<std::string>& undefined,
                                 cmDefinitions const* defs)
 {
   // Consider local definitions.
@@ -145,17 +145,17 @@ void cmDefinitions::ClosureImpl(std::set<cmStdString>& undefined,
 }
 
 //----------------------------------------------------------------------------
-std::set<cmStdString> cmDefinitions::ClosureKeys() const
+std::set<std::string> cmDefinitions::ClosureKeys() const
 {
-  std::set<cmStdString> defined;
+  std::set<std::string> defined;
-  std::set<cmStdString> undefined;
+  std::set<std::string> undefined;
   this->ClosureKeys(defined, undefined);
   return defined;
 }
 
 //----------------------------------------------------------------------------
-void cmDefinitions::ClosureKeys(std::set<cmStdString>& defined,
+void cmDefinitions::ClosureKeys(std::set<std::string>& defined,
-                                std::set<cmStdString>& undefined) const
+                                std::set<std::string>& undefined) const
 {
   // Consider local definitions.
   for(MapType::const_iterator mi = this->Map.begin();
@@ -165,7 +165,7 @@ void cmDefinitions::ClosureKeys(std::set<cmStdString>& defined,
     if(defined.find(mi->first) == defined.end() &&
        undefined.find(mi->first) == undefined.end())
       {
-      std::set<cmStdString>& m = mi->second.Exists? defined : undefined;
+      std::set<std::string>& m = mi->second.Exists? defined : undefined;
       m.insert(mi->first);
       }
     }

Source/cmDefinitions.h

@@ -41,22 +41,25 @@ public:
   const char* Set(const std::string& key, const char* value);
 
   /** Get the set of all local keys.  */
-  std::set<cmStdString> LocalKeys() const;
+  std::set<std::string> LocalKeys() const;
 
   /** Compute the closure of all defined keys with values.
       This flattens the scope.  The result has no parent.  */
   cmDefinitions Closure() const;
 
   /** Compute the set of all defined keys.  */
-  std::set<cmStdString> ClosureKeys() const;
+  std::set<std::string> ClosureKeys() const;
 
 private:
   // String with existence boolean.
-  struct Def: public cmStdString
+  struct Def: public std::string
   {
-    Def(): cmStdString(), Exists(false) {}
+  private:
-    Def(const char* v): cmStdString(v?v:""), Exists(v?true:false) {}
+    typedef std::string std_string;
-    Def(Def const& d): cmStdString(d), Exists(d.Exists) {}
+  public:
+    Def(): std_string(), Exists(false) {}
+    Def(const char* v): std_string(v?v:""), Exists(v?true:false) {}
+    Def(Def const& d): std_string(d), Exists(d.Exists) {}
     bool Exists;
   };
   static Def NoDef;
@@ -65,7 +68,7 @@ private:
   cmDefinitions* Up;
 
   // Local definitions, set or unset.
-  typedef std::map<cmStdString, Def> MapType;
+  typedef std::map<std::string, Def> MapType;
   MapType Map;
 
   // Internal query and update methods.
@@ -75,12 +78,12 @@ private:
   // Implementation of Closure() method.
   struct ClosureTag {};
   cmDefinitions(ClosureTag const&, cmDefinitions const* root);
-  void ClosureImpl(std::set<cmStdString>& undefined,
+  void ClosureImpl(std::set<std::string>& undefined,
                    cmDefinitions const* defs);
 
   // Implementation of ClosureKeys() method.
-  void ClosureKeys(std::set<cmStdString>& defined,
+  void ClosureKeys(std::set<std::string>& defined,
-                   std::set<cmStdString>& undefined) const;
+                   std::set<std::string>& undefined) const;
 };
 
 #endif

Source/cmDependsC.cxx

@@ -91,7 +91,7 @@ cmDependsC::~cmDependsC()
 {
   this->WriteCacheFile();
 
-  for (std::map<cmStdString, cmIncludeLines*>::iterator it=
+  for (std::map<std::string, cmIncludeLines*>::iterator it=
          this->FileCache.begin(); it!=this->FileCache.end(); ++it)
     {
     delete it->second;
@@ -116,7 +116,7 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
     return false;
     }
 
-  std::set<cmStdString> dependencies;
+  std::set<std::string> dependencies;
   bool haveDeps = false;
 
   if (this->ValidDeps != 0)
@@ -149,7 +149,7 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
       this->Encountered.insert(*srcIt);
       }
 
-    std::set<cmStdString> scanned;
+    std::set<std::string> scanned;
 
     // Use reserve to allocate enough memory for tempPathStr
     // so that during the loops no memory is allocated or freed
@@ -182,7 +182,7 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
         }
       else
         {
-        std::map<cmStdString, cmStdString>::iterator
+        std::map<std::string, std::string>::iterator
           headerLocationIt=this->HeaderLocationCache.find(current.FileName);
         if (headerLocationIt!=this->HeaderLocationCache.end())
           {
@@ -224,7 +224,7 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
         scanned.insert(fullName);
 
         // Check whether this file is already in the cache
-        std::map<cmStdString, cmIncludeLines*>::iterator fileIt=
+        std::map<std::string, cmIncludeLines*>::iterator fileIt=
           this->FileCache.find(fullName);
         if (fileIt!=this->FileCache.end())
           {
@@ -270,7 +270,7 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
   // convert the dependencies to paths relative to the home output
   // directory.  We must do the same here.
   internalDepends << obj << std::endl;
-  for(std::set<cmStdString>::const_iterator i=dependencies.begin();
+  for(std::set<std::string>::const_iterator i=dependencies.begin();
       i != dependencies.end(); ++i)
     {
     makeDepends << obj << ": " <<
@@ -392,7 +392,7 @@ void cmDependsC::WriteCacheFile() const
   cacheOut << this->IncludeRegexComplainString << "\n\n";
   cacheOut << this->IncludeRegexTransformString << "\n\n";
 
-  for (std::map<cmStdString, cmIncludeLines*>::const_iterator fileIt=
+  for (std::map<std::string, cmIncludeLines*>::const_iterator fileIt=
          this->FileCache.begin();
        fileIt!=this->FileCache.end(); ++fileIt)
     {
@@ -421,7 +421,7 @@ void cmDependsC::WriteCacheFile() const
 
 //----------------------------------------------------------------------------
 void cmDependsC::Scan(std::istream& is, const char* directory,
-  const cmStdString& fullName)
+  const std::string& fullName)
 {
   cmIncludeLines* newCacheEntry=new cmIncludeLines;
   newCacheEntry->Used=true;

Source/cmDependsC.h

@@ -41,7 +41,7 @@ protected:
 
   // Method to scan a single file.
   void Scan(std::istream& is, const char* directory,
-    const cmStdString& fullName);
+    const std::string& fullName);
 
   // Regular expression to identify C preprocessor include directives.
   cmsys::RegularExpression IncludeRegexLine;
@@ -57,7 +57,7 @@ protected:
   // Regex to transform #include lines.
   std::string IncludeRegexTransformString;
   cmsys::RegularExpression IncludeRegexTransform;
-  typedef std::map<cmStdString, cmStdString> TransformRulesType;
+  typedef std::map<std::string, std::string> TransformRulesType;
   TransformRulesType TransformRules;
   void SetupTransforms();
   void ParseTransform(std::string const& xform);
@@ -67,8 +67,8 @@ public:
   // Data structures for dependency graph walk.
   struct UnscannedEntry
   {
-    cmStdString FileName;
+    std::string FileName;
-    cmStdString QuotedLocation;
+    std::string QuotedLocation;
   };
 
   struct cmIncludeLines
@@ -79,13 +79,13 @@ public:
   };
 protected:
   const std::map<std::string, DependencyVector>* ValidDeps;
-  std::set<cmStdString> Encountered;
+  std::set<std::string> Encountered;
   std::queue<UnscannedEntry> Unscanned;
 
-  std::map<cmStdString, cmIncludeLines *> FileCache;
+  std::map<std::string, cmIncludeLines *> FileCache;
-  std::map<cmStdString, cmStdString> HeaderLocationCache;
+  std::map<std::string, std::string> HeaderLocationCache;
 
-  cmStdString CacheFileName;
+  std::string CacheFileName;
 
   void WriteCacheFile() const;
   void ReadCacheFile();

Source/cmDependsFortran.cxx

@@ -34,11 +34,11 @@ public:
   std::string Source;
 
   // Set of provided and required modules.
-  std::set<cmStdString> Provides;
+  std::set<std::string> Provides;
-  std::set<cmStdString> Requires;
+  std::set<std::string> Requires;
 
   // Set of files included in the translation unit.
-  std::set<cmStdString> Includes;
+  std::set<std::string> Includes;
 };
 
 //----------------------------------------------------------------------------
@@ -98,24 +98,24 @@ class cmDependsFortranInternals
 {
 public:
   // The set of modules provided by this target.
-  std::set<cmStdString> TargetProvides;
+  std::set<std::string> TargetProvides;
 
   // Map modules required by this target to locations.
-  typedef std::map<cmStdString, cmStdString> TargetRequiresMap;
+  typedef std::map<std::string, std::string> TargetRequiresMap;
   TargetRequiresMap TargetRequires;
 
   // Information about each object file.
-  typedef std::map<cmStdString, cmDependsFortranSourceInfo> ObjectInfoMap;
+  typedef std::map<std::string, cmDependsFortranSourceInfo> ObjectInfoMap;
   ObjectInfoMap ObjectInfo;
 
   cmDependsFortranSourceInfo& CreateObjectInfo(const char* obj,
                                                const char* src)
     {
-    std::map<cmStdString, cmDependsFortranSourceInfo>::iterator i =
+    std::map<std::string, cmDependsFortranSourceInfo>::iterator i =
       this->ObjectInfo.find(obj);
     if(i == this->ObjectInfo.end())
       {
-      std::map<cmStdString, cmDependsFortranSourceInfo>::value_type
+      std::map<std::string, cmDependsFortranSourceInfo>::value_type
         entry(obj, cmDependsFortranSourceInfo());
       i = this->ObjectInfo.insert(entry).first;
       i->second.Source = src;
@@ -260,8 +260,8 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
   cmGeneratedFileStream fiStream(fiName.c_str());
   fiStream << "# The fortran modules provided by this target.\n";
   fiStream << "provides\n";
-  std::set<cmStdString> const& provides = this->Internal->TargetProvides;
+  std::set<std::string> const& provides = this->Internal->TargetProvides;
-  for(std::set<cmStdString>::const_iterator i = provides.begin();
+  for(std::set<std::string>::const_iterator i = provides.begin();
       i != provides.end(); ++i)
     {
     fiStream << " " << *i << "\n";
@@ -275,7 +275,7 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
     cmGeneratedFileStream fcStream(fcName.c_str());
     fcStream << "# Remove fortran modules provided by this target.\n";
     fcStream << "FILE(REMOVE";
-    for(std::set<cmStdString>::const_iterator i = provides.begin();
+    for(std::set<std::string>::const_iterator i = provides.begin();
         i != provides.end(); ++i)
       {
       std::string mod_upper = mod_dir;
@@ -319,14 +319,14 @@ void cmDependsFortran::LocateModules()
       infoI != objInfo.end(); ++infoI)
     {
     cmDependsFortranSourceInfo const& info = infoI->second;
-    for(std::set<cmStdString>::const_iterator i = info.Provides.begin();
+    for(std::set<std::string>::const_iterator i = info.Provides.begin();
         i != info.Provides.end(); ++i)
       {
       // Include this module in the set provided by this target.
       this->Internal->TargetProvides.insert(*i);
       }
 
-    for(std::set<cmStdString>::const_iterator i = info.Requires.begin();
+    for(std::set<std::string>::const_iterator i = info.Requires.begin();
         i != info.Requires.end(); ++i)
       {
       // Include this module in the set required by this target.
@@ -368,8 +368,8 @@ void cmDependsFortran::LocateModules()
 void cmDependsFortran::MatchLocalModules()
 {
   const char* stampDir = this->TargetDirectory.c_str();
-  std::set<cmStdString> const& provides = this->Internal->TargetProvides;
+  std::set<std::string> const& provides = this->Internal->TargetProvides;
-  for(std::set<cmStdString>::const_iterator i = provides.begin();
+  for(std::set<std::string>::const_iterator i = provides.begin();
       i != provides.end(); ++i)
     {
     this->ConsiderModule(i->c_str(), stampDir);
@@ -445,7 +445,7 @@ cmDependsFortran
   // Write the include dependencies to the output stream.
   internalDepends << obj << std::endl;
   internalDepends << " " << src << std::endl;
-  for(std::set<cmStdString>::const_iterator i = info.Includes.begin();
+  for(std::set<std::string>::const_iterator i = info.Includes.begin();
       i != info.Includes.end(); ++i)
     {
     makeDepends << obj << ": " <<
@@ -458,11 +458,11 @@ cmDependsFortran
   makeDepends << std::endl;
 
   // Write module requirements to the output stream.
-  for(std::set<cmStdString>::const_iterator i = info.Requires.begin();
+  for(std::set<std::string>::const_iterator i = info.Requires.begin();
       i != info.Requires.end(); ++i)
     {
     // Require only modules not provided in the same source.
-    if(std::set<cmStdString>::const_iterator(info.Provides.find(*i)) !=
+    if(std::set<std::string>::const_iterator(info.Provides.find(*i)) !=
        info.Provides.end())
       {
       continue;
@@ -519,7 +519,7 @@ cmDependsFortran
     }
 
   // Write provided modules to the output stream.
-  for(std::set<cmStdString>::const_iterator i = info.Provides.begin();
+  for(std::set<std::string>::const_iterator i = info.Provides.begin();
       i != info.Provides.end(); ++i)
     {
     std::string proxy = stamp_dir;
@@ -538,7 +538,7 @@ cmDependsFortran
     // Create a target to copy the module after the object file
     // changes.
     makeDepends << obj << ".provides.build:\n";
-    for(std::set<cmStdString>::const_iterator i = info.Provides.begin();
+    for(std::set<std::string>::const_iterator i = info.Provides.begin();
         i != info.Provides.end(); ++i)
       {
       // Include this module in the set provided by this target.

Source/cmDependsJavaParserHelper.cxx

@@ -36,10 +36,10 @@ cmDependsJavaParserHelper::~cmDependsJavaParserHelper()
 }
 
 void cmDependsJavaParserHelper::CurrentClass
-::AddFileNamesForPrinting(std::vector<cmStdString> *files,
+::AddFileNamesForPrinting(std::vector<std::string> *files,
                           const char* prefix, const char* sep)
 {
-  cmStdString rname = "";
+  std::string rname = "";
   if ( prefix )
     {
     rname += prefix;
@@ -76,7 +76,7 @@ void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
     {
     return;
     }
-  std::vector<cmStdString>::iterator it;
+  std::vector<std::string>::iterator it;
   for ( it = this->ClassesFound.begin();
     it != this->ClassesFound.end();
     it ++ )
@@ -91,7 +91,7 @@ void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
 
 void cmDependsJavaParserHelper::AddPackagesImport(const char* sclass)
 {
-  std::vector<cmStdString>::iterator it;
+  std::vector<std::string>::iterator it;
   for ( it = this->PackagesImport.begin();
     it != this->PackagesImport.end();
     it ++ )
@@ -256,8 +256,8 @@ void cmDependsJavaParserHelper::PrintClasses()
     std::cerr << "Error when parsing. No classes on class stack" << std::endl;
     abort();
     }
-  std::vector<cmStdString> files = this->GetFilesProduced();
+  std::vector<std::string> files = this->GetFilesProduced();
-  std::vector<cmStdString>::iterator sit;
+  std::vector<std::string>::iterator sit;
   for ( sit = files.begin();
     sit != files.end();
     ++ sit )
@@ -266,9 +266,9 @@ void cmDependsJavaParserHelper::PrintClasses()
     }
 }
 
-std::vector<cmStdString> cmDependsJavaParserHelper::GetFilesProduced()
+std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced()
 {
-  std::vector<cmStdString> files;
+  std::vector<std::string> files;
   CurrentClass* toplevel = &(*(this->ClassStack.begin()));
   std::vector<CurrentClass>::iterator it;
   for ( it = toplevel->NestedClasses->begin();
@@ -313,7 +313,7 @@ int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
     std::cout << "Imports packages:";
     if ( this->PackagesImport.size() > 0 )
       {
-      std::vector<cmStdString>::iterator it;
+      std::vector<std::string>::iterator it;
       for ( it = this->PackagesImport.begin();
         it != this->PackagesImport.end();
         ++ it )
@@ -325,7 +325,7 @@ int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
     std::cout << "Depends on:";
     if ( this->ClassesFound.size() > 0 )
       {
-      std::vector<cmStdString>::iterator it;
+      std::vector<std::string>::iterator it;
       for ( it = this->ClassesFound.begin();
         it != this->ClassesFound.end();
         ++ it )
@@ -419,8 +419,8 @@ int cmDependsJavaParserHelper::ParseFile(const char* file)
     return 0;
     }
 
-  cmStdString fullfile = "";
+  std::string fullfile = "";
-  cmStdString line;
+  std::string line;
   while ( cmSystemTools::GetLineFromStream(ifs, line) )
     {
     fullfile += line + "\n";

Source/cmDependsJavaParserHelper.h

@@ -59,15 +59,15 @@ public:
   const char* GetCurrentCombine() { return this->CurrentCombine.c_str(); }
   void UpdateCombine(const char* str1, const char* str2);
 
-  std::vector<cmStdString>& GetClassesFound() { return this->ClassesFound; }
+  std::vector<std::string>& GetClassesFound() { return this->ClassesFound; }
 
-  std::vector<cmStdString> GetFilesProduced();
+  std::vector<std::string> GetFilesProduced();
 
 private:
   class CurrentClass
   {
   public:
-    cmStdString Name;
+    std::string Name;
     std::vector<CurrentClass>* NestedClasses;
     CurrentClass()
       {
@@ -93,16 +93,16 @@ private:
       {
         (*this) = c;
       }
-    void AddFileNamesForPrinting(std::vector<cmStdString> *files,
+    void AddFileNamesForPrinting(std::vector<std::string> *files,
                                  const char* prefix, const char* sep);
   };
-  cmStdString CurrentPackage;
+  std::string CurrentPackage;
-  cmStdString::size_type InputBufferPos;
+  std::string::size_type InputBufferPos;
-  cmStdString InputBuffer;
+  std::string InputBuffer;
   std::vector<char> OutputBuffer;
-  std::vector<cmStdString> ClassesFound;
+  std::vector<std::string> ClassesFound;
-  std::vector<cmStdString> PackagesImport;
+  std::vector<std::string> PackagesImport;
-  cmStdString CurrentCombine;
+  std::string CurrentCombine;
 
   std::vector<CurrentClass> ClassStack;
 

Source/cmDynamicLoader.cxx

@@ -23,7 +23,7 @@ public:
   static cmDynamicLoaderCache* GetInstance();
 
 private:
-  std::map<cmStdString, cmsys::DynamicLoader::LibraryHandle> CacheMap;
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle> CacheMap;
   static cmDynamicLoaderCache* Instance;
 };
 
@@ -47,7 +47,7 @@ void cmDynamicLoaderCache::CacheFile(const char* path,
 bool cmDynamicLoaderCache::GetCacheFile(const char* path,
   cmsys::DynamicLoader::LibraryHandle& p)
 {
-  std::map<cmStdString, cmsys::DynamicLoader::LibraryHandle>::iterator it
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it
     = this->CacheMap.find(path);
   if ( it != this->CacheMap.end() )
     {
@@ -59,7 +59,7 @@ bool cmDynamicLoaderCache::GetCacheFile(const char* path,
 
 bool cmDynamicLoaderCache::FlushCache(const char* path)
 {
-  std::map<cmStdString, cmsys::DynamicLoader::LibraryHandle>::iterator it
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it
     = this->CacheMap.find(path);
   bool ret = false;
   if ( it != this->CacheMap.end() )
@@ -73,7 +73,7 @@ bool cmDynamicLoaderCache::FlushCache(const char* path)
 
 void cmDynamicLoaderCache::FlushCache()
 {
-  for ( std::map<cmStdString,
+  for ( std::map<std::string,
     cmsys::DynamicLoader::LibraryHandle>::iterator it
     = this->CacheMap.begin();
         it != this->CacheMap.end(); it++ )

Source/cmExportFileGenerator.h

@@ -63,7 +63,7 @@ public:
   bool GenerateImportFile();
 protected:
 
-  typedef std::map<cmStdString, cmStdString> ImportPropertyMap;
+  typedef std::map<std::string, std::string> ImportPropertyMap;
 
   // Generate per-configuration target information to the given output
   // stream.

Source/cmExportInstallFileGenerator.h

@@ -41,7 +41,7 @@ public:
   /** Get the per-config file generated for each configuraiton.  This
       maps from the configuration name to the file temporary location
       for installation.  */
-  std::map<cmStdString, cmStdString> const& GetConfigImportFiles()
+  std::map<std::string, std::string> const& GetConfigImportFiles()
     { return this->ConfigImportFiles; }
 
   /** Compute the globbing expression used to load per-config import
@@ -92,7 +92,7 @@ protected:
   std::string ImportPrefix;
 
   // The import file generated for each configuration.
-  std::map<cmStdString, cmStdString> ConfigImportFiles;
+  std::map<std::string, std::string> ConfigImportFiles;
 };
 
 #endif

Source/cmExportLibraryDependenciesCommand.cxx

@@ -83,9 +83,9 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
   cmake* cm = this->Makefile->GetCMakeInstance();
   cmGlobalGenerator* global = cm->GetGlobalGenerator();
   const std::vector<cmLocalGenerator *>& locals = global->GetLocalGenerators();
-  std::map<cmStdString, cmStdString> libDepsOld;
+  std::map<std::string, std::string> libDepsOld;
-  std::map<cmStdString, cmStdString> libDepsNew;
+  std::map<std::string, std::string> libDepsNew;
-  std::map<cmStdString, cmStdString> libTypes;
+  std::map<std::string, std::string> libTypes;
   for(std::vector<cmLocalGenerator *>::const_iterator i = locals.begin();
       i != locals.end(); ++i)
     {
@@ -175,7 +175,7 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
   fout << "# Generated by CMake " <<  cmVersion::GetCMakeVersion() << "\n\n";
   fout << "if(" << vertest << ")\n";
   fout << "  # Information for CMake 2.6 and above.\n";
-  for(std::map<cmStdString, cmStdString>::const_iterator
+  for(std::map<std::string, std::string>::const_iterator
         i = libDepsNew.begin();
       i != libDepsNew.end(); ++i)
     {
@@ -186,7 +186,7 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
     }
   fout << "else()\n";
   fout << "  # Information for CMake 2.4 and lower.\n";
-  for(std::map<cmStdString, cmStdString>::const_iterator
+  for(std::map<std::string, std::string>::const_iterator
         i = libDepsOld.begin();
       i != libDepsOld.end(); ++i)
     {
@@ -195,7 +195,7 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
       fout << "  set(\"" << i->first << "\" \"" << i->second << "\")\n";
       }
     }
-  for(std::map<cmStdString, cmStdString>::const_iterator i = libTypes.begin();
+  for(std::map<std::string, std::string>::const_iterator i = libTypes.begin();
       i != libTypes.end(); ++i)
     {
     if(i->second != "general")

Source/cmExprParserHelper.h

@@ -49,8 +49,8 @@ public:
   const char* GetError() { return this->ErrorString.c_str(); }
 
 private:
-  cmStdString::size_type InputBufferPos;
+  std::string::size_type InputBufferPos;
-  cmStdString InputBuffer;
+  std::string InputBuffer;
   std::vector<char> OutputBuffer;
   int CurrentLine;
   int Verbose;

Source/cmExtraCodeBlocksGenerator.cxx

@@ -61,7 +61,7 @@ cmExtraCodeBlocksGenerator::cmExtraCodeBlocksGenerator()
 void cmExtraCodeBlocksGenerator::Generate()
 {
   // for each sub project in the project create a codeblocks project
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
        it = this->GlobalGenerator->GetProjectMap().begin();
       it!= this->GlobalGenerator->GetProjectMap().end();
       ++it)
@@ -243,7 +243,7 @@ void cmExtraCodeBlocksGenerator
   Tree tree;
 
   // build tree of virtual folders
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
           it = this->GlobalGenerator->GetProjectMap().begin();
          it != this->GlobalGenerator->GetProjectMap().end();
          ++it)

Source/cmExtraCodeLiteGenerator.cxx

@@ -60,7 +60,7 @@ void cmExtraCodeLiteGenerator::Generate()
 
   // loop projects and locate the root project.
   // and extract the information for creating the worspace
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
        it = this->GlobalGenerator->GetProjectMap().begin();
        it!= this->GlobalGenerator->GetProjectMap().end();
        ++it)
@@ -85,7 +85,7 @@ void cmExtraCodeLiteGenerator::Generate()
     }
 
   // for each sub project in the workspace create a codelite project
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
        it = this->GlobalGenerator->GetProjectMap().begin();
        it!= this->GlobalGenerator->GetProjectMap().end();
        ++it)

Source/cmExtraEclipseCDT4Generator.cxx

@@ -624,7 +624,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
   this->AppendLinkedResource(fout, "[Subprojects]",
                              "virtual:/virtual", VirtualFolder);
 
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
        it = this->GlobalGenerator->GetProjectMap().begin();
        it != this->GlobalGenerator->GetProjectMap().end();
        ++it)

Source/cmExtraSublimeTextGenerator.cxx

@@ -64,7 +64,7 @@ cmExtraSublimeTextGenerator::cmExtraSublimeTextGenerator()
 void cmExtraSublimeTextGenerator::Generate()
 {
   // for each sub project in the project create a sublime text 2 project
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
        it = this->GlobalGenerator->GetProjectMap().begin();
       it!= this->GlobalGenerator->GetProjectMap().end();
       ++it)

Source/cmFileTimeComparison.cxx

@@ -43,13 +43,13 @@ private:
   class HashString
     {
   public:
-    size_t operator()(const cmStdString& s) const
+    size_t operator()(const std::string& s) const
       {
       return h(s.c_str());
       }
     cmsys::hash<const char*> h;
     };
-  typedef cmsys::hash_map<cmStdString,
+  typedef cmsys::hash_map<std::string,
                           cmFileTimeComparison_Type, HashString> FileStatsMap;
   FileStatsMap Files;
 #endif

Source/cmFindBase.h

@@ -42,14 +42,14 @@ protected:
   bool CheckForVariableInCache();
 
   // use by command during find
-  cmStdString VariableDocumentation;
+  std::string VariableDocumentation;
-  cmStdString VariableName;
+  std::string VariableName;
   std::vector<std::string> Names;
   bool NamesPerDir;
   bool NamesPerDirAllowed;
 
   // CMAKE_*_PATH CMAKE_SYSTEM_*_PATH FRAMEWORK|LIBRARY|INCLUDE|PROGRAM
-  cmStdString EnvironmentPath; // LIB,INCLUDE
+  std::string EnvironmentPath; // LIB,INCLUDE
 
   bool AlreadyInCache;
   bool AlreadyInCacheWithoutMetaInfo;

Source/cmFindCommon.h

@@ -56,7 +56,7 @@ protected:
   /** Compute the current default bundle/framework search policy.  */
   void SelectDefaultMacMode();
 
-  cmStdString CMakePathName;
+  std::string CMakePathName;
   RootPathMode FindRootPathMode;
 
   bool CheckCommonArgument(std::string const& arg);
@@ -81,7 +81,7 @@ protected:
   std::vector<std::string> UserPaths;
   std::vector<std::string> UserHints;
   std::vector<std::string> SearchPaths;
-  std::set<cmStdString> SearchPathsEmitted;
+  std::set<std::string> SearchPathsEmitted;
 
   bool SearchFrameworkFirst;
   bool SearchFrameworkOnly;

Source/cmFindLibraryCommand.cxx

@@ -368,8 +368,8 @@ bool cmFindLibraryHelper::CheckDirectoryForName(std::string const& path,
   // Search for a file matching the library name regex.
   std::string dir = path;
   cmSystemTools::ConvertToUnixSlashes(dir);
-  std::set<cmStdString> const& files = this->GG->GetDirectoryContent(dir);
+  std::set<std::string> const& files = this->GG->GetDirectoryContent(dir);
-  for(std::set<cmStdString>::const_iterator fi = files.begin();
+  for(std::set<std::string>::const_iterator fi = files.begin();
       fi != files.end(); ++fi)
     {
     std::string const& origName = *fi;

Source/cmFindPackageCommand.cxx

@@ -553,7 +553,7 @@ void cmFindPackageCommand::AddFindDefinition(const std::string& var,
 //----------------------------------------------------------------------------
 void cmFindPackageCommand::RestoreFindDefinitions()
 {
-  for(std::map<cmStdString, OriginalDef>::iterator
+  for(std::map<std::string, OriginalDef>::iterator
         i = this->OriginalDefs.begin(); i != this->OriginalDefs.end(); ++i)
     {
     OriginalDef const& od = i->second;

Source/cmFindPackageCommand.h

@@ -96,19 +96,19 @@ private:
   friend class cmFindPackageFileList;
 
   struct OriginalDef { bool exists; std::string value; };
-  std::map<cmStdString, OriginalDef> OriginalDefs;
+  std::map<std::string, OriginalDef> OriginalDefs;
 
-  cmStdString Name;
+  std::string Name;
-  cmStdString Variable;
+  std::string Variable;
-  cmStdString Version;
+  std::string Version;
   unsigned int VersionMajor;
   unsigned int VersionMinor;
   unsigned int VersionPatch;
   unsigned int VersionTweak;
   unsigned int VersionCount;
   bool VersionExact;
-  cmStdString FileFound;
+  std::string FileFound;
-  cmStdString VersionFound;
+  std::string VersionFound;
   unsigned int VersionFoundMajor;
   unsigned int VersionFoundMinor;
   unsigned int VersionFoundPatch;

Source/cmFindPathCommand.cxx

@@ -89,9 +89,9 @@ std::string
 cmFindPathCommand::FindHeaderInFramework(std::string const& file,
                                          std::string const& dir)
 {
-  cmStdString fileName = file;
+  std::string fileName = file;
-  cmStdString frameWorkName;
+  std::string frameWorkName;
-  cmStdString::size_type pos = fileName.find("/");
+  std::string::size_type pos = fileName.find("/");
   // if there is a / in the name try to find the header as a framework
   // For example bar/foo.h would look for:
   // bar.framework/Headers/foo.h
@@ -128,7 +128,7 @@ cmFindPathCommand::FindHeaderInFramework(std::string const& file,
     }
   // if it is not found yet or not a framework header, then do a glob search
   // for all frameworks in the directory: dir/*.framework/Headers/<file>
-  cmStdString glob = dir;
+  std::string glob = dir;
   glob += "*.framework/Headers/";
   glob += file;
   cmsys::Glob globIt;
@@ -136,7 +136,7 @@ cmFindPathCommand::FindHeaderInFramework(std::string const& file,
   std::vector<std::string> files = globIt.GetFiles();
   if(files.size())
     {
-    cmStdString fheader = cmSystemTools::CollapseFullPath(files[0].c_str());
+    std::string fheader = cmSystemTools::CollapseFullPath(files[0].c_str());
     if(this->IncludeFileInPath)
       {
       return fheader;

Source/cmGeneratorExpression.cxx

@@ -97,7 +97,7 @@ const char *cmCompiledGeneratorExpression::Evaluate(
     {
     this->Output += (*it)->Evaluate(&context, dagChecker);
 
-    for(std::set<cmStdString>::const_iterator
+    for(std::set<std::string>::const_iterator
           p = context.SeenTargetProperties.begin();
           p != context.SeenTargetProperties.end(); ++p)
       {

Source/cmGeneratorExpression.h

@@ -92,7 +92,7 @@ public:
   std::set<cmTarget*> const& GetTargets() const
     { return this->DependTargets; }
 
-  std::set<cmStdString> const& GetSeenTargetProperties() const
+  std::set<std::string> const& GetSeenTargetProperties() const
     { return this->SeenTargetProperties; }
 
   std::set<cmTarget const*> const& GetAllTargetsSeen() const
@@ -130,7 +130,7 @@ private:
 
   mutable std::set<cmTarget*> DependTargets;
   mutable std::set<cmTarget const*> AllTargetsSeen;
-  mutable std::set<cmStdString> SeenTargetProperties;
+  mutable std::set<std::string> SeenTargetProperties;
   mutable std::string Output;
   mutable bool HadContextSensitiveCondition;
 };

Source/cmGeneratorExpressionDAGChecker.cxx

@@ -42,12 +42,12 @@ cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
      )
 #undef TEST_TRANSITIVE_PROPERTY_METHOD
     {
-    std::map<cmStdString, std::set<cmStdString> >::const_iterator it
+    std::map<std::string, std::set<std::string> >::const_iterator it
                                                     = top->Seen.find(target);
     if (it != top->Seen.end())
       {
-      const std::set<cmStdString> &propSet = it->second;
+      const std::set<std::string> &propSet = it->second;
-      const std::set<cmStdString>::const_iterator i = propSet.find(property);
+      const std::set<std::string>::const_iterator i = propSet.find(property);
       if (i != propSet.end())
         {
         this->CheckResult = ALREADY_SEEN;

Source/cmGeneratorExpressionDAGChecker.h

@@ -77,7 +77,7 @@ private:
   const cmGeneratorExpressionDAGChecker * const Parent;
   const std::string Target;
   const std::string Property;
-  std::map<cmStdString, std::set<cmStdString> > Seen;
+  std::map<std::string, std::set<std::string> > Seen;
   const GeneratorExpressionContent * const Content;
   const cmListFileBacktrace Backtrace;
   Result CheckResult;

Source/cmGeneratorExpressionEvaluator.h

@@ -25,7 +25,7 @@ struct cmGeneratorExpressionContext
   cmListFileBacktrace Backtrace;
   std::set<cmTarget*> DependTargets;
   std::set<cmTarget const*> AllTargets;
-  std::set<cmStdString> SeenTargetProperties;
+  std::set<std::string> SeenTargetProperties;
   cmMakefile *Makefile;
   const char *Config;
   cmTarget const* HeadTarget; // The target whose property is being evaluated.

Source/cmGeneratorTarget.cxx

@@ -422,7 +422,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const char *dir,
                 = this->Target->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED");
 
     std::vector<std::string> result;
-    for (std::set<cmStdString>::const_iterator
+    for (std::set<std::string>::const_iterator
         it = this->Target->GetSystemIncludeDirectories().begin();
         it != this->Target->GetSystemIncludeDirectories().end(); ++it)
       {
@@ -462,7 +462,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const char *dir,
           }
         }
       }
-    std::set<cmStdString> unique;
+    std::set<std::string> unique;
     for(std::vector<std::string>::iterator li = result.begin();
         li != result.end(); ++li)
       {
@@ -470,7 +470,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const char *dir,
       unique.insert(*li);
       }
     result.clear();
-    for(std::set<cmStdString>::iterator li = unique.begin();
+    for(std::set<std::string>::iterator li = unique.begin();
         li != unique.end(); ++li)
       {
       result.push_back(*li);
@@ -594,7 +594,7 @@ private:
   SourceEntry* CurrentEntry;
   std::queue<cmSourceFile*> SourceQueue;
   std::set<cmSourceFile*> SourcesQueued;
-  typedef std::map<cmStdString, cmSourceFile*> NameMapType;
+  typedef std::map<std::string, cmSourceFile*> NameMapType;
   NameMapType NameMap;
 
   void QueueSource(cmSourceFile* sf);

Source/cmGetCMakePropertyCommand.cxx

@@ -49,10 +49,10 @@ bool cmGetCMakePropertyCommand
     }
   else if ( args[1] == "COMPONENTS" )
     {
-    const std::set<cmStdString>* components
+    const std::set<std::string>* components
       = this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
         ->GetInstallComponents();
-    std::set<cmStdString>::const_iterator compIt;
+    std::set<std::string>::const_iterator compIt;
     output = "";
     for (compIt = components->begin(); compIt != components->end(); ++compIt)
       {

Source/cmGlobalGenerator.cxx

@@ -432,8 +432,8 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     fpath += "/CMakeSystem.cmake";
     mf->ReadListFile(0,fpath.c_str());
     }
-  std::map<cmStdString, bool> needTestLanguage;
+  std::map<std::string, bool> needTestLanguage;
-  std::map<cmStdString, bool> needSetLanguageEnabledMaps;
+  std::map<std::string, bool> needSetLanguageEnabledMaps;
   // foreach language
   // load the CMakeDetermine(LANG)Compiler.cmake file to find
   // the compiler
@@ -823,7 +823,7 @@ cmGlobalGenerator::GetLanguageOutputExtension(cmSourceFile const& source) const
   const std::string& lang = source.GetLanguage();
   if(!lang.empty())
     {
-    std::map<cmStdString, cmStdString>::const_iterator it =
+    std::map<std::string, std::string>::const_iterator it =
                                   this->LanguageToOutputExtension.find(lang);
 
     if(it != this->LanguageToOutputExtension.end())
@@ -857,7 +857,7 @@ std::string cmGlobalGenerator::GetLanguageFromExtension(const char* ext) const
     {
     ++ext;
     }
-  std::map<cmStdString, cmStdString>::const_iterator it
+  std::map<std::string, std::string>::const_iterator it
                                         = this->ExtensionToLanguage.find(ext);
   if(it != this->ExtensionToLanguage.end())
     {
@@ -1011,7 +1011,7 @@ bool cmGlobalGenerator::IsDependedOn(const std::string& project,
                                      cmTarget const* targetIn)
 {
   // Get all local gens for this project
-  std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator it =
+  std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator it =
                                               this->ProjectMap.find(project);
   if (it == this->ProjectMap.end())
     {
@@ -1516,8 +1516,8 @@ void cmGlobalGenerator::ComputeTargetObjects(cmGeneratorTarget*) const
 
 void cmGlobalGenerator::CheckLocalGenerators()
 {
-  std::map<cmStdString, cmStdString> notFoundMap;
+  std::map<std::string, std::string> notFoundMap;
-//  std::set<cmStdString> notFoundMap;
+//  std::set<std::string> notFoundMap;
   // after it is all done do a ConfigureFinalPass
   cmCacheManager* manager = 0;
   for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
@@ -1597,7 +1597,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
   if(notFoundMap.size())
     {
     std::string notFoundVars;
-    for(std::map<cmStdString, cmStdString>::const_iterator
+    for(std::map<std::string, std::string>::const_iterator
         ii = notFoundMap.begin();
         ii != notFoundMap.end();
         ++ii)
@@ -1956,7 +1956,7 @@ bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root,
 void
 cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
 {
-  for(std::map<cmStdString, bool>::const_iterator i =
+  for(std::map<std::string, bool>::const_iterator i =
         this->LanguageEnabled.begin(); i != this->LanguageEnabled.end(); ++i)
     {
     lang.push_back(i->first);
@@ -1965,7 +1965,7 @@ cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) const
 
 int cmGlobalGenerator::GetLinkerPreference(const std::string& lang) const
 {
-  std::map<cmStdString, int>::const_iterator it =
+  std::map<std::string, int>::const_iterator it =
                                    this->LanguageToLinkerPreference.find(lang);
   if (it != this->LanguageToLinkerPreference.end())
     {
@@ -2075,14 +2075,14 @@ cmGlobalGenerator::FindTarget(const std::string& name,
 {
   if (!excludeAliases)
     {
-    std::map<cmStdString, cmTarget*>::const_iterator ai
+    std::map<std::string, cmTarget*>::const_iterator ai
                                             = this->AliasTargets.find(name);
     if (ai != this->AliasTargets.end())
       {
       return ai->second;
       }
     }
-  std::map<cmStdString,cmTarget *>::const_iterator i =
+  std::map<std::string,cmTarget *>::const_iterator i =
     this->TotalTargets.find ( name );
   if ( i != this->TotalTargets.end() )
     {
@@ -2294,7 +2294,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
     {
     if(!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.')
       {
-      std::set<cmStdString>* componentsSet = &this->InstallComponents;
+      std::set<std::string>* componentsSet = &this->InstallComponents;
       cpackCommandLines.erase(cpackCommandLines.begin(),
         cpackCommandLines.end());
       depends.erase(depends.begin(), depends.end());
@@ -2302,7 +2302,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
       if ( componentsSet->size() > 0 )
         {
         ostr << "Available install components are:";
-        std::set<cmStdString>::iterator it;
+        std::set<std::string>::iterator it;
         for (
           it = componentsSet->begin();
           it != componentsSet->end();
@@ -2516,7 +2516,7 @@ cmGlobalGenerator::GenerateRuleFile(std::string const& output) const
 std::string cmGlobalGenerator::GetSharedLibFlagsForLanguage(
                                                   std::string const& l) const
 {
-  std::map<cmStdString, cmStdString>::const_iterator it =
+  std::map<std::string, std::string>::const_iterator it =
                               this->LanguageToOriginalSharedLibFlags.find(l);
   if(it != this->LanguageToOriginalSharedLibFlags.end())
     {
@@ -2690,7 +2690,7 @@ void cmGlobalGenerator::AddToManifest(const char* config,
 }
 
 //----------------------------------------------------------------------------
-std::set<cmStdString> const&
+std::set<std::string> const&
 cmGlobalGenerator::GetDirectoryContent(std::string const& dir, bool needDisk)
 {
   DirectoryContent& dc = this->DirectoryContentMap[dir];
@@ -2796,7 +2796,7 @@ void cmGlobalGenerator::CheckRuleHashes(std::string const& pfile,
     fname = line.substr(33, line.npos);
 
     // Look for a hash for this file's rule.
-    std::map<cmStdString, RuleHash>::const_iterator rhi =
+    std::map<std::string, RuleHash>::const_iterator rhi =
       this->RuleHashes.find(fname);
     if(rhi != this->RuleHashes.end())
       {
@@ -2841,7 +2841,7 @@ void cmGlobalGenerator::WriteRuleHashes(std::string const& pfile)
     {
     cmGeneratedFileStream fout(pfile.c_str());
     fout << "# Hashes of file build rules.\n";
-    for(std::map<cmStdString, RuleHash>::const_iterator
+    for(std::map<std::string, RuleHash>::const_iterator
           rhi = this->RuleHashes.begin(); rhi != this->RuleHashes.end(); ++rhi)
       {
       fout.write(rhi->second.Data, 32);
@@ -2862,7 +2862,7 @@ void cmGlobalGenerator::WriteSummary()
   cmGeneratedFileStream fout(fname.c_str());
 
   // Generate summary information files for each target.
-  for(std::map<cmStdString,cmTarget *>::const_iterator ti =
+  for(std::map<std::string,cmTarget *>::const_iterator ti =
         this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti)
     {
     if ((ti->second)->GetType() == cmTarget::INTERFACE_LIBRARY)

Source/cmGlobalGenerator.h

@@ -167,7 +167,7 @@ public:
 
   void AddInstallComponent(const char* component);
 
-  const std::set<cmStdString>* GetInstallComponents() const
+  const std::set<std::string>* GetInstallComponents() const
     { return &this->InstallComponents; }
 
   cmExportSetMap& GetExportSets() {return this->ExportSets;}
@@ -244,7 +244,7 @@ public:
       from disk at most once and cached.  During the generation step
       the content will include the target files to be built even if
       they do not yet exist.  */
-  std::set<cmStdString> const& GetDirectoryContent(std::string const& dir,
+  std::set<std::string> const& GetDirectoryContent(std::string const& dir,
                                                    bool needDisk = true);
 
   void AddTarget(cmTarget* t);
@@ -276,7 +276,7 @@ public:
   /** Get per-target generator information.  */
   cmGeneratorTarget* GetGeneratorTarget(cmTarget const*) const;
 
-  const std::map<cmStdString, std::vector<cmLocalGenerator*> >& GetProjectMap()
+  const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap()
                                                const {return this->ProjectMap;}
 
   // track files replaced during a Generate
@@ -364,18 +364,18 @@ protected:
   bool UseLinkScript;
   bool ForceUnixPaths;
   bool ToolSupportsColor;
-  cmStdString FindMakeProgramFile;
+  std::string FindMakeProgramFile;
-  cmStdString ConfiguredFilesPath;
+  std::string ConfiguredFilesPath;
   cmake *CMakeInstance;
   std::vector<cmLocalGenerator *> LocalGenerators;
   cmLocalGenerator* CurrentLocalGenerator;
   // map from project name to vector of local generators in that project
-  std::map<cmStdString, std::vector<cmLocalGenerator*> > ProjectMap;
+  std::map<std::string, std::vector<cmLocalGenerator*> > ProjectMap;
   std::map<cmLocalGenerator*, std::set<cmTarget const*> >
                                                     LocalGeneratorToTargetMap;
 
   // Set of named installation components requested by the project.
-  std::set<cmStdString> InstallComponents;
+  std::set<std::string> InstallComponents;
   bool InstallTargetEnabled;
   // Sets of named target exports
   cmExportSetMap ExportSets;
@@ -387,9 +387,9 @@ protected:
   cmTargetManifest TargetManifest;
 
   // All targets in the entire project.
-  std::map<cmStdString,cmTarget *> TotalTargets;
+  std::map<std::string,cmTarget *> TotalTargets;
-  std::map<cmStdString,cmTarget *> AliasTargets;
+  std::map<std::string,cmTarget *> AliasTargets;
-  std::map<cmStdString,cmTarget *> ImportedTargets;
+  std::map<std::string,cmTarget *> ImportedTargets;
   std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles;
 
   virtual const char* GetPredefinedTargetsFolder();
@@ -401,18 +401,18 @@ private:
   float FirstTimeProgress;
   // If you add a new map here, make sure it is copied
   // in EnableLanguagesFromGenerator
-  std::map<cmStdString, bool> IgnoreExtensions;
+  std::map<std::string, bool> IgnoreExtensions;
-  std::map<cmStdString, bool> LanguageEnabled;
+  std::map<std::string, bool> LanguageEnabled;
-  std::set<cmStdString> LanguagesReady; // Ready for try_compile
+  std::set<std::string> LanguagesReady; // Ready for try_compile
-  std::map<cmStdString, cmStdString> OutputExtensions;
+  std::map<std::string, std::string> OutputExtensions;
-  std::map<cmStdString, cmStdString> LanguageToOutputExtension;
+  std::map<std::string, std::string> LanguageToOutputExtension;
-  std::map<cmStdString, cmStdString> ExtensionToLanguage;
+  std::map<std::string, std::string> ExtensionToLanguage;
-  std::map<cmStdString, int> LanguageToLinkerPreference;
+  std::map<std::string, int> LanguageToLinkerPreference;
-  std::map<cmStdString, cmStdString> LanguageToOriginalSharedLibFlags;
+  std::map<std::string, std::string> LanguageToOriginalSharedLibFlags;
 
   // Record hashes for rules and outputs.
   struct RuleHash { char Data[32]; };
-  std::map<cmStdString, RuleHash> RuleHashes;
+  std::map<std::string, RuleHash> RuleHashes;
   void CheckRuleHashes();
   void CheckRuleHashes(std::string const& pfile, std::string const& home);
   void WriteRuleHashes(std::string const& pfile);
@@ -448,18 +448,18 @@ private:
   virtual const char* GetBuildIgnoreErrorsFlag() const { return 0; }
 
   // Cache directory content and target files to be built.
-  struct DirectoryContent: public std::set<cmStdString>
+  struct DirectoryContent: public std::set<std::string>
   {
-    typedef std::set<cmStdString> derived;
+    typedef std::set<std::string> derived;
     bool LoadedFromDisk;
     DirectoryContent(): LoadedFromDisk(false) {}
     DirectoryContent(DirectoryContent const& dc):
       derived(dc), LoadedFromDisk(dc.LoadedFromDisk) {}
   };
-  std::map<cmStdString, DirectoryContent> DirectoryContentMap;
+  std::map<std::string, DirectoryContent> DirectoryContentMap;
 
   // Set of binary directories on disk.
-  std::set<cmStdString> BinaryDirectories;
+  std::set<std::string> BinaryDirectories;
 
   // track targets to issue CMP0042 warning for.
   std::set<std::string> CMP0042WarnTargets;

Source/cmGlobalKdevelopGenerator.cxx

@@ -44,7 +44,7 @@ void cmGlobalKdevelopGenerator::Generate()
 {
   // for each sub project in the project create
   // a kdevelop project
-  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
        it = this->GlobalGenerator->GetProjectMap().begin();
       it!= this->GlobalGenerator->GetProjectMap().end();
       ++it)
@@ -103,7 +103,7 @@ bool cmGlobalKdevelopGenerator
   std::string projectDir = projectDirIn + "/";
   std::string filename = outputDir+ "/" + projectname +".kdevelop.filelist";
 
-  std::set<cmStdString> files;
+  std::set<std::string> files;
   std::string tmp;
 
   for (std::vector<cmLocalGenerator*>::const_iterator it=lgs.begin();
@@ -217,7 +217,7 @@ bool cmGlobalKdevelopGenerator
     }
 
   fileToOpen="";
-  for (std::set<cmStdString>::const_iterator it=files.begin();
+  for (std::set<std::string>::const_iterator it=files.begin();
        it!=files.end(); it++)
     {
     // get the full path to the file

Source/cmGlobalNinjaGenerator.cxx

@@ -886,7 +886,7 @@ cmGlobalNinjaGenerator
   if (target->GetType() == cmTarget::GLOBAL_TARGET) {
     // Global targets only depend on other utilities, which may not appear in
     // the TargetDepends set (e.g. "all").
-    std::set<cmStdString> const& utils = target->GetUtilities();
+    std::set<std::string> const& utils = target->GetUtilities();
     std::copy(utils.begin(), utils.end(), std::back_inserter(outputs));
   } else {
     cmTargetDependSet const& targetDeps =

Source/cmGlobalUnixMakefileGenerator3.cxx

@@ -624,7 +624,7 @@ void cmGlobalUnixMakefileGenerator3
 void
 cmGlobalUnixMakefileGenerator3
 ::WriteConvenienceRules(std::ostream& ruleFileStream,
-                        std::set<cmStdString> &emitted)
+                        std::set<std::string> &emitted)
 {
   std::vector<std::string> depends;
   std::vector<std::string> commands;
@@ -1049,7 +1049,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
   lg->AppendEcho(commands,"... depend");
 
   // Keep track of targets already listed.
-  std::set<cmStdString> emittedTargets;
+  std::set<std::string> emittedTargets;
 
   // for each local generator
   unsigned int i;
@@ -1084,8 +1084,8 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
         }
       }
     }
-  std::vector<cmStdString> const& localHelp = lg->GetLocalHelp();
+  std::vector<std::string> const& localHelp = lg->GetLocalHelp();
-  for(std::vector<cmStdString>::const_iterator o = localHelp.begin();
+  for(std::vector<std::string>::const_iterator o = localHelp.begin();
       o != localHelp.end(); ++o)
     {
     path = "... ";
@@ -1102,9 +1102,9 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
 bool cmGlobalUnixMakefileGenerator3
 ::NeedRequiresStep(cmTarget const& target)
 {
-  std::set<cmStdString> languages;
+  std::set<std::string> languages;
   target.GetLanguages(languages);
-  for(std::set<cmStdString>::const_iterator l = languages.begin();
+  for(std::set<std::string>::const_iterator l = languages.begin();
       l != languages.end(); ++l)
     {
     std::string var = "CMAKE_NEEDS_REQUIRES_STEP_";

Source/cmGlobalUnixMakefileGenerator3.h

@@ -96,7 +96,7 @@ public:
 
   // write the top level target rules
   void WriteConvenienceRules(std::ostream& ruleFileStream,
-                             std::set<cmStdString> &emitted);
+                             std::set<std::string> &emitted);
 
   /** Get the command to use for a target that has no rule.  This is
       used for multiple output dependencies and for cmake_force.  */

Source/cmGlobalVisualStudio6Generator.cxx

@@ -260,7 +260,7 @@ void cmGlobalVisualStudio6Generator
 // output the DSW file
 void cmGlobalVisualStudio6Generator::OutputDSWFile()
 {
-  std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     this->OutputDSWFile(it->second[0], it->second);
@@ -318,7 +318,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
 void cmGlobalVisualStudio6Generator::WriteExternalProject(std::ostream& fout,
                                const std::string& name,
                                const char* location,
-                               const std::set<cmStdString>& dependencies)
+                               const std::set<std::string>& dependencies)
 {
  fout << "#########################################################"
     "######################\n\n";
@@ -329,7 +329,7 @@ void cmGlobalVisualStudio6Generator::WriteExternalProject(std::ostream& fout,
   fout << "{{{\n";
 
 
-  std::set<cmStdString>::const_iterator i, end;
+  std::set<std::string>::const_iterator i, end;
   // write dependencies.
   i = dependencies.begin();
   end = dependencies.end();

Source/cmGlobalVisualStudio6Generator.h

@@ -103,7 +103,7 @@ private:
                     cmTarget const& t);
   void WriteExternalProject(std::ostream& fout,
                             const std::string& name, const char* path,
-                            const std::set<cmStdString>& dependencies);
+                            const std::set<std::string>& dependencies);
   void WriteDSWFooter(std::ostream& fout);
   virtual std::string WriteUtilityDepend(cmTarget const* target);
   std::string MSDevCommand;

Source/cmGlobalVisualStudio71Generator.cxx

@@ -237,7 +237,7 @@ void cmGlobalVisualStudio71Generator
                        const std::string& name,
                        const char* location,
                        const char* typeGuid,
-                       const std::set<cmStdString>& depends)
+                       const std::set<std::string>& depends)
 {
   fout << "Project(\"{"
        << (typeGuid ? typeGuid : this->ExternalProjectType(location))
@@ -252,7 +252,7 @@ void cmGlobalVisualStudio71Generator
   if(!depends.empty())
     {
     fout << "\tProjectSection(ProjectDependencies) = postProject\n";
-    std::set<cmStdString>::const_iterator it;
+    std::set<std::string>::const_iterator it;
     for(it = depends.begin(); it != depends.end(); ++it)
       {
       if(it->size() > 0)

Source/cmGlobalVisualStudio71Generator.h

@@ -72,7 +72,7 @@ protected:
                                     const std::string& name,
                                     const char* path,
                                     const char* typeGuid,
-                                    const std::set<cmStdString>& depends);
+                                    const std::set<std::string>& depends);
   virtual void WriteSLNHeader(std::ostream& fout);
 
   std::string ProjectConfigurationSectionName;

Source/cmGlobalVisualStudio7Generator.cxx

@@ -353,7 +353,7 @@ void cmGlobalVisualStudio7Generator
 // output the SLN file
 void cmGlobalVisualStudio7Generator::OutputSLNFile()
 {
-  std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     this->OutputSLNFile(it->second[0], it->second);
@@ -761,7 +761,7 @@ void cmGlobalVisualStudio7Generator::WriteExternalProject(std::ostream& fout,
                                const std::string& name,
                                const char* location,
                                const char* typeGuid,
-                               const std::set<cmStdString>&)
+                               const std::set<std::string>&)
 {
   std::string d = cmSystemTools::ConvertToOutputPath(location);
   fout << "Project("

Source/cmGlobalVisualStudio7Generator.h

@@ -156,7 +156,7 @@ protected:
                                     const std::string& name,
                                     const char* path,
                                     const char* typeGuid,
-                                    const std::set<cmStdString>&
+                                    const std::set<std::string>&
                                     dependencies);
 
   std::string ConvertToSolutionPath(const char* path);
@@ -164,7 +164,7 @@ protected:
   std::set<std::string> IsPartOfDefaultBuild(const std::string& project,
                                              cmTarget const* target);
   std::vector<std::string> Configurations;
-  std::map<cmStdString, cmStdString> GUIDMap;
+  std::map<std::string, std::string> GUIDMap;
 
   virtual void WriteFolders(std::ostream& fout);
   virtual void WriteFoldersContent(std::ostream& fout);

Source/cmGlobalVisualStudio8Generator.cxx

@@ -338,7 +338,7 @@ void cmGlobalVisualStudio8Generator::Generate()
   if(this->AddCheckTarget())
     {
     // All targets depend on the build-system check target.
-    for(std::map<cmStdString,cmTarget *>::const_iterator
+    for(std::map<std::string,cmTarget *>::const_iterator
           ti = this->TotalTargets.begin();
         ti != this->TotalTargets.end(); ++ti)
       {
@@ -436,7 +436,7 @@ bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies(
   cmTarget& target)
 {
   // Look for utility dependencies that magically link.
-  for(std::set<cmStdString>::const_iterator ui =
+  for(std::set<std::string>::const_iterator ui =
         target.GetUtilities().begin();
       ui != target.GetUtilities().end(); ++ui)
     {

Source/cmGlobalVisualStudioGenerator.cxx

@@ -53,7 +53,7 @@ void cmGlobalVisualStudioGenerator::Generate()
   const char* no_working_dir = 0;
   std::vector<std::string> no_depends;
   cmCustomCommandLines no_commands;
-  std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     std::vector<cmLocalGenerator*>& gen = it->second;
@@ -128,7 +128,7 @@ cmGlobalVisualStudioGenerator
 
   // Count the number of object files with each name.  Note that
   // windows file names are not case sensitive.
-  std::map<cmStdString, int> counts;
+  std::map<std::string, int> counts;
   std::vector<cmSourceFile*> objectSources;
   gt->GetObjectSources(objectSources);
   for(std::vector<cmSourceFile*>::const_iterator
@@ -380,7 +380,7 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends()
     {
     return false;
     }
-  std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
     {
     std::vector<cmLocalGenerator*>& gen = it->second;
@@ -852,7 +852,7 @@ bool
 cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmTarget const& target)
 {
   // check to see if this is a fortran build
-  std::set<cmStdString> languages;
+  std::set<std::string> languages;
   target.GetLanguages(languages);
   if(languages.size() == 1)
     {

Source/cmGlobalVisualStudioGenerator.h

@@ -99,7 +99,7 @@ protected:
   virtual void AddPlatformDefinitions(cmMakefile* mf);
 
   virtual bool ComputeTargetDepends();
-  class VSDependSet: public std::set<cmStdString> {};
+  class VSDependSet: public std::set<std::string> {};
   class VSDependMap: public std::map<cmTarget const*, VSDependSet> {};
   VSDependMap VSTargetDepends;
   void ComputeVSTargetDepends(cmTarget&);
@@ -108,7 +108,7 @@ protected:
   std::string GetUtilityForTarget(cmTarget& target, const std::string&);
   virtual std::string WriteUtilityDepend(cmTarget const*) = 0;
   std::string GetUtilityDepend(cmTarget const* target);
-  typedef std::map<cmTarget const*, cmStdString> UtilityDependsMap;
+  typedef std::map<cmTarget const*, std::string> UtilityDependsMap;
   UtilityDependsMap UtilityDepends;
   const char* AdditionalPlatformDefinition;
 

Source/cmGlobalXCodeGenerator.cxx

@@ -337,7 +337,7 @@ cmLocalGenerator *cmGlobalXCodeGenerator::CreateLocalGenerator()
 //----------------------------------------------------------------------------
 void cmGlobalXCodeGenerator::Generate()
 {
-  std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
+  std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   // make sure extra targets are added before calling
   // the parent generate which will call trace depends
   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
@@ -570,7 +570,7 @@ void cmGlobalXCodeGenerator::addObject(cmXCodeObject *obj)
 {
   if(obj->GetType() == cmXCodeObject::OBJECT)
     {
-    cmStdString id = obj->GetId();
+    std::string id = obj->GetId();
 
     // If this is a duplicate id, it's an error:
     //
@@ -631,17 +631,17 @@ cmXCodeObject* cmGlobalXCodeGenerator
 }
 
 //----------------------------------------------------------------------------
-cmStdString
+std::string
 GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath)
 {
-  cmStdString key(cmtarget.GetName());
+  std::string key(cmtarget.GetName());
   key += "-";
   key += fullpath;
   return key;
 }
 
 //----------------------------------------------------------------------------
-cmStdString
+std::string
 GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf)
 {
   return GetGroupMapKeyFromPath(cmtarget, sf->GetFullPath());
@@ -844,7 +844,7 @@ cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
     fileRef->SetComment(fname.c_str());
     this->FileRefs[fname] = fileRef;
     }
-  cmStdString key = GetGroupMapKeyFromPath(cmtarget, fullpath);
+  std::string key = GetGroupMapKeyFromPath(cmtarget, fullpath);
   cmXCodeObject* group = this->GroupMap[key];
   cmXCodeObject* children = group->GetObject("children");
   if (!children->HasObject(fileRef))
@@ -1127,7 +1127,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
     std::vector<cmXCodeObject*> contentBuildPhases;
     if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
       {
-      typedef std::map<cmStdString, std::vector<cmSourceFile*> >
+      typedef std::map<std::string, std::vector<cmSourceFile*> >
         mapOfVectorOfSourceFiles;
       mapOfVectorOfSourceFiles bundleFiles;
       for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
@@ -1216,7 +1216,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
 void cmGlobalXCodeGenerator::ForceLinkerLanguages()
 {
   // This makes sure all targets link using the proper language.
-  for(std::map<cmStdString, cmTarget*>::const_iterator
+  for(std::map<std::string, cmTarget*>::const_iterator
         ti = this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti)
     {
     this->ForceLinkerLanguage(*ti->second);
@@ -1477,7 +1477,7 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
 
   // collect multiple outputs of custom commands into a set
   // which will be used for every configuration
-  std::map<cmStdString, cmStdString> multipleOutputPairs;
+  std::map<std::string, std::string> multipleOutputPairs;
   for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
       i != commands.end(); ++i)
     {
@@ -1548,8 +1548,8 @@ void  cmGlobalXCodeGenerator
                             std::vector<cmCustomCommand>
                             const & commands,
                             const char* configName,
-                            const std::map<cmStdString,
+                            const std::map<std::string,
-                            cmStdString>& multipleOutputPairs
+                            std::string>& multipleOutputPairs
                            )
 {
   std::string makefileName=makefileBasename;
@@ -1571,7 +1571,7 @@ void  cmGlobalXCodeGenerator
 
   // have all depend on all outputs
   makefileStream << "all: ";
-  std::map<const cmCustomCommand*, cmStdString> tname;
+  std::map<const cmCustomCommand*, std::string> tname;
   int count = 0;
   for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
       i != commands.end(); ++i)
@@ -1669,7 +1669,7 @@ void  cmGlobalXCodeGenerator
     makefileStream <<
         "\n# Dependencies of multiple outputs to their primary outputs \n";
 
-    for(std::map<cmStdString, cmStdString>::const_iterator o =
+    for(std::map<std::string, std::string>::const_iterator o =
         multipleOutputPairs.begin(); o != multipleOutputPairs.end(); ++o)
       {
       makefileStream << o->first << ": " << o->second << "\n";
@@ -1678,7 +1678,7 @@ void  cmGlobalXCodeGenerator
     makefileStream <<
         "\n"
         "cmake_check_multiple_outputs:\n";
-    for(std::map<cmStdString, cmStdString>::const_iterator o =
+    for(std::map<std::string, std::string>::const_iterator o =
         multipleOutputPairs.begin(); o != multipleOutputPairs.end(); ++o)
       {
       makefileStream << "\t@if [ ! -f "
@@ -2088,7 +2088,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
   std::vector<std::string> includes;
   this->CurrentLocalGenerator->GetIncludeDirectories(includes, gtgt,
                                                      "C", configName);
-  std::set<cmStdString> emitted;
+  std::set<std::string> emitted;
   emitted.insert("/System/Library/Frameworks");
   for(std::vector<std::string>::iterator i = includes.begin();
       i != includes.end(); ++i)
@@ -2357,18 +2357,18 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
     {
     if(i->first.find("XCODE_ATTRIBUTE_") == 0)
       {
-      cmStdString attribute = i->first.substr(16);
+      std::string attribute = i->first.substr(16);
       // Handle [variant=<config>] condition explicitly here.
-      cmStdString::size_type beginVariant =
+      std::string::size_type beginVariant =
         attribute.find("[variant=");
-      if (beginVariant != cmStdString::npos)
+      if (beginVariant != std::string::npos)
         {
-        cmStdString::size_type endVariant =
+        std::string::size_type endVariant =
           attribute.find("]", beginVariant+9);
-        if (endVariant != cmStdString::npos)
+        if (endVariant != std::string::npos)
           {
           // Compare the variant to the configuration.
-          cmStdString variant =
+          std::string variant =
             attribute.substr(beginVariant+9, endVariant-beginVariant-9);
           if (variant == configName)
             {
@@ -2969,7 +2969,7 @@ void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
           mf->FindSourceGroup(source.c_str(), sourceGroups);
         cmXCodeObject* pbxgroup =
           this->CreateOrGetPBXGroup(cmtarget, sourceGroup);
-        cmStdString key = GetGroupMapKey(cmtarget, sf);
+        std::string key = GetGroupMapKey(cmtarget, sf);
         this->GroupMap[key] = pbxgroup;
         }
 
@@ -2984,7 +2984,7 @@ void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
           mf->FindSourceGroup(source.c_str(), sourceGroups);
         cmXCodeObject* pbxgroup =
           this->CreateOrGetPBXGroup(cmtarget, sourceGroup);
-        cmStdString key = GetGroupMapKeyFromPath(cmtarget, source);
+        std::string key = GetGroupMapKeyFromPath(cmtarget, source);
         this->GroupMap[key] = pbxgroup;
         }
       }
@@ -2992,7 +2992,7 @@ void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
 }
 
 cmXCodeObject *cmGlobalXCodeGenerator
-::CreatePBXGroup(cmXCodeObject *parent, cmStdString name)
+::CreatePBXGroup(cmXCodeObject *parent, std::string name)
 {
   cmXCodeObject* parentChildren = NULL;
   if(parent)
@@ -3016,8 +3016,8 @@ cmXCodeObject *cmGlobalXCodeGenerator
 cmXCodeObject* cmGlobalXCodeGenerator
 ::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg)
 {
-  cmStdString s;
+  std::string s;
-  cmStdString target;
+  std::string target;
   const char *targetFolder= cmtarget.GetProperty("FOLDER");
   if(targetFolder) {
     target = targetFolder;
@@ -3026,7 +3026,7 @@ cmXCodeObject* cmGlobalXCodeGenerator
   target += cmtarget.GetName();
   s = target + "/";
   s += sg->GetFullName();
-  std::map<cmStdString, cmXCodeObject* >::iterator it =
+  std::map<std::string, cmXCodeObject* >::iterator it =
     this->GroupNameMap.find(s);
   if(it != this->GroupNameMap.end())
     {
@@ -3043,7 +3043,7 @@ cmXCodeObject* cmGlobalXCodeGenerator
     {
     std::vector<std::string> tgt_folders =
       cmSystemTools::tokenize(target, "/");
-    cmStdString curr_tgt_folder;
+    std::string curr_tgt_folder;
     for(std::vector<std::string>::size_type i = 0; i < tgt_folders.size();i++)
       {
       if (i != 0)
@@ -3070,7 +3070,7 @@ cmXCodeObject* cmGlobalXCodeGenerator
   // If it's the default source group (empty name) then put the source file
   // directly in the tgroup...
   //
-  if (cmStdString(sg->GetFullName()) == "")
+  if (std::string(sg->GetFullName()) == "")
     {
     this->GroupNameMap[s] = tgroup;
     return tgroup;
@@ -3081,12 +3081,12 @@ cmXCodeObject* cmGlobalXCodeGenerator
     {
     std::vector<std::string> folders =
       cmSystemTools::tokenize(sg->GetFullName(), "\\");
-    cmStdString curr_folder = target;
+    std::string curr_folder = target;
     curr_folder += "/";
     for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
       {
       curr_folder += folders[i];
-      std::map<cmStdString, cmXCodeObject* >::iterator i_folder =
+      std::map<std::string, cmXCodeObject* >::iterator i_folder =
         this->GroupNameMap.find(curr_folder);
       //Create new folder
       if(i_folder == this->GroupNameMap.end())
@@ -3466,14 +3466,14 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
   makefileStream
     << "# For each target create a dummy rule "
     "so the target does not have to exist\n";
-  std::set<cmStdString> emitted;
+  std::set<std::string> emitted;
   for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
       i != targets.end(); ++i)
     {
     cmXCodeObject* target = *i;
-    std::map<cmStdString, cmXCodeObject::StringVec> const& deplibs =
+    std::map<std::string, cmXCodeObject::StringVec> const& deplibs =
       target->GetDependLibraries();
-    for(std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator ci
+    for(std::map<std::string, cmXCodeObject::StringVec>::const_iterator ci
           = deplibs.begin(); ci != deplibs.end(); ++ci)
       {
       for(cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
@@ -3529,12 +3529,12 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
         std::string trel = this->ConvertToRelativeForMake(tfull.c_str());
 
         // Add this target to the post-build phases of its dependencies.
-        std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator
+        std::map<std::string, cmXCodeObject::StringVec>::const_iterator
           y = target->GetDependTargets().find(*ct);
         if(y != target->GetDependTargets().end())
           {
-          std::vector<cmStdString> const& deptgts = y->second;
+          std::vector<std::string> const& deptgts = y->second;
-          for(std::vector<cmStdString>::const_iterator d = deptgts.begin();
+          for(std::vector<std::string>::const_iterator d = deptgts.begin();
               d != deptgts.end(); ++d)
             {
             makefileStream << this->PostBuildMakeTarget(*d, *ct) << ": "
@@ -3546,12 +3546,12 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
         makefileStream << trel << ":";
 
         // List dependencies if any exist.
-        std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator
+        std::map<std::string, cmXCodeObject::StringVec>::const_iterator
           x = target->GetDependLibraries().find(*ct);
         if(x != target->GetDependLibraries().end())
           {
-          std::vector<cmStdString> const& deplibs = x->second;
+          std::vector<std::string> const& deplibs = x->second;
-          for(std::vector<cmStdString>::const_iterator d = deplibs.begin();
+          for(std::vector<std::string>::const_iterator d = deplibs.begin();
               d != deplibs.end(); ++d)
             {
             makefileStream << "\\\n\t" <<
@@ -3960,7 +3960,7 @@ cmGlobalXCodeGenerator
   // names since Xcode names them uniquely automatically with a numeric suffix
   // to avoid exact duplicate file names. Note that Mac file names are not
   // typically case sensitive, hence the LowerCase.
-  std::map<cmStdString, int> counts;
+  std::map<std::string, int> counts;
   std::vector<cmSourceFile*> objectSources;
   gt->GetObjectSources(objectSources);
   for(std::vector<cmSourceFile*>::const_iterator

Source/cmGlobalXCodeGenerator.h

@@ -95,7 +95,7 @@ private:
   cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
                                      cmSourceGroup* sg);
   cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
-                                cmStdString name);
+                                std::string name);
   void CreateGroups(cmLocalGenerator* root,
                     std::vector<cmLocalGenerator*>&
                     generators);
@@ -124,7 +124,7 @@ private:
                                  cmTarget& target,
                                  std::vector<cmCustomCommand> const & commands,
                                  const char* configName,
-                                 const std::map<cmStdString, cmStdString>&
+                                 const std::map<std::string, std::string>&
                                      multipleOutputPairs
                                 );
 
@@ -211,7 +211,7 @@ protected:
 
   unsigned int XcodeVersion;
   std::string VersionString;
-  std::set<cmStdString> XCodeObjectIDs;
+  std::set<std::string> XCodeObjectIDs;
   std::vector<cmXCodeObject*> XCodeObjects;
   cmXCodeObject* RootObject;
 private:
@@ -236,14 +236,14 @@ private:
   std::string CurrentReRunCMakeMakefile;
   std::string CurrentXCodeHackMakefile;
   std::string CurrentProject;
-  std::set<cmStdString> TargetDoneSet;
+  std::set<std::string> TargetDoneSet;
   std::vector<std::string> CurrentOutputDirectoryComponents;
   std::vector<std::string> ProjectSourceDirectoryComponents;
   std::vector<std::string> ProjectOutputDirectoryComponents;
-  std::map<cmStdString, cmXCodeObject* > GroupMap;
+  std::map<std::string, cmXCodeObject* > GroupMap;
-  std::map<cmStdString, cmXCodeObject* > GroupNameMap;
+  std::map<std::string, cmXCodeObject* > GroupNameMap;
-  std::map<cmStdString, cmXCodeObject* > TargetGroup;
+  std::map<std::string, cmXCodeObject* > TargetGroup;
-  std::map<cmStdString, cmXCodeObject* > FileRefs;
+  std::map<std::string, cmXCodeObject* > FileRefs;
   std::vector<std::string> Architectures;
   std::string PlatformToolset;
 };

Source/cmGraphVizWriter.cxx

@@ -121,7 +121,7 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
   __set_bool_if_set(this->GeneratePerTarget, "GRAPHVIZ_GENERATE_PER_TARGET");
   __set_bool_if_set(this->GenerateDependers, "GRAPHVIZ_GENERATE_DEPENDERS");
 
-  cmStdString ignoreTargetsRegexes;
+  std::string ignoreTargetsRegexes;
   __set_if_set(ignoreTargetsRegexes, "GRAPHVIZ_IGNORE_TARGETS");
 
   this->TargetsToIgnoreRegex.clear();
@@ -135,7 +135,7 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
         itvIt != ignoreTargetsRegExVector.end();
         ++ itvIt )
       {
-      cmStdString currentRegexString(*itvIt);
+      std::string currentRegexString(*itvIt);
       cmsys::RegularExpression currentRegex;
       if (!currentRegex.compile(currentRegexString.c_str()))
         {
@@ -160,7 +160,7 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
 
   this->CollectTargetsAndLibs();
 
-  for(std::map<cmStdString, const cmTarget*>::const_iterator ptrIt =
+  for(std::map<std::string, const cmTarget*>::const_iterator ptrIt =
                                                       this->TargetPtrs.begin();
       ptrIt != this->TargetPtrs.end();
       ++ptrIt)
@@ -211,7 +211,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
 
   this->CollectTargetsAndLibs();
 
-  for(std::map<cmStdString, const cmTarget*>::const_iterator ptrIt =
+  for(std::map<std::string, const cmTarget*>::const_iterator ptrIt =
                                                       this->TargetPtrs.begin();
       ptrIt != this->TargetPtrs.end();
       ++ptrIt)
@@ -265,7 +265,7 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName)
   std::set<std::string> insertedConnections;
   std::set<std::string> insertedNodes;
 
-  for(std::map<cmStdString, const cmTarget*>::const_iterator ptrIt =
+  for(std::map<std::string, const cmTarget*>::const_iterator ptrIt =
                                                       this->TargetPtrs.begin();
       ptrIt != this->TargetPtrs.end();
       ++ptrIt)
@@ -305,7 +305,7 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName,
                                     std::set<std::string>& insertedConnections,
                                     cmGeneratedFileStream& str) const
 {
-  std::map<cmStdString, const cmTarget* >::const_iterator targetPtrIt =
+  std::map<std::string, const cmTarget* >::const_iterator targetPtrIt =
                                              this->TargetPtrs.find(targetName);
 
   if (targetPtrIt == this->TargetPtrs.end())  // not found at all
@@ -331,7 +331,7 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName,
        ++ llit )
     {
     const char* libName = llit->first.c_str();
-    std::map<cmStdString, cmStdString>::const_iterator libNameIt =
+    std::map<std::string, std::string>::const_iterator libNameIt =
                                           this->TargetNamesNodes.find(libName);
 
     // can happen e.g. if GRAPHVIZ_TARGET_IGNORE_REGEX is used
@@ -364,7 +364,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
                                     std::set<std::string>& insertedConnections,
                                     cmGeneratedFileStream& str) const
 {
-  std::map<cmStdString, const cmTarget* >::const_iterator targetPtrIt =
+  std::map<std::string, const cmTarget* >::const_iterator targetPtrIt =
                                              this->TargetPtrs.find(targetName);
 
   if (targetPtrIt == this->TargetPtrs.end())  // not found at all
@@ -383,7 +383,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
   std::string myNodeName = this->TargetNamesNodes.find(targetName)->second;
 
   // now search who links against me
-  for(std::map<cmStdString, const cmTarget*>::const_iterator dependerIt =
+  for(std::map<std::string, const cmTarget*>::const_iterator dependerIt =
                                                       this->TargetPtrs.begin();
       dependerIt != this->TargetPtrs.end();
       ++dependerIt)
@@ -411,7 +411,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
       if (libName == targetName)
         {
         // So this target links against targetName.
-        std::map<cmStdString, cmStdString>::const_iterator dependerNodeNameIt =
+        std::map<std::string, std::string>::const_iterator dependerNodeNameIt =
                                 this->TargetNamesNodes.find(dependerIt->first);
 
         if(dependerNodeNameIt != this->TargetNamesNodes.end())
@@ -452,7 +452,7 @@ void cmGraphVizWriter::WriteNode(const std::string& targetName,
   if (insertedNodes.find(targetName) == insertedNodes.end())
   {
     insertedNodes.insert(targetName);
-    std::map<cmStdString, cmStdString>::const_iterator nameIt =
+    std::map<std::string, std::string>::const_iterator nameIt =
                                        this->TargetNamesNodes.find(targetName);
 
     str << "    \"" << nameIt->second.c_str() << "\" [ label=\""
@@ -540,7 +540,7 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt)
           continue;
           }
 
-        std::map<cmStdString, const cmTarget*>::const_iterator tarIt =
+        std::map<std::string, const cmTarget*>::const_iterator tarIt =
                                                 this->TargetPtrs.find(libName);
         if ( tarIt == this->TargetPtrs.end() )
           {