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

Remove trailing whitespace from cmLocalGenerator

Browse Source
This commit is contained in:
Brad King 2011-11-29 08:58:45 -05:00
parent 66f44dcdf4
commit 6b104e107e
1 changed files with 73 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
Source/cmLocalGenerator.cxx
View File

@ -96,14 +96,14 @@ void cmLocalGenerator::Configure()
std::string filesDir = this->Makefile->GetStartOutputDirectory(); std::string filesDir = this->Makefile->GetStartOutputDirectory();
filesDir += cmake::GetCMakeFilesDirectory(); filesDir += cmake::GetCMakeFilesDirectory();
cmSystemTools::MakeDirectory(filesDir.c_str()); cmSystemTools::MakeDirectory(filesDir.c_str());
// find & read the list file // find & read the list file
this->ReadInputFile(); this->ReadInputFile();
// at the end of the ReadListFile handle any old style subdirs // at the end of the ReadListFile handle any old style subdirs
// first get all the subdirectories // first get all the subdirectories
std::vector<cmLocalGenerator *> subdirs = this->GetChildren(); std::vector<cmLocalGenerator *> subdirs = this->GetChildren();
// for each subdir recurse // for each subdir recurse
std::vector<cmLocalGenerator *>::iterator sdi = subdirs.begin(); std::vector<cmLocalGenerator *>::iterator sdi = subdirs.begin();
for (; sdi != subdirs.end(); ++sdi) for (; sdi != subdirs.end(); ++sdi)
@ -112,7 +112,7 @@ void cmLocalGenerator::Configure()
{ {
this->Makefile->ConfigureSubDirectory(*sdi); this->Makefile->ConfigureSubDirectory(*sdi);
} }
} }
// Check whether relative paths should be used for optionally // Check whether relative paths should be used for optionally
// relative paths. // relative paths.
@ -212,10 +212,10 @@ void cmLocalGenerator::ReadInputFile()
} }
void cmLocalGenerator::SetupPathConversions() void cmLocalGenerator::SetupPathConversions()
{ {
// Setup the current output directory components for use by // Setup the current output directory components for use by
// Convert // Convert
std::string outdir; std::string outdir;
outdir = outdir =
cmSystemTools::CollapseFullPath(this->Makefile->GetHomeDirectory()); cmSystemTools::CollapseFullPath(this->Makefile->GetHomeDirectory());
cmSystemTools::SplitPath(outdir.c_str(), this->HomeDirectoryComponents); cmSystemTools::SplitPath(outdir.c_str(), this->HomeDirectoryComponents);
@ -225,12 +225,12 @@ void cmLocalGenerator::SetupPathConversions()
outdir = cmSystemTools::CollapseFullPath outdir = cmSystemTools::CollapseFullPath
(this->Makefile->GetHomeOutputDirectory()); (this->Makefile->GetHomeOutputDirectory());
cmSystemTools::SplitPath(outdir.c_str(), cmSystemTools::SplitPath(outdir.c_str(),
this->HomeOutputDirectoryComponents); this->HomeOutputDirectoryComponents);
outdir = cmSystemTools::CollapseFullPath outdir = cmSystemTools::CollapseFullPath
(this->Makefile->GetStartOutputDirectory()); (this->Makefile->GetStartOutputDirectory());
cmSystemTools::SplitPath(outdir.c_str(), cmSystemTools::SplitPath(outdir.c_str(),
this->StartOutputDirectoryComponents); this->StartOutputDirectoryComponents);
} }
@ -289,17 +289,17 @@ void cmLocalGenerator::GenerateTestFiles()
fout.SetCopyIfDifferent(true); fout.SetCopyIfDifferent(true);
fout << "# CMake generated Testfile for " << std::endl fout << "# CMake generated Testfile for " << std::endl
<< "# Source directory: " << "# Source directory: "
<< this->Makefile->GetStartDirectory() << std::endl << this->Makefile->GetStartDirectory() << std::endl
<< "# Build directory: " << "# Build directory: "
<< this->Makefile->GetStartOutputDirectory() << std::endl << this->Makefile->GetStartOutputDirectory() << std::endl
<< "# " << std::endl << "# " << std::endl
<< "# This file includes the relevent testing commands " << "# This file includes the relevent testing commands "
<< "required for " << std::endl << "required for " << std::endl
<< "# testing this directory and lists subdirectories to " << "# testing this directory and lists subdirectories to "
<< "be tested as well." << std::endl; << "be tested as well." << std::endl;
const char* testIncludeFile = const char* testIncludeFile =
this->Makefile->GetProperty("TEST_INCLUDE_FILE"); this->Makefile->GetProperty("TEST_INCLUDE_FILE");
if ( testIncludeFile ) if ( testIncludeFile )
{ {
@ -320,7 +320,7 @@ void cmLocalGenerator::GenerateTestFiles()
for(i = 0; i < this->Children.size(); ++i) for(i = 0; i < this->Children.size(); ++i)
{ {
fout << "SUBDIRS("; fout << "SUBDIRS(";
std::string outP = std::string outP =
this->Children[i]->GetMakefile()->GetStartOutputDirectory(); this->Children[i]->GetMakefile()->GetStartOutputDirectory();
fout << this->Convert(outP.c_str(),START_OUTPUT); fout << this->Convert(outP.c_str(),START_OUTPUT);
fout << ")" << std::endl; fout << ")" << std::endl;
@ -472,7 +472,7 @@ void cmLocalGenerator::GenerateInstallRules()
// Ask each install generator to write its code. // Ask each install generator to write its code.
std::vector<cmInstallGenerator*> const& installers = std::vector<cmInstallGenerator*> const& installers =
this->Makefile->GetInstallGenerators(); this->Makefile->GetInstallGenerators();
for(std::vector<cmInstallGenerator*>::const_iterator for(std::vector<cmInstallGenerator*>::const_iterator
gi = installers.begin(); gi = installers.begin();
gi != installers.end(); ++gi) gi != installers.end(); ++gi)
{ {
@ -553,15 +553,15 @@ void cmLocalGenerator::GenerateTargetManifest()
} }
} }
void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname, void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname,
const char* lang, const char* lang,
cmSourceFile& source, cmSourceFile& source,
cmTarget& ) cmTarget& )
{ {
std::string objectDir = cmSystemTools::GetFilenamePath(std::string(ofname)); std::string objectDir = cmSystemTools::GetFilenamePath(std::string(ofname));
objectDir = this->Convert(objectDir.c_str(),START_OUTPUT,SHELL); objectDir = this->Convert(objectDir.c_str(),START_OUTPUT,SHELL);
std::string objectFile = this->Convert(ofname,START_OUTPUT,SHELL); std::string objectFile = this->Convert(ofname,START_OUTPUT,SHELL);
std::string sourceFile = std::string sourceFile =
this->Convert(source.GetFullPath().c_str(),START_OUTPUT,SHELL,true); this->Convert(source.GetFullPath().c_str(),START_OUTPUT,SHELL,true);
std::string varString = "CMAKE_"; std::string varString = "CMAKE_";
varString += lang; varString += lang;
@ -655,7 +655,7 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
ofname += "/"; ofname += "/";
ofname += obj; ofname += obj;
objVector.push_back(ofname); objVector.push_back(ofname);
this->AddCustomCommandToCreateObject(ofname.c_str(), this->AddCustomCommandToCreateObject(ofname.c_str(),
llang, *(*i), target); llang, *(*i), target);
objs += this->Convert(ofname.c_str(),START_OUTPUT,MAKEFILE); objs += this->Convert(ofname.c_str(),START_OUTPUT,MAKEFILE);
objs += " "; objs += " ";
@ -672,7 +672,7 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
// Shared Module: // Shared Module:
std::string linkLibs; // should be set std::string linkLibs; // should be set
std::string flags; // should be set std::string flags; // should be set
std::string linkFlags; // should be set std::string linkFlags; // should be set
this->GetTargetFlags(linkLibs, flags, linkFlags, target); this->GetTargetFlags(linkLibs, flags, linkFlags, target);
cmLocalGenerator::RuleVariables vars; cmLocalGenerator::RuleVariables vars;
vars.Language = llang; vars.Language = llang;
@ -682,17 +682,17 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
vars.LinkLibraries = linkLibs.c_str(); vars.LinkLibraries = linkLibs.c_str();
vars.Flags = flags.c_str(); vars.Flags = flags.c_str();
vars.LinkFlags = linkFlags.c_str(); vars.LinkFlags = linkFlags.c_str();
std::string langFlags; std::string langFlags;
this->AddLanguageFlags(langFlags, llang, 0); this->AddLanguageFlags(langFlags, llang, 0);
this->AddArchitectureFlags(langFlags, &target, llang, 0); this->AddArchitectureFlags(langFlags, &target, llang, 0);
vars.LanguageCompileFlags = langFlags.c_str(); vars.LanguageCompileFlags = langFlags.c_str();
cmCustomCommandLines commandLines; cmCustomCommandLines commandLines;
std::vector<std::string> rules; std::vector<std::string> rules;
rules.push_back(this->Makefile->GetRequiredDefinition(createRule.c_str())); rules.push_back(this->Makefile->GetRequiredDefinition(createRule.c_str()));
std::vector<std::string> commands; std::vector<std::string> commands;
cmSystemTools::ExpandList(rules, commands); cmSystemTools::ExpandList(rules, commands);
for(std::vector<std::string>::iterator i = commands.begin(); for(std::vector<std::string>::iterator i = commands.begin();
i != commands.end(); ++i) i != commands.end(); ++i)
{ {
@ -728,21 +728,21 @@ void cmLocalGenerator::AddBuildTargetRule(const char* llang, cmTarget& target)
(this->Makefile->GetSource(targetFullPath.c_str())); (this->Makefile->GetSource(targetFullPath.c_str()));
} }
void cmLocalGenerator void cmLocalGenerator
::CreateCustomTargetsAndCommands(std::set<cmStdString> const& lang) ::CreateCustomTargetsAndCommands(std::set<cmStdString> const& lang)
{ {
cmTargets &tgts = this->Makefile->GetTargets(); cmTargets &tgts = this->Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin(); for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++) l != tgts.end(); l++)
{ {
cmTarget& target = l->second; cmTarget& target = l->second;
switch(target.GetType()) switch(target.GetType())
{ {
case cmTarget::STATIC_LIBRARY: case cmTarget::STATIC_LIBRARY:
case cmTarget::SHARED_LIBRARY: case cmTarget::SHARED_LIBRARY:
case cmTarget::MODULE_LIBRARY: case cmTarget::MODULE_LIBRARY:
case cmTarget::EXECUTABLE: case cmTarget::EXECUTABLE:
{ {
const char* llang = target.GetLinkerLanguage(); const char* llang = target.GetLinkerLanguage();
if(!llang) if(!llang)
@ -759,7 +759,7 @@ void cmLocalGenerator
this->AddBuildTargetRule(llang, target); this->AddBuildTargetRule(llang, target);
} }
} }
break; break;
default: default:
break; break;
} }
@ -769,14 +769,14 @@ void cmLocalGenerator
// List of variables that are replaced when // List of variables that are replaced when
// rules are expanced. These variables are // rules are expanced. These variables are
// replaced in the form <var> with GetSafeDefinition(var). // replaced in the form <var> with GetSafeDefinition(var).
// ${LANG} is replaced in the variable first with all enabled // ${LANG} is replaced in the variable first with all enabled
// languages. // languages.
static const char* ruleReplaceVars[] = static const char* ruleReplaceVars[] =
{ {
"CMAKE_${LANG}_COMPILER", "CMAKE_${LANG}_COMPILER",
"CMAKE_SHARED_LIBRARY_CREATE_${LANG}_FLAGS", "CMAKE_SHARED_LIBRARY_CREATE_${LANG}_FLAGS",
"CMAKE_SHARED_MODULE_CREATE_${LANG}_FLAGS", "CMAKE_SHARED_MODULE_CREATE_${LANG}_FLAGS",
"CMAKE_SHARED_MODULE_${LANG}_FLAGS", "CMAKE_SHARED_MODULE_${LANG}_FLAGS",
"CMAKE_SHARED_LIBRARY_${LANG}_FLAGS", "CMAKE_SHARED_LIBRARY_${LANG}_FLAGS",
"CMAKE_${LANG}_LINK_FLAGS", "CMAKE_${LANG}_LINK_FLAGS",
"CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG", "CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG",
@ -807,7 +807,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
return replaceValues.Flags; return replaceValues.Flags;
} }
} }
if(replaceValues.Source) if(replaceValues.Source)
{ {
if(variable == "SOURCE") if(variable == "SOURCE")
@ -870,7 +870,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
} }
if(replaceValues.Target) if(replaceValues.Target)
{ {
if(variable == "TARGET_QUOTED") if(variable == "TARGET_QUOTED")
{ {
std::string targetQuoted = replaceValues.Target; std::string targetQuoted = replaceValues.Target;
@ -1018,13 +1018,13 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
int pos = 0; int pos = 0;
while(ruleReplaceVars[pos]) while(ruleReplaceVars[pos])
{ {
for(std::vector<std::string>::iterator i = enabledLanguages.begin(); for(std::vector<std::string>::iterator i = enabledLanguages.begin();
i != enabledLanguages.end(); ++i) i != enabledLanguages.end(); ++i)
{ {
const char* lang = i->c_str(); const char* lang = i->c_str();
std::string actualReplace = ruleReplaceVars[pos]; std::string actualReplace = ruleReplaceVars[pos];
// If this is the compiler then look for the extra variable // If this is the compiler then look for the extra variable
// _COMPILER_ARG1 which must be the first argument to the compiler // _COMPILER_ARG1 which must be the first argument to the compiler
const char* compilerArg1 = 0; const char* compilerArg1 = 0;
if(actualReplace == "CMAKE_${LANG}_COMPILER") if(actualReplace == "CMAKE_${LANG}_COMPILER")
{ {
@ -1038,7 +1038,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
} }
if(actualReplace == variable) if(actualReplace == variable)
{ {
std::string replace = std::string replace =
this->Makefile->GetSafeDefinition(variable.c_str()); this->Makefile->GetSafeDefinition(variable.c_str());
// if the variable is not a FLAG then treat it like a path // if the variable is not a FLAG then treat it like a path
if(variable.find("_FLAG") == variable.npos) if(variable.find("_FLAG") == variable.npos)
@ -1062,7 +1062,7 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
} }
void void
cmLocalGenerator::ExpandRuleVariables(std::string& s, cmLocalGenerator::ExpandRuleVariables(std::string& s,
const RuleVariables& replaceValues) const RuleVariables& replaceValues)
{ {
@ -1213,7 +1213,7 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang,
std::string flagVar = "CMAKE_INCLUDE_FLAG_"; std::string flagVar = "CMAKE_INCLUDE_FLAG_";
flagVar += lang; flagVar += lang;
const char* includeFlag = const char* includeFlag =
this->Makefile->GetSafeDefinition(flagVar.c_str()); this->Makefile->GetSafeDefinition(flagVar.c_str());
flagVar = "CMAKE_INCLUDE_FLAG_SEP_"; flagVar = "CMAKE_INCLUDE_FLAG_SEP_";
flagVar += lang; flagVar += lang;
@ -1223,7 +1223,7 @@ const char* cmLocalGenerator::GetIncludeFlags(const char* lang,
{ {
quotePaths = true; quotePaths = true;
} }
bool repeatFlag = true; bool repeatFlag = true;
// should the include flag be repeated like ie. -IA -IB // should the include flag be repeated like ie. -IA -IB
if(!sep) if(!sep)
{ {
@ -1354,15 +1354,15 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
this->Makefile->GetDefinition("VTK_SOURCE_DIR"); this->Makefile->GetDefinition("VTK_SOURCE_DIR");
if(vtkSourceDir) if(vtkSourceDir)
{ {
const char* vtk_major = const char* vtk_major =
this->Makefile->GetDefinition("VTK_MAJOR_VERSION"); this->Makefile->GetDefinition("VTK_MAJOR_VERSION");
const char* vtk_minor = const char* vtk_minor =
this->Makefile->GetDefinition("VTK_MINOR_VERSION"); this->Makefile->GetDefinition("VTK_MINOR_VERSION");
vtk_major = vtk_major? vtk_major : "4"; vtk_major = vtk_major? vtk_major : "4";
vtk_minor = vtk_minor? vtk_minor : "4"; vtk_minor = vtk_minor? vtk_minor : "4";
int vmajor = 0; int vmajor = 0;
int vminor = 0; int vminor = 0;
if(sscanf(vtk_major, "%d", &vmajor) && if(sscanf(vtk_major, "%d", &vmajor) &&
sscanf(vtk_minor, "%d", &vminor) && vmajor == 4 && vminor <= 4) sscanf(vtk_minor, "%d", &vminor) && vmajor == 4 && vminor <= 4)
{ {
includeSourceDir = true; includeSourceDir = true;
@ -1403,7 +1403,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
} }
// Get the project-specified include directories. // Get the project-specified include directories.
std::vector<std::string>& includes = std::vector<std::string>& includes =
this->Makefile->GetIncludeDirectories(); this->Makefile->GetIncludeDirectories();
// Support putting all the in-project include directories first if // Support putting all the in-project include directories first if
@ -1446,17 +1446,17 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
std::string& linkFlags, std::string& linkFlags,
cmTarget& target) cmTarget& target)
{ {
std::string buildType = std::string buildType =
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
buildType = cmSystemTools::UpperCase(buildType); buildType = cmSystemTools::UpperCase(buildType);
const char* libraryLinkVariable = const char* libraryLinkVariable =
"CMAKE_SHARED_LINKER_FLAGS"; // default to shared library "CMAKE_SHARED_LINKER_FLAGS"; // default to shared library
switch(target.GetType()) switch(target.GetType())
{ {
case cmTarget::STATIC_LIBRARY: case cmTarget::STATIC_LIBRARY:
{ {
const char* targetLinkFlags = const char* targetLinkFlags =
target.GetProperty("STATIC_LIBRARY_FLAGS"); target.GetProperty("STATIC_LIBRARY_FLAGS");
if(targetLinkFlags) if(targetLinkFlags)
{ {
@ -1475,11 +1475,11 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
} }
} }
} }
break; break;
case cmTarget::MODULE_LIBRARY: case cmTarget::MODULE_LIBRARY:
libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS"; libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS";
case cmTarget::SHARED_LIBRARY: case cmTarget::SHARED_LIBRARY:
{ {
linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable); linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable);
linkFlags += " "; linkFlags += " ";
if(!buildType.empty()) if(!buildType.empty())
@ -1489,8 +1489,8 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
build += buildType; build += buildType;
linkFlags += this->Makefile->GetSafeDefinition(build.c_str()); linkFlags += this->Makefile->GetSafeDefinition(build.c_str());
linkFlags += " "; linkFlags += " ";
} }
if(this->Makefile->IsOn("WIN32") && if(this->Makefile->IsOn("WIN32") &&
!(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW"))) !(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW")))
{ {
const std::vector<cmSourceFile*>& sources = target.GetSourceFiles(); const std::vector<cmSourceFile*>& sources = target.GetSourceFiles();
@ -1500,14 +1500,14 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
cmSourceFile* sf = *i; cmSourceFile* sf = *i;
if(sf->GetExtension() == "def") if(sf->GetExtension() == "def")
{ {
linkFlags += linkFlags +=
this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG"); this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
linkFlags += this->Convert(sf->GetFullPath().c_str(), linkFlags += this->Convert(sf->GetFullPath().c_str(),
START_OUTPUT, SHELL); START_OUTPUT, SHELL);
linkFlags += " "; linkFlags += " ";
} }
} }
} }
const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"); const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
if(targetLinkFlags) if(targetLinkFlags)
{ {
@ -1520,11 +1520,11 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
configLinkFlags += buildType; configLinkFlags += buildType;
targetLinkFlags = target.GetProperty(configLinkFlags.c_str()); targetLinkFlags = target.GetProperty(configLinkFlags.c_str());
if(targetLinkFlags) if(targetLinkFlags)
{ {
linkFlags += targetLinkFlags; linkFlags += targetLinkFlags;
linkFlags += " "; linkFlags += " ";
} }
} }
cmOStringStream linklibsStr; cmOStringStream linklibsStr;
this->OutputLinkLibraries(linklibsStr, target, false); this->OutputLinkLibraries(linklibsStr, target, false);
linkLibs = linklibsStr.str(); linkLibs = linklibsStr.str();
@ -1532,7 +1532,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
break; break;
case cmTarget::EXECUTABLE: case cmTarget::EXECUTABLE:
{ {
linkFlags += linkFlags +=
this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS"); this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
linkFlags += " "; linkFlags += " ";
if(!buildType.empty()) if(!buildType.empty())
@ -1541,7 +1541,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
build += buildType; build += buildType;
linkFlags += this->Makefile->GetSafeDefinition(build.c_str()); linkFlags += this->Makefile->GetSafeDefinition(build.c_str());
linkFlags += " "; linkFlags += " ";
} }
const char* linkLanguage = target.GetLinkerLanguage(); const char* linkLanguage = target.GetLinkerLanguage();
if(!linkLanguage) if(!linkLanguage)
{ {
@ -1566,7 +1566,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
if(cmSystemTools::IsOn if(cmSystemTools::IsOn
(this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) (this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
{ {
std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_") std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_")
+ linkLanguage + std::string("_FLAGS"); + linkLanguage + std::string("_FLAGS");
linkFlags += this->Makefile->GetSafeDefinition(sFlagVar.c_str()); linkFlags += this->Makefile->GetSafeDefinition(sFlagVar.c_str());
linkFlags += " "; linkFlags += " ";
@ -1579,7 +1579,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
} }
else else
{ {
linkFlags += linkFlags +=
this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE"); this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE");
linkFlags += " "; linkFlags += " ";
} }
@ -1595,13 +1595,13 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
configLinkFlags += buildType; configLinkFlags += buildType;
targetLinkFlags = target.GetProperty(configLinkFlags.c_str()); targetLinkFlags = target.GetProperty(configLinkFlags.c_str());
if(targetLinkFlags) if(targetLinkFlags)
{ {
linkFlags += targetLinkFlags; linkFlags += targetLinkFlags;
linkFlags += " "; linkFlags += " ";
} }
} }
} }
break; break;
default: default:
break; break;
} }
@ -1661,9 +1661,9 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
const char* linkLanguage = cli.GetLinkLanguage(); const char* linkLanguage = cli.GetLinkLanguage();
std::string libPathFlag = std::string libPathFlag =
this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG"); this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG");
std::string libPathTerminator = std::string libPathTerminator =
this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR"); this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR");
// Flags to link an executable to shared libraries. // Flags to link an executable to shared libraries.
@ -1786,11 +1786,11 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
{ {
std::vector<std::string> archs; std::vector<std::string> archs;
target->GetAppleArchs(config, archs); target->GetAppleArchs(config, archs);
const char* sysroot = const char* sysroot =
this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT"); this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT");
const char* sysrootDefault = const char* sysrootDefault =
this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT_DEFAULT"); this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT_DEFAULT");
const char* deploymentTarget = const char* deploymentTarget =
this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET"); this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
std::string isysrootVar = std::string("CMAKE_") + lang + "_HAS_ISYSROOT"; std::string isysrootVar = std::string("CMAKE_") + lang + "_HAS_ISYSROOT";
bool hasIsysroot = this->Makefile->IsOn(isysrootVar.c_str()); bool hasIsysroot = this->Makefile->IsOn(isysrootVar.c_str());
@ -1876,7 +1876,7 @@ bool cmLocalGenerator::GetRealDependency(const char* inName,
if(cmSystemTools::FileIsFullPath(inName)) if(cmSystemTools::FileIsFullPath(inName))
{ {
std::string tLocation; std::string tLocation;
if(target->GetType() >= cmTarget::EXECUTABLE && if(target->GetType() >= cmTarget::EXECUTABLE &&
target->GetType() <= cmTarget::MODULE_LIBRARY) target->GetType() <= cmTarget::MODULE_LIBRARY)
{ {
tLocation = target->GetLocation(config); tLocation = target->GetLocation(config);
@ -2904,7 +2904,7 @@ std::string cmLocalGenerator::EscapeForShell(const char* str, bool makeVars,
else else
{ {
cmsysSystem_Shell_GetArgumentForUnix(str, &arg[0], flags); cmsysSystem_Shell_GetArgumentForUnix(str, &arg[0], flags);
} }
return std::string(&arg[0]); return std::string(&arg[0]);
} }
@ -2976,9 +2976,9 @@ cmLocalGenerator::GetTargetDirectory(cmTarget const&) const
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void void
cmLocalGenerator::GetTargetObjectFileDirectories(cmTarget* , cmLocalGenerator::GetTargetObjectFileDirectories(cmTarget* ,
std::vector<std::string>& std::vector<std::string>&
) )
{ {
cmSystemTools::Error("GetTargetObjectFileDirectories" cmSystemTools::Error("GetTargetObjectFileDirectories"