kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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.
This commit is contained in:
Ben Boeckel 2014-02-10 00:21:34 -05:00 committed by Brad King
parent 215b1addf0
commit 270eb96df0
152 changed files with 805 additions and 841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/CPack/cmCPackGeneratorFactory.h
View File

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

2
Source/CPack/cpack.cxx
View File

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

4
Source/CTest/cmCTestBZR.cxx
View File

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

2
Source/CTest/cmCTestBuildAndTestHandler.h
View File

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

12
Source/CTest/cmCTestBuildHandler.cxx
View File

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

14
Source/CTest/cmCTestBuildHandler.h
View File

@ -97,10 +97,10 @@ private:
double StartBuildTime;
double EndBuildTime;
std::vector<cmStdString> CustomErrorMatches;
std::vector<cmStdString> CustomErrorExceptions;
std::vector<cmStdString> CustomWarningMatches;
std::vector<cmStdString> CustomWarningExceptions;
std::vector<std::string> CustomErrorMatches;
std::vector<std::string> CustomErrorExceptions;
std::vector<std::string> CustomWarningMatches;
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;
cmStdString SimplifyBuildDir;
std::string SimplifySourceDir;
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;

6
Source/CTest/cmCTestCVS.cxx
View File

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

4
Source/CTest/cmCTestCVS.h
View File

@ -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> {};
std::map<cmStdString, Directory> Dirs;
class Directory: public std::map<std::string, PathStatus> {};
std::map<std::string, Directory> Dirs;
std::string ComputeBranchFlag(std::string const& dir);
void LoadRevisions(std::string const& file, const char* branchFlag,

2
Source/CTest/cmCTestCoverageCommand.h
View File

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

24
Source/CTest/cmCTestCoverageHandler.cxx
View File

@ -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<cmStdString>::iterator line;
std::vector<std::string> lines;
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;

12
Source/CTest/cmCTestCoverageHandler.h
View File

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

4
Source/CTest/cmCTestGIT.cxx
View File

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

2
Source/CTest/cmCTestGenericHandler.h
View File

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

2
Source/CTest/cmCTestGlobalVC.cxx
View File

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

4
Source/CTest/cmCTestGlobalVC.h
View File

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

4
Source/CTest/cmCTestHG.cxx
View File

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

2
Source/CTest/cmCTestLaunch.cxx
View File

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

2
Source/CTest/cmCTestLaunch.h
View File

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

34
Source/CTest/cmCTestMemCheckHandler.cxx
View File

@ -246,8 +246,8 @@ int cmCTestMemCheckHandler::PostProcessHandler()
void cmCTestMemCheckHandler::GenerateTestCommand(
std::vector<std::string>& args, int test)
{
std::vector<cmStdString>::size_type pp;
cmStdString index;
std::vector<std::string>::size_type pp;
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];
cmStdString::size_type pos = arg.find("??");
if (pos != cmStdString::npos)
std::string arg = this->MemoryTesterDynamicOptions[pp];
std::string::size_type pos = arg.find("??");
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;
cmStdString::size_type pos = ofile.find("??");
std::string ofile = this->MemoryTesterOutputFile;
std::string::size_type pos = ofile.find("??");
ofile.replace(pos, 2, index);
if ( !cmSystemTools::FileExists(ofile.c_str()) )

10
Source/CTest/cmCTestMemCheckHandler.h
View File

@ -89,8 +89,8 @@ private:
std::string BoundsCheckerDPBDFile;
std::string BoundsCheckerXMLFile;
std::string MemoryTester;
std::vector<cmStdString> MemoryTesterDynamicOptions;
std::vector<cmStdString> MemoryTesterOptions;
std::vector<std::string> MemoryTesterDynamicOptions;
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<cmStdString> CustomPostMemCheck;
std::vector<std::string> CustomPreMemCheck;
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

2
Source/CTest/cmCTestMultiProcessHandler.cxx
View File

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

10
Source/CTest/cmCTestMultiProcessHandler.h
View File

@ -41,8 +41,8 @@ public:
void PrintTestList();
void PrintLabels();
void SetPassFailVectors(std::vector<cmStdString>* passed,
std::vector<cmStdString>* failed)
void SetPassFailVectors(std::vector<std::string>* passed,
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::vector<cmStdString>* Passed;
std::vector<cmStdString>* Failed;
std::map<int, std::string> TestOutput;
std::vector<std::string>* Passed;
std::vector<std::string>* Failed;
std::vector<std::string> LastTestsFailed;
std::set<std::string> LockedResources;
std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults;

8
Source/CTest/cmCTestP4.cxx
View File

@ -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());
for(std::vector<cmStdString>::const_iterator ai = args.begin();
std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
for(std::vector<std::string>::const_iterator ai = args.begin();
ai != args.end(); ++ai)
{
p4_sync.push_back(ai->c_str());

8
Source/CTest/cmCTestSVN.cxx
View File

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

4
Source/CTest/cmCTestScriptHandler.cxx
View File

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

28
Source/CTest/cmCTestScriptHandler.h
View File

@ -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;
cmStdString BinaryDir;
cmStdString BackupSourceDir;
cmStdString BackupBinaryDir;
cmStdString CTestRoot;
cmStdString CVSCheckOut;
cmStdString CTestCmd;
cmStdString UpdateCmd;
cmStdString CTestEnv;
cmStdString InitialCache;
cmStdString CMakeCmd;
cmStdString CMOutFile;
std::vector<cmStdString> ExtraUpdates;
std::string SourceDir;
std::string BinaryDir;
std::string BackupSourceDir;
std::string BackupBinaryDir;
std::string CTestRoot;
std::string CVSCheckOut;
std::string CTestCmd;
std::string UpdateCmd;
std::string CTestEnv;
std::string InitialCache;
std::string CMakeCmd;
std::string CMOutFile;
std::vector<std::string> ExtraUpdates;
double MinimumInterval;
double ContinuousDuration;

6
Source/CTest/cmCTestSubmitCommand.cxx
View File

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

98
Source/CTest/cmCTestSubmitHandler.cxx
View File

@ -170,10 +170,10 @@ void cmCTestSubmitHandler::Initialize()
}
//----------------------------------------------------------------------------
bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url)
bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
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,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url)
bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
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"));
cmStdString curlopt(this->CTest->GetCTestConfiguration("CurlOptions"));
std::string dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
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
= url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
std::string upload_as
= 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 cmStdString& remoteprefix,
const cmStdString& url)
const std::set<std::string>& files,
const std::string& remoteprefix,
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 = "";
cmStdString::iterator kk;
std::string ofile = "";
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
= url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
std::string turl
= 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 cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url)
const std::string& scp_command,
const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
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::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& destination)
const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
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,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url)
bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
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&,
std::set<cmStdString> const&,
cmStdString const&,
cmStdString const&)
bool cmCTestSubmitHandler::SubmitUsingXMLRPC(std::string const&,
std::set<std::string> const&,
std::string 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" )
{

54
Source/CTest/cmCTestSubmitHandler.h
View File

@ -47,33 +47,33 @@ private:
/**
* Submit file using various ways
*/
bool SubmitUsingFTP(const cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingHTTP(const cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingSCP(const cmStdString& scp_command,
const cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingFTP(const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
const std::string& url);
bool SubmitUsingHTTP(const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
const std::string& url);
bool SubmitUsingSCP(const std::string& scp_command,
const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
const std::string& url);
bool SubmitUsingCP( const cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingCP( const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
const std::string& url);
bool TriggerUsingHTTP(const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool TriggerUsingHTTP(const std::set<std::string>& files,
const std::string& remoteprefix,
const std::string& url);
bool SubmitUsingXMLRPC(const cmStdString& localprefix,
const std::set<cmStdString>& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingXMLRPC(const std::string& localprefix,
const std::set<std::string>& files,
const std::string& remoteprefix,
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;
cmStdString FTPProxy;
std::string HTTPProxyAuth;
std::string FTPProxy;
int FTPProxyType;
std::ostream* LogFile;
bool SubmitPart[cmCTest::PartCount];

30
Source/CTest/cmCTestTestHandler.cxx
View File

@ -540,8 +540,8 @@ int cmCTestTestHandler::ProcessHandler()
this->StartLogFile((this->MemCheck ? "DynamicAnalysis" : "Test"), mLogFile);
this->LogFile = &mLogFile;
std::vector<cmStdString> passed;
std::vector<cmStdString> failed;
std::vector<std::string> passed;
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::set<cmStdString> labels;
std::map<std::string, double> labelTimes;
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,
std::vector<cmStdString> &failed)
void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
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 )

18
Source/CTest/cmCTestTestHandler.h
View File

@ -87,8 +87,8 @@ public:
// ctest -j N will break for that feature
struct cmCTestTestProperties
{
cmStdString Name;
cmStdString Directory;
std::string Name;
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,
std::vector<cmStdString> &failed);
void ProcessDirectory(std::vector<std::string> &passed,
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<cmStdString> CustomPostTest;
std::vector<std::string> CustomPreTest;
std::vector<std::string> CustomPostTest;
std::vector<int> TestsToRun;

2
Source/CTest/cmCTestUploadCommand.cxx
View File

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

4
Source/CTest/cmCTestVC.cxx
View File

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

2
Source/CTest/cmParseGTMCoverage.cxx
View File

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

2
Source/CTest/cmParseMumpsCoverage.cxx
View File

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

2
Source/CTest/cmParseMumpsCoverage.h
View File

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

4
Source/CTest/cmParsePHPCoverage.cxx
View File

@ -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 != '"')

2
Source/CTest/cmParsePHPCoverage.h
View File

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

2
Source/CursesDialog/cmCursesPathWidget.cxx
View File

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

22
Source/cmCTest.cxx
View File

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

20
Source/cmCTest.h
View File

@ -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::set<cmStdString> SetOfStrings;
typedef std::vector<cmsys::String> VectorOfStrings;
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;

10
Source/cmCacheManager.cxx
View File

@ -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<cmStdString>& includes)
std::set<std::string>& excludes,
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)

8
Source/cmCacheManager.h
View File

@ -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<cmStdString>& includes);
std::set<std::string>& excludes,
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);

4
Source/cmCommandArgumentParserHelper.h
View File

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

10
Source/cmComputeLinkDepends.cxx
View File

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

4
Source/cmComputeLinkDepends.h
View File

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

8
Source/cmComputeLinkInformation.cxx
View File

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

10
Source/cmComputeLinkInformation.h
View File

@ -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<cmStdString> ImplicitLinkLibs;
std::set<std::string> ImplicitLinkDirs;
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;

16
Source/cmComputeTargetDepends.cxx
View File

@ -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<cmStdString> emitted;
std::set<std::string> const& tutils = depender->GetUtilities();
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();
for(std::set<cmStdString>::const_iterator i = utils.begin();
std::set<std::string> const& utils = dependee->GetUtilities();
for(std::set<std::string>::const_iterator i = utils.begin();
i != utils.end(); ++i)
{
if(cmTarget const* transitive_dependee =

4
Source/cmComputeTargetDepends.h
View File

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

2
Source/cmCoreTryCompile.cxx
View File

@ -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)),".") &&

2
Source/cmCustomCommand.h
View File

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

20
Source/cmDefinitions.cxx
View File

@ -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<cmStdString> undefined;
std::set<std::string> defined;
std::set<std::string> undefined;
this->ClosureKeys(defined, undefined);
return defined;
}
//----------------------------------------------------------------------------
void cmDefinitions::ClosureKeys(std::set<cmStdString>& defined,
std::set<cmStdString>& undefined) const
void cmDefinitions::ClosureKeys(std::set<std::string>& defined,
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);
}
}

23
Source/cmDefinitions.h
View File

@ -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) {}
Def(const char* v): cmStdString(v?v:""), Exists(v?true:false) {}
Def(Def const& d): cmStdString(d), Exists(d.Exists) {}
private:
typedef std::string std_string;
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,
std::set<cmStdString>& undefined) const;
void ClosureKeys(std::set<std::string>& defined,
std::set<std::string>& undefined) const;
};
#endif

16
Source/cmDependsC.cxx
View File

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

16
Source/cmDependsC.h
View File

@ -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;
cmStdString QuotedLocation;
std::string FileName;
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<cmStdString, cmStdString> HeaderLocationCache;
std::map<std::string, cmIncludeLines *> FileCache;
std::map<std::string, std::string> HeaderLocationCache;
cmStdString CacheFileName;
std::string CacheFileName;
void WriteCacheFile() const;
void ReadCacheFile();

40
Source/cmDependsFortran.cxx
View File

@ -34,11 +34,11 @@ public:
std::string Source;
// Set of provided and required modules.
std::set<cmStdString> Provides;
std::set<cmStdString> Requires;
std::set<std::string> Provides;
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;
for(std::set<cmStdString>::const_iterator i = provides.begin();
std::set<std::string> const& provides = this->Internal->TargetProvides;
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;
for(std::set<cmStdString>::const_iterator i = provides.begin();
std::set<std::string> const& provides = this->Internal->TargetProvides;
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.

24
Source/cmDependsJavaParserHelper.cxx
View File

@ -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<cmStdString>::iterator sit;
std::vector<std::string> files = this->GetFilesProduced();
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 = "";
cmStdString line;
std::string fullfile = "";
std::string line;
while ( cmSystemTools::GetLineFromStream(ifs, line) )
{
fullfile += line + "\n";

20
Source/cmDependsJavaParserHelper.h
View File

@ -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;
cmStdString::size_type InputBufferPos;
cmStdString InputBuffer;
std::string CurrentPackage;
std::string::size_type InputBufferPos;
std::string InputBuffer;
std::vector<char> OutputBuffer;
std::vector<cmStdString> ClassesFound;
std::vector<cmStdString> PackagesImport;
cmStdString CurrentCombine;
std::vector<std::string> ClassesFound;
std::vector<std::string> PackagesImport;
std::string CurrentCombine;
std::vector<CurrentClass> ClassStack;

8
Source/cmDynamicLoader.cxx
View File

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

2
Source/cmExportFileGenerator.h
View File

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

4
Source/cmExportInstallFileGenerator.h
View File

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

12
Source/cmExportLibraryDependenciesCommand.cxx
View File

@ -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<cmStdString, cmStdString> libDepsNew;
std::map<cmStdString, cmStdString> libTypes;
std::map<std::string, std::string> libDepsOld;
std::map<std::string, std::string> libDepsNew;
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")

4
Source/cmExprParserHelper.h
View File

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

4
Source/cmExtraCodeBlocksGenerator.cxx
View File

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

4
Source/cmExtraCodeLiteGenerator.cxx
View File

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

2
Source/cmExtraEclipseCDT4Generator.cxx
View File

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

2
Source/cmExtraSublimeTextGenerator.cxx
View File

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

4
Source/cmFileTimeComparison.cxx
View File

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

6
Source/cmFindBase.h
View File

@ -42,14 +42,14 @@ protected:
bool CheckForVariableInCache();
// use by command during find
cmStdString VariableDocumentation;
cmStdString VariableName;
std::string VariableDocumentation;
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;

4
Source/cmFindCommon.h
View File

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

4
Source/cmFindLibraryCommand.cxx
View File

@ -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);
for(std::set<cmStdString>::const_iterator fi = files.begin();
std::set<std::string> const& files = this->GG->GetDirectoryContent(dir);
for(std::set<std::string>::const_iterator fi = files.begin();
fi != files.end(); ++fi)
{
std::string const& origName = *fi;

2
Source/cmFindPackageCommand.cxx
View File

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

12
Source/cmFindPackageCommand.h
View File

@ -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;
cmStdString Variable;
cmStdString Version;
std::string Name;
std::string Variable;
std::string Version;
unsigned int VersionMajor;
unsigned int VersionMinor;
unsigned int VersionPatch;
unsigned int VersionTweak;
unsigned int VersionCount;
bool VersionExact;
cmStdString FileFound;
cmStdString VersionFound;
std::string FileFound;
std::string VersionFound;
unsigned int VersionFoundMajor;
unsigned int VersionFoundMinor;
unsigned int VersionFoundPatch;

10
Source/cmFindPathCommand.cxx
View File

@ -89,9 +89,9 @@ std::string
cmFindPathCommand::FindHeaderInFramework(std::string const& file,
std::string const& dir)
{
cmStdString fileName = file;
cmStdString frameWorkName;
cmStdString::size_type pos = fileName.find("/");
std::string fileName = file;
std::string frameWorkName;
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;

2
Source/cmGeneratorExpression.cxx
View File

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

4
Source/cmGeneratorExpression.h
View File

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

6
Source/cmGeneratorExpressionDAGChecker.cxx
View File

@ -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<cmStdString>::const_iterator i = propSet.find(property);
const std::set<std::string> &propSet = it->second;
const std::set<std::string>::const_iterator i = propSet.find(property);
if (i != propSet.end())
{
this->CheckResult = ALREADY_SEEN;

2
Source/cmGeneratorExpressionDAGChecker.h
View File

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

2
Source/cmGeneratorExpressionEvaluator.h
View File

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

8
Source/cmGeneratorTarget.cxx
View File

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

4
Source/cmGetCMakePropertyCommand.cxx
View File

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

38
Source/cmGlobalGenerator.cxx
View File

@ -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<cmStdString, bool> needSetLanguageEnabledMaps;
std::map<std::string, bool> needTestLanguage;
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::set<cmStdString> notFoundMap;
std::map<std::string, std::string> 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)

46
Source/cmGlobalGenerator.h
View File

@ -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;
cmStdString ConfiguredFilesPath;
std::string FindMakeProgramFile;
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<cmStdString,cmTarget *> AliasTargets;
std::map<cmStdString,cmTarget *> ImportedTargets;
std::map<std::string,cmTarget *> TotalTargets;
std::map<std::string,cmTarget *> AliasTargets;
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<cmStdString, bool> LanguageEnabled;
std::set<cmStdString> LanguagesReady; // Ready for try_compile
std::map<cmStdString, cmStdString> OutputExtensions;
std::map<cmStdString, cmStdString> LanguageToOutputExtension;
std::map<cmStdString, cmStdString> ExtensionToLanguage;
std::map<cmStdString, int> LanguageToLinkerPreference;
std::map<cmStdString, cmStdString> LanguageToOriginalSharedLibFlags;
std::map<std::string, bool> IgnoreExtensions;
std::map<std::string, bool> LanguageEnabled;
std::set<std::string> LanguagesReady; // Ready for try_compile
std::map<std::string, std::string> OutputExtensions;
std::map<std::string, std::string> LanguageToOutputExtension;
std::map<std::string, std::string> ExtensionToLanguage;
std::map<std::string, int> LanguageToLinkerPreference;
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;

6
Source/cmGlobalKdevelopGenerator.cxx
View File

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

2
Source/cmGlobalNinjaGenerator.cxx
View File

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

12
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -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();
for(std::vector<cmStdString>::const_iterator o = localHelp.begin();
std::vector<std::string> const& localHelp = lg->GetLocalHelp();
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_";

2
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -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. */

6
Source/cmGlobalVisualStudio6Generator.cxx
View File

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

2
Source/cmGlobalVisualStudio6Generator.h
View File

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

4
Source/cmGlobalVisualStudio71Generator.cxx
View File

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

2
Source/cmGlobalVisualStudio71Generator.h
View File

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

4
Source/cmGlobalVisualStudio7Generator.cxx
View File

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

4
Source/cmGlobalVisualStudio7Generator.h
View File

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

4
Source/cmGlobalVisualStudio8Generator.cxx
View File

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

8
Source/cmGlobalVisualStudioGenerator.cxx
View File

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

4
Source/cmGlobalVisualStudioGenerator.h
View File

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

82
Source/cmGlobalXCodeGenerator.cxx
View File

@ -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,
cmStdString>& multipleOutputPairs
const std::map<std::string,
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;
cmStdString target;
std::string s;
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;
for(std::vector<cmStdString>::const_iterator d = deptgts.begin();
std::vector<std::string> const& deptgts = y->second;
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;
for(std::vector<cmStdString>::const_iterator d = deplibs.begin();
std::vector<std::string> const& deplibs = x->second;
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

16
Source/cmGlobalXCodeGenerator.h
View File

@ -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<cmStdString, cmXCodeObject* > GroupNameMap;
std::map<cmStdString, cmXCodeObject* > TargetGroup;
std::map<cmStdString, cmXCodeObject* > FileRefs;
std::map<std::string, cmXCodeObject* > GroupMap;
std::map<std::string, cmXCodeObject* > GroupNameMap;
std::map<std::string, cmXCodeObject* > TargetGroup;
std::map<std::string, cmXCodeObject* > FileRefs;
std::vector<std::string> Architectures;
std::string PlatformToolset;
};

24
Source/cmGraphVizWriter.cxx
View File

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

Some files were not shown because too many files have changed in this diff Show More