On Wed, Feb 10, 2016 at 12:15 AM Stephen Kelly <steve...@gmail.com> wrote:
> 1) Make cmLocalGenerator not inherit cmOutputConverter
> * Change enums like cmLocalGenerator::START_OUTPUT with sed. See
Please see attached patch.
From 9e1203308ad79d62b24fe6930501e1013b4e52ec Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <dan...@pfeifer-mail.de>
Date: Thu, 19 May 2016 23:11:40 +0200
Subject: [PATCH] Use enums defined in cmOutputConverter using their fully
qualified name.
Mostly automated:
values=("RelativeRoot" "NONE" "FULL" "HOME" "START" "HOME_OUTPUT" "START_OUTPUT"
"OutputFormat" "UNCHANGED" "MAKERULE" "SHELL" "WATCOMQUOTE" "RESPONSE"
"FortranFormat" "FortranFormatNone" "FortranFormatFixed" "FortranFormatFree")
for i in "${values[@]}"; do git grep -l cmLocalGenerator::$i | xargs sed -i "s|cmLocalGenerator::$i|cmOutputConverter::$i|g"; done
---
Source/cmCommonTargetGenerator.cxx | 18 ++--
Source/cmCommonTargetGenerator.h | 4 +-
Source/cmDependsC.cxx | 10 +--
Source/cmDependsFortran.cxx | 40 ++++-----
Source/cmExtraEclipseCDT4Generator.cxx | 2 +-
Source/cmGlobalGenerator.cxx | 2 +-
Source/cmGlobalNinjaGenerator.cxx | 10 +--
Source/cmGlobalUnixMakefileGenerator3.cxx | 24 ++---
Source/cmGlobalVisualStudio7Generator.cxx | 2 +-
Source/cmGlobalXCodeGenerator.cxx | 8 +-
Source/cmLocalGenerator.cxx | 2 +-
Source/cmLocalGenerator.h | 12 +--
Source/cmLocalUnixMakefileGenerator3.cxx | 50 +++++------
Source/cmLocalUnixMakefileGenerator3.h | 6 +-
Source/cmLocalVisualStudio7Generator.cxx | 16 ++--
Source/cmMakefileExecutableTargetGenerator.cxx | 55 ++++++------
Source/cmMakefileLibraryTargetGenerator.cxx | 84 +++++++++---------
Source/cmMakefileTargetGenerator.cxx | 118 ++++++++++++-------------
Source/cmMakefileUtilityTargetGenerator.cxx | 4 +-
Source/cmNinjaNormalTargetGenerator.cxx | 22 ++---
Source/cmNinjaTargetGenerator.cxx | 12 +--
Source/cmNinjaUtilityTargetGenerator.cxx | 4 +-
Source/cmVisualStudio10TargetGenerator.cxx | 4 +-
23 files changed, 257 insertions(+), 252 deletions(-)
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index 6b2d1e3..c630971 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -43,8 +43,8 @@ std::string const& cmCommonTargetGenerator::GetConfigName() const
}
std::string cmCommonTargetGenerator::Convert(
- std::string const& source, cmLocalGenerator::RelativeRoot relative,
- cmLocalGenerator::OutputFormat output)
+ std::string const& source, cmOutputConverter::RelativeRoot relative,
+ cmOutputConverter::OutputFormat output)
{
return this->LocalGenerator->Convert(source, relative, output);
}
@@ -140,7 +140,7 @@ void cmCommonTargetGenerator::AddFortranFlags(std::string& flags)
std::string mod_dir = this->GetFortranModuleDirectory();
if (!mod_dir.empty()) {
mod_dir =
- this->Convert(mod_dir, this->WorkingDirectory, cmLocalGenerator::SHELL);
+ this->Convert(mod_dir, this->WorkingDirectory, cmOutputConverter::SHELL);
} else {
mod_dir =
this->Makefile->GetSafeDefinition("CMAKE_Fortran_MODDIR_DEFAULT");
@@ -167,7 +167,7 @@ void cmCommonTargetGenerator::AddFortranFlags(std::string& flags)
idi != includes.end(); ++idi) {
std::string flg = modpath_flag;
flg +=
- this->Convert(*idi, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ this->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL);
this->LocalGenerator->AppendFlags(flags, flg);
}
}
@@ -177,18 +177,18 @@ void cmCommonTargetGenerator::AppendFortranFormatFlags(
std::string& flags, cmSourceFile const& source)
{
const char* srcfmt = source.GetProperty("Fortran_FORMAT");
- cmLocalGenerator::FortranFormat format =
+ cmOutputConverter::FortranFormat format =
this->LocalGenerator->GetFortranFormat(srcfmt);
- if (format == cmLocalGenerator::FortranFormatNone) {
+ if (format == cmOutputConverter::FortranFormatNone) {
const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT");
format = this->LocalGenerator->GetFortranFormat(tgtfmt);
}
const char* var = 0;
switch (format) {
- case cmLocalGenerator::FortranFormatFixed:
+ case cmOutputConverter::FortranFormatFixed:
var = "CMAKE_Fortran_FORMAT_FIXED_FLAG";
break;
- case cmLocalGenerator::FortranFormatFree:
+ case cmOutputConverter::FortranFormatFree:
var = "CMAKE_Fortran_FORMAT_FREE_FLAG";
break;
default:
@@ -244,7 +244,7 @@ std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l)
if (emitted.insert(*i).second) {
flags += fwSearchFlag;
flags += this->LocalGenerator->ConvertToOutputFormat(
- *i, cmLocalGenerator::SHELL);
+ *i, cmOutputConverter::SHELL);
flags += " ";
}
}
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
index c5d324f..c9645e7 100644
--- a/Source/cmCommonTargetGenerator.h
+++ b/Source/cmCommonTargetGenerator.h
@@ -65,8 +65,8 @@ protected:
void AddFortranFlags(std::string& flags);
std::string Convert(
- std::string const& source, cmLocalGenerator::RelativeRoot relative,
- cmLocalGenerator::OutputFormat output = cmLocalGenerator::UNCHANGED);
+ std::string const& source, cmOutputConverter::RelativeRoot relative,
+ cmOutputConverter::OutputFormat output = cmOutputConverter::UNCHANGED);
void AppendFortranFormatFlags(std::string& flags,
cmSourceFile const& source);
diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx
index 0a5c7fa..78bb1b2 100644
--- a/Source/cmDependsC.cxx
+++ b/Source/cmDependsC.cxx
@@ -238,17 +238,17 @@ 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.
std::string obj_i =
- this->LocalGenerator->Convert(obj, cmLocalGenerator::HOME_OUTPUT);
+ this->LocalGenerator->Convert(obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
- obj_i, cmLocalGenerator::MAKERULE);
+ obj_i, cmOutputConverter::MAKERULE);
internalDepends << obj_i << std::endl;
for (std::set<std::string>::const_iterator i = dependencies.begin();
i != dependencies.end(); ++i) {
makeDepends << obj_m << ": "
- << this->LocalGenerator->Convert(*i,
- cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE)
+ << this->LocalGenerator->Convert(
+ *i, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE)
<< std::endl;
internalDepends << " " << *i << std::endl;
}
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index b8af178..8aa358c 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -192,16 +192,16 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
stamp += ".mod.stamp";
fcStream << "\n";
fcStream << " \""
- << this->LocalGenerator->Convert(mod_lower,
- cmLocalGenerator::START_OUTPUT)
+ << this->LocalGenerator->Convert(
+ mod_lower, cmOutputConverter::START_OUTPUT)
<< "\"\n";
fcStream << " \""
- << this->LocalGenerator->Convert(mod_upper,
- cmLocalGenerator::START_OUTPUT)
+ << this->LocalGenerator->Convert(
+ mod_upper, cmOutputConverter::START_OUTPUT)
<< "\"\n";
fcStream << " \""
- << this->LocalGenerator->Convert(stamp,
- cmLocalGenerator::START_OUTPUT)
+ << this->LocalGenerator->Convert(
+ stamp, cmOutputConverter::START_OUTPUT)
<< "\"\n";
}
fcStream << " )\n";
@@ -317,17 +317,17 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
// Write the include dependencies to the output stream.
std::string obj_i =
- this->LocalGenerator->Convert(obj, cmLocalGenerator::HOME_OUTPUT);
+ this->LocalGenerator->Convert(obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
- obj_i, cmLocalGenerator::MAKERULE);
+ obj_i, cmOutputConverter::MAKERULE);
internalDepends << obj_i << std::endl;
internalDepends << " " << src << std::endl;
for (std::set<std::string>::const_iterator i = info.Includes.begin();
i != info.Includes.end(); ++i) {
makeDepends << obj_m << ": "
- << this->LocalGenerator->Convert(*i,
- cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE)
+ << this->LocalGenerator->Convert(
+ *i, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE)
<< std::endl;
internalDepends << " " << *i << std::endl;
}
@@ -354,7 +354,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
proxy += *i;
proxy += ".mod.proxy";
proxy = this->LocalGenerator->Convert(
- proxy, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE);
+ proxy, cmOutputConverter::HOME_OUTPUT, cmOutputConverter::MAKERULE);
// since we require some things add them to our list of requirements
makeDepends << obj_m << ".requires: " << proxy << std::endl;
@@ -370,8 +370,8 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
if (!required->second.empty()) {
// This module is known. Depend on its timestamp file.
std::string stampFile = this->LocalGenerator->Convert(
- required->second, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE);
+ required->second, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE);
makeDepends << obj_m << ": " << stampFile << "\n";
} else {
// This module is not known to CMake. Try to locate it where
@@ -379,7 +379,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
std::string module;
if (this->FindModule(*i, module)) {
module = this->LocalGenerator->Convert(
- module, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE);
+ module, cmOutputConverter::HOME_OUTPUT, cmOutputConverter::MAKERULE);
makeDepends << obj_m << ": " << module << "\n";
}
}
@@ -392,8 +392,8 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
proxy += "/";
proxy += *i;
proxy += ".mod.proxy";
- proxy = this->LocalGenerator->Convert(proxy, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE);
+ proxy = this->LocalGenerator->Convert(
+ proxy, cmOutputConverter::HOME_OUTPUT, cmOutputConverter::MAKERULE);
makeDepends << proxy << ": " << obj_m << ".provides" << std::endl;
}
@@ -415,13 +415,13 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
modFile += "/";
modFile += *i;
modFile = this->LocalGenerator->Convert(
- modFile, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::SHELL);
+ modFile, cmOutputConverter::HOME_OUTPUT, cmOutputConverter::SHELL);
std::string stampFile = stamp_dir;
stampFile += "/";
stampFile += m;
stampFile += ".mod.stamp";
stampFile = this->LocalGenerator->Convert(
- stampFile, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::SHELL);
+ stampFile, cmOutputConverter::HOME_OUTPUT, cmOutputConverter::SHELL);
makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " << modFile
<< " " << stampFile;
cmMakefile* mf = this->LocalGenerator->GetMakefile();
@@ -441,7 +441,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
std::string driver = this->TargetDirectory;
driver += "/build";
driver = this->LocalGenerator->Convert(
- driver, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE);
+ driver, cmOutputConverter::HOME_OUTPUT, cmOutputConverter::MAKERULE);
makeDepends << driver << ": " << obj_m << ".provides.build\n";
}
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index a8f2e3f..f1b2e33 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -902,7 +902,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
const std::vector<cmGeneratorTarget*> targets =
(*it)->GetGeneratorTargets();
std::string subdir = (*it)->Convert((*it)->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
if (subdir == ".") {
subdir = "";
}
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 3f4c22f..ec8e77c 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -2523,7 +2523,7 @@ void cmGlobalGenerator::AddRuleHash(const std::vector<std::string>& outputs,
// Shorten the output name (in expected use case).
cmOutputConverter converter(this->GetMakefiles()[0]->GetStateSnapshot());
std::string fname =
- converter.Convert(outputs[0], cmLocalGenerator::HOME_OUTPUT);
+ converter.Convert(outputs[0], cmOutputConverter::HOME_OUTPUT);
// Associate the hash with this output.
this->RuleHashes[fname] = hash;
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index d65b463..44a750f 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -289,7 +289,7 @@ void cmGlobalNinjaGenerator::AddMacOSXContentRule()
std::ostringstream cmd;
cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(),
- cmLocalGenerator::SHELL)
+ cmOutputConverter::SHELL)
<< " -E copy $in $out";
this->AddRule("COPY_OSX_CONTENT", cmd.str(), "Copying OS X Content $out",
@@ -1166,13 +1166,13 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
std::ostringstream cmd;
cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(),
- cmLocalGenerator::SHELL)
+ cmOutputConverter::SHELL)
<< " -H"
<< lg->ConvertToOutputFormat(lg->GetSourceDirectory(),
- cmLocalGenerator::SHELL)
+ cmOutputConverter::SHELL)
<< " -B"
<< lg->ConvertToOutputFormat(lg->GetBinaryDirectory(),
- cmLocalGenerator::SHELL);
+ cmOutputConverter::SHELL);
WriteRule(*this->RulesFileStream, "RERUN_CMAKE", cmd.str(),
"Re-running CMake...", "Rule for re-running cmake.",
/*depfile=*/"",
@@ -1221,7 +1221,7 @@ std::string cmGlobalNinjaGenerator::ninjaCmd() const
cmLocalGenerator* lgen = this->LocalGenerators[0];
if (lgen) {
return lgen->ConvertToOutputFormat(this->NinjaCommand,
- cmLocalGenerator::SHELL);
+ cmOutputConverter::SHELL);
}
return "ninja";
}
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 7b5ea13..1985461 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -311,11 +311,11 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream
<< "# The top level Makefile was generated from the following files:\n"
<< "set(CMAKE_MAKEFILE_DEPENDS\n"
- << " \"" << lg->Convert(cache, cmLocalGenerator::START_OUTPUT) << "\"\n";
+ << " \"" << lg->Convert(cache, cmOutputConverter::START_OUTPUT) << "\"\n";
for (std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i) {
cmakefileStream << " \""
- << lg->Convert(*i, cmLocalGenerator::START_OUTPUT)
+ << lg->Convert(*i, cmOutputConverter::START_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@@ -329,10 +329,10 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream << "# The corresponding makefile is:\n"
<< "set(CMAKE_MAKEFILE_OUTPUTS\n"
<< " \""
- << lg->Convert(makefileName, cmLocalGenerator::START_OUTPUT)
+ << lg->Convert(makefileName, cmOutputConverter::START_OUTPUT)
<< "\"\n"
<< " \""
- << lg->Convert(check, cmLocalGenerator::START_OUTPUT)
+ << lg->Convert(check, cmOutputConverter::START_OUTPUT)
<< "\"\n";
cmakefileStream << " )\n\n";
@@ -345,7 +345,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
for (std::vector<std::string>::const_iterator k = outfiles.begin();
k != outfiles.end(); ++k) {
cmakefileStream << " \""
- << lg->Convert(*k, cmLocalGenerator::HOME_OUTPUT)
+ << lg->Convert(*k, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
@@ -358,7 +358,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
tmpStr += cmake::GetCMakeFilesDirectory();
tmpStr += "/CMakeDirectoryInformation.cmake";
cmakefileStream << " \""
- << lg->Convert(tmpStr, cmLocalGenerator::HOME_OUTPUT)
+ << lg->Convert(tmpStr, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@@ -470,8 +470,8 @@ void cmGlobalUnixMakefileGenerator3::WriteDirectoryRules2(
// Begin the directory-level rules section.
std::string dir = lg->GetCurrentBinaryDirectory();
- dir = lg->Convert(dir, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE);
+ dir = lg->Convert(dir, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE);
lg->WriteDivider(ruleFileStream);
ruleFileStream << "# Directory level rules for directory " << dir << "\n\n";
@@ -716,8 +716,8 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
// # in target
- progCmd << lg->Convert(progress.Dir, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ progCmd << lg->Convert(progress.Dir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
//
std::set<cmGeneratorTarget const*> emitted;
progCmd << " " << this->CountProgressMarksInTarget(gtarget, emitted);
@@ -729,8 +729,8 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
- progCmd << lg->Convert(progress.Dir, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ progCmd << lg->Convert(progress.Dir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
progCmd << " 0";
commands.push_back(progCmd.str());
}
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index cfe5e49..faee6ae 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -385,7 +385,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
if (vcprojName) {
cmLocalGenerator* lg = target->GetLocalGenerator();
std::string dir = lg->GetCurrentBinaryDirectory();
- dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT);
+ dir = root->Convert(dir.c_str(), cmOutputConverter::START_OUTPUT);
if (dir == ".") {
dir = ""; // msbuild cannot handle ".\" prefix
}
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index efc239e..a937e9c 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -660,10 +660,10 @@ cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile(
std::string flags;
const char* srcfmt = sf->GetProperty("Fortran_FORMAT");
switch (this->CurrentLocalGenerator->GetFortranFormat(srcfmt)) {
- case cmLocalGenerator::FortranFormatFixed:
+ case cmOutputConverter::FortranFormatFixed:
flags = "-fixed " + flags;
break;
- case cmLocalGenerator::FortranFormatFree:
+ case cmOutputConverter::FortranFormatFree:
flags = "-free " + flags;
break;
default:
@@ -1982,10 +1982,10 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
const char* format = 0;
const char* tgtfmt = gtgt->GetProperty("Fortran_FORMAT");
switch (this->CurrentLocalGenerator->GetFortranFormat(tgtfmt)) {
- case cmLocalGenerator::FortranFormatFixed:
+ case cmOutputConverter::FortranFormatFixed:
format = "fixed";
break;
- case cmLocalGenerator::FortranFormatFree:
+ case cmOutputConverter::FortranFormatFree:
format = "free";
break;
default:
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 0ff13d9..a350f09 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -2140,7 +2140,7 @@ std::string cmLocalGenerator::ConstructComment(
for (std::vector<std::string>::const_iterator o = ccg.GetOutputs().begin();
o != ccg.GetOutputs().end(); ++o) {
comment += sep;
- comment += this->Convert(*o, cmLocalGenerator::START_OUTPUT);
+ comment += this->Convert(*o, cmOutputConverter::START_OUTPUT);
sep = ", ";
}
return comment;
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 892ad4f..5c603a6 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -174,9 +174,10 @@ public:
bool GetRealDependency(const std::string& name, const std::string& config,
std::string& dep);
- virtual std::string ConvertToIncludeReference(std::string const& path,
- OutputFormat format = SHELL,
- bool forceFullPaths = false);
+ virtual std::string ConvertToIncludeReference(
+ std::string const& path,
+ cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL,
+ bool forceFullPaths = false);
/** Called from command-line hook to clear dependencies. */
virtual void ClearDependencies(cmMakefile* /* mf */, bool /* verbose */) {}
@@ -353,8 +354,9 @@ protected:
std::string& CreateSafeUniqueObjectFileName(const std::string& sin,
std::string const& dir_max);
- virtual std::string ConvertToLinkReference(std::string const& lib,
- OutputFormat format = SHELL);
+ virtual std::string ConvertToLinkReference(
+ std::string const& lib,
+ cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL);
/** Check whether the native build system supports the given
definition. Issues a warning. */
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 88c6d61..8cd9c09 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -358,7 +358,7 @@ void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule(
this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName));
}
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
// Write the rule to the makefile.
std::vector<std::string> no_depends;
@@ -398,7 +398,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
commands.push_back(
this->GetRecursiveMakeCall(makefile2.c_str(), localName));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
localName, depends, commands, true);
@@ -423,7 +423,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
commands.push_back(
this->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "fast build rule for target.",
localName, depends, commands, true);
@@ -439,7 +439,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
commands.push_back(
this->GetRecursiveMakeCall(makefile2.c_str(), makeTargetName));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->WriteMakeRule(ruleFileStream,
"Manual pre-install relink rule for target.",
localName, depends, commands, true);
@@ -783,7 +783,7 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
commands.push_back(runRule);
if (!this->IsRootMakefile()) {
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
}
this->WriteMakeRule(
makefileStream, "Special rule to run CMake to check the build system "
@@ -889,7 +889,7 @@ void cmLocalUnixMakefileGenerator3::AppendCustomDepend(
void cmLocalUnixMakefileGenerator3::AppendCustomCommands(
std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs,
- cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative)
+ cmGeneratorTarget* target, cmOutputConverter::RelativeRoot relative)
{
for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i) {
@@ -901,7 +901,7 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommands(
void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target, bool echo_comment,
- cmLocalGenerator::RelativeRoot relative, std::ostream* content)
+ cmOutputConverter::RelativeRoot relative, std::ostream* content)
{
// Optionally create a command to display the custom command's
// comment text. This is used for pre-build, pre-link, and
@@ -1133,8 +1133,8 @@ void cmLocalUnixMakefileGenerator3::AppendEcho(
cmd += color_name;
if (progress) {
cmd += "--progress-dir=";
- cmd += this->Convert(progress->Dir, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ cmd += this->Convert(progress->Dir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
cmd += " ";
cmd += "--progress-num=";
cmd += progress->Arg;
@@ -1544,9 +1544,9 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
this->AppendCustomDepends(depends, gt->GetPreBuildCommands());
this->AppendCustomDepends(depends, gt->GetPostBuildCommands());
this->AppendCustomCommands(commands, gt->GetPreBuildCommands(), gt,
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->AppendCustomCommands(commands, gt->GetPostBuildCommands(), gt,
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
std::string targetName = gt->GetName();
this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName,
depends, commands, true);
@@ -1583,15 +1583,15 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
- progCmd << this->Convert(progressDir, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ progCmd << this->Convert(progressDir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
std::string progressFile = cmake::GetCMakeFilesDirectory();
progressFile += "/progress.marks";
std::string progressFileNameFull = this->ConvertToFullPath(progressFile);
progCmd << " "
- << this->Convert(progressFileNameFull, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ << this->Convert(progressFileNameFull, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
commands.push_back(progCmd.str());
}
std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash();
@@ -1599,12 +1599,12 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
commands.push_back(
this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
- progCmd << this->Convert(progressDir, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ progCmd << this->Convert(progressDir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
progCmd << " 0";
commands.push_back(progCmd.str());
}
@@ -1619,7 +1619,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
commands.push_back(
this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "The main clean target", "clean",
depends, commands, true);
commands.clear();
@@ -1645,7 +1645,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
commands.push_back(
this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
"preinstall", depends, commands, true);
depends.clear();
@@ -1660,12 +1660,12 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system ";
- runRule += this->Convert(cmakefileName, cmLocalGenerator::NONE,
- cmLocalGenerator::SHELL);
+ runRule += this->Convert(cmakefileName, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
runRule += " 1";
commands.push_back(runRule);
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
- cmLocalGenerator::START_OUTPUT);
+ cmOutputConverter::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends,
commands, true);
}
@@ -1832,7 +1832,7 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
cmakefileStream << " \""
- << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT)
+ << this->Convert(*i, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n";
@@ -2031,7 +2031,7 @@ void cmLocalUnixMakefileGenerator3::AddImplicitDepends(
void cmLocalUnixMakefileGenerator3::CreateCDCommand(
std::vector<std::string>& commands, const char* tgtDir,
- cmLocalGenerator::RelativeRoot relRetDir)
+ cmOutputConverter::RelativeRoot relRetDir)
{
const char* retDir = this->GetRelativeRootPath(relRetDir);
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index 321edcb..e0cfeb8 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -120,7 +120,7 @@ public:
// create a command that cds to the start dir then runs the commands
void CreateCDCommand(std::vector<std::string>& commands,
const char* targetDir,
- cmLocalGenerator::RelativeRoot returnDir);
+ cmOutputConverter::RelativeRoot returnDir);
static std::string ConvertToQuotedOutputPath(const char* p,
bool useWatcomQuote);
@@ -230,11 +230,11 @@ protected:
void AppendCustomCommands(
std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs, cmGeneratorTarget* target,
- cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::RelativeRoot relative = cmOutputConverter::HOME_OUTPUT);
void AppendCustomCommand(
std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target, bool echo_comment = false,
- cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT,
+ cmOutputConverter::RelativeRoot relative = cmOutputConverter::HOME_OUTPUT,
std::ostream* content = 0);
void AppendCleanCommand(std::vector<std::string>& commands,
const std::vector<std::string>& files,
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index ad386f7..3e3d90b 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -786,8 +786,8 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
target->GetProperty("Fortran_MODULE_DIRECTORY");
std::string modDir;
if (target_mod_dir) {
- modDir = this->Convert(target_mod_dir, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED);
+ modDir = this->Convert(target_mod_dir, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
} else {
modDir = ".";
}
@@ -1298,8 +1298,8 @@ void cmLocalVisualStudio7GeneratorInternals::OutputLibraries(
for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
if (l->IsPath) {
std::string rel =
- lg->Convert(l->Value.c_str(), cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED);
+ lg->Convert(l->Value.c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
fout << lg->ConvertToXMLOutputPath(rel.c_str()) << " ";
} else if (!l->Target ||
l->Target->GetType() != cmState::INTERFACE_LIBRARY) {
@@ -1319,8 +1319,8 @@ void cmLocalVisualStudio7GeneratorInternals::OutputObjects(
const char* sep = isep ? isep : "";
for (std::vector<std::string>::const_iterator oi = objs.begin();
oi != objs.end(); ++oi) {
- std::string rel = lg->Convert(oi->c_str(), cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED);
+ std::string rel = lg->Convert(oi->c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
fout << sep << lg->ConvertToXMLOutputPath(rel.c_str());
sep = " ";
}
@@ -1472,11 +1472,11 @@ cmLocalVisualStudio7GeneratorFCInfo::cmLocalVisualStudio7GeneratorFCInfo(
}
if (lg->FortranProject) {
switch (lg->GetFortranFormat(sf.GetProperty("Fortran_FORMAT"))) {
- case cmLocalGenerator::FortranFormatFixed:
+ case cmOutputConverter::FortranFormatFixed:
fc.CompileFlags = "-fixed " + fc.CompileFlags;
needfc = true;
break;
- case cmLocalGenerator::FortranFormatFree:
+ case cmOutputConverter::FortranFormatFree:
fc.CompileFlags = "-free " + fc.CompileFlags;
needfc = true;
break;
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 674bc2f..51231fc 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -128,16 +128,16 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
std::string targetFullPathPDB = pdbOutputPath + targetNamePDB;
std::string targetFullPathImport = outpathImp + targetNameImport;
std::string targetOutPathPDB = this->Convert(
- targetFullPathPDB, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
// Convert to the output path to use in constructing commands.
std::string targetOutPath = this->Convert(
- targetFullPath, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL);
+ targetFullPath, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
std::string targetOutPathReal =
- this->Convert(targetFullPathReal, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ this->Convert(targetFullPathReal, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
std::string targetOutPathImport =
- this->Convert(targetFullPathImport, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ this->Convert(targetFullPathImport, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
// Get the language to use for linking this executable.
std::string linkLanguage =
@@ -209,29 +209,30 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// may need to be cleaned.
std::vector<std::string> exeCleanFiles;
exeCleanFiles.push_back(this->Convert(targetFullPath,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
#ifdef _WIN32
// There may be a manifest file for this target. Add it to the
// clean set just in case.
exeCleanFiles.push_back(this->Convert((targetFullPath + ".manifest").c_str(),
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
#endif
if (targetNameReal != targetName) {
exeCleanFiles.push_back(this->Convert(targetFullPathReal,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
if (!targetNameImport.empty()) {
exeCleanFiles.push_back(this->Convert(targetFullPathImport,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
- exeCleanFiles.push_back(this->Convert(
- implib, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED));
+ exeCleanFiles.push_back(this->Convert(implib,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
}
@@ -239,8 +240,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// cleaned. We do not want to delete the .pdb file just before
// linking the target.
this->CleanFiles.push_back(this->Convert(targetFullPathPDB,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
// Add the pre-build and pre-link rules building but not when relinking.
if (!relink) {
@@ -323,14 +324,14 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
vars.Language = linkLanguage.c_str();
vars.Objects = buildObjs.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
- objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ objectDir = this->Convert(objectDir, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
vars.ObjectDir = objectDir.c_str();
- cmLocalGenerator::OutputFormat output = (useWatcomQuote)
- ? cmLocalGenerator::WATCOMQUOTE
- : cmLocalGenerator::SHELL;
- std::string target = this->Convert(targetFullPathReal,
- cmLocalGenerator::START_OUTPUT, output);
+ cmOutputConverter::OutputFormat output = (useWatcomQuote)
+ ? cmOutputConverter::WATCOMQUOTE
+ : cmOutputConverter::SHELL;
+ std::string target = this->Convert(
+ targetFullPathReal, cmOutputConverter::START_OUTPUT, output);
vars.Target = target.c_str();
vars.TargetPDB = targetOutPathPDB.c_str();
@@ -380,7 +381,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
}
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
@@ -393,7 +394,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
commands1.push_back(symlink);
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
}
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 25235ea..7f5bc11 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -301,17 +301,18 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Construct the output path version of the names for use in command
// arguments.
std::string targetOutPathPDB = this->Convert(
- targetFullPathPDB, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
std::string targetOutPath = this->Convert(
- targetFullPath, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL);
- std::string targetOutPathSO = this->Convert(
- targetFullPathSO, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL);
+ targetFullPath, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
+ std::string targetOutPathSO =
+ this->Convert(targetFullPathSO, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
std::string targetOutPathReal =
- this->Convert(targetFullPathReal, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ this->Convert(targetFullPathReal, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
std::string targetOutPathImport =
- this->Convert(targetFullPathImport, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ this->Convert(targetFullPathImport, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
this->NumberOfProgressActions++;
if (!this->NoRuleMessages) {
@@ -357,27 +358,28 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Clean files associated with this library.
std::vector<std::string> libCleanFiles;
libCleanFiles.push_back(this->Convert(targetFullPath,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
if (targetNameReal != targetName) {
libCleanFiles.push_back(this->Convert(targetFullPathReal,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
if (targetNameSO != targetName && targetNameSO != targetNameReal) {
libCleanFiles.push_back(this->Convert(targetFullPathSO,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
if (!targetNameImport.empty()) {
libCleanFiles.push_back(this->Convert(targetFullPathImport,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
- libCleanFiles.push_back(this->Convert(
- implib, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED));
+ libCleanFiles.push_back(this->Convert(implib,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
}
@@ -385,16 +387,16 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// cleaned. We do not want to delete the .pdb file just before
// linking the target.
this->CleanFiles.push_back(this->Convert(targetFullPathPDB,
- cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
#ifdef _WIN32
// There may be a manifest file for this target. Add it to the
// clean set just in case.
if (this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) {
libCleanFiles.push_back(this->Convert(
- (targetFullPath + ".manifest").c_str(), cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED));
+ (targetFullPath + ".manifest").c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
#endif
@@ -406,7 +408,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
this->GeneratorTarget, "target");
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
}
@@ -525,16 +527,16 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
std::string("/") + this->GeneratorTarget->GetName();
name_of_def_file += ".def";
std::string cmd = cmSystemTools::GetCMakeCommand();
- cmd =
- this->Convert(cmd, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ cmd = this->Convert(cmd, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
cmd += " -E __create_def ";
- cmd += this->Convert(name_of_def_file, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ cmd += this->Convert(name_of_def_file, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
cmd += " ";
std::string objlist_file = name_of_def_file;
objlist_file += ".objs";
- cmd += this->Convert(objlist_file, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ cmd += this->Convert(objlist_file, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
real_link_commands.push_back(cmd);
// create a list of obj files for the -E __create_def to read
cmGeneratedFileStream fout(objlist_file.c_str());
@@ -555,8 +557,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
linkFlags +=
this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
linkFlags +=
- this->Convert(name_of_def_file, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ this->Convert(name_of_def_file, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
linkFlags += " ";
}
}
@@ -588,14 +590,14 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
vars.Language = linkLanguage.c_str();
vars.Objects = buildObjs.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
- objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ objectDir = this->Convert(objectDir, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
vars.ObjectDir = objectDir.c_str();
- cmLocalGenerator::OutputFormat output = (useWatcomQuote)
- ? cmLocalGenerator::WATCOMQUOTE
- : cmLocalGenerator::SHELL;
- std::string target = this->Convert(targetFullPathReal,
- cmLocalGenerator::START_OUTPUT, output);
+ cmOutputConverter::OutputFormat output = (useWatcomQuote)
+ ? cmOutputConverter::WATCOMQUOTE
+ : cmOutputConverter::SHELL;
+ std::string target = this->Convert(
+ targetFullPathReal, cmOutputConverter::START_OUTPUT, output);
vars.Target = target.c_str();
vars.LinkLibraries = linkLibs.c_str();
vars.ObjectsQuoted = buildObjs.c_str();
@@ -620,7 +622,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
} else {
// Convert to a path for the native build tool.
install_name_dir = this->LocalGenerator->Convert(
- install_name_dir, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ install_name_dir, cmOutputConverter::NONE, cmOutputConverter::SHELL);
vars.TargetInstallNameDir = install_name_dir.c_str();
}
}
@@ -707,7 +709,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
}
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
@@ -724,7 +726,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
commands1.push_back(symlink);
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
}
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index e480140..980a49d 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -162,7 +162,7 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
this->CleanFiles.push_back(this->Convert(
- *o, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED));
+ *o, cmOutputConverter::START_OUTPUT, cmOutputConverter::UNCHANGED));
}
}
}
@@ -203,8 +203,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
*this->BuildFileStream
<< "# Include any dependencies generated for this target.\n"
<< this->GlobalGenerator->IncludeDirective << " " << root
- << this->Convert(dependFileNameFull, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE)
+ << this->Convert(dependFileNameFull, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE)
<< "\n\n";
if (!this->NoRuleMessages) {
@@ -213,8 +213,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
<< "# Include the progress variables for this target.\n"
<< this->GlobalGenerator->IncludeDirective << " " << root
<< this->Convert(this->ProgressFileNameFull,
- cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE)
+ cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE)
<< "\n\n";
}
@@ -244,8 +244,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
*this->BuildFileStream
<< "# Include the compile flags for this target's objects.\n"
<< this->GlobalGenerator->IncludeDirective << " " << root
- << this->Convert(this->FlagFileNameFull, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE)
+ << this->Convert(this->FlagFileNameFull, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE)
<< "\n\n";
}
@@ -301,8 +301,8 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
output += "/";
output += cmSystemTools::GetFilenameName(input);
this->Generator->CleanFiles.push_back(
- this->Generator->Convert(output, cmLocalGenerator::START_OUTPUT));
- output = this->Generator->Convert(output, cmLocalGenerator::HOME_OUTPUT);
+ this->Generator->Convert(output, cmOutputConverter::START_OUTPUT));
+ output = this->Generator->Convert(output, cmOutputConverter::HOME_OUTPUT);
// Create a rule to copy the content into the bundle.
std::vector<std::string> depends;
@@ -313,11 +313,11 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
this->Generator->LocalGenerator->AppendEcho(
commands, copyEcho.c_str(), cmLocalUnixMakefileGenerator3::EchoBuild);
std::string copyCommand = "$(CMAKE_COMMAND) -E copy ";
- copyCommand += this->Generator->Convert(input, cmLocalGenerator::NONE,
- cmLocalGenerator::SHELL);
+ copyCommand += this->Generator->Convert(input, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
copyCommand += " ";
- copyCommand += this->Generator->Convert(output, cmLocalGenerator::NONE,
- cmLocalGenerator::SHELL);
+ copyCommand += this->Generator->Convert(output, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
commands.push_back(copyCommand);
this->Generator->LocalGenerator->WriteMakeRule(
*this->Generator->BuildFileStream, 0, output, depends, commands, false);
@@ -381,9 +381,9 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
std::string objFullPath = this->LocalGenerator->GetCurrentBinaryDirectory();
objFullPath += "/";
objFullPath += obj;
- objFullPath = this->Convert(objFullPath, cmLocalGenerator::FULL);
+ objFullPath = this->Convert(objFullPath, cmOutputConverter::FULL);
std::string srcFullPath =
- this->Convert(source.GetFullPath(), cmLocalGenerator::FULL);
+ this->Convert(source.GetFullPath(), cmOutputConverter::FULL);
this->LocalGenerator->AddImplicitDepends(
this->GeneratorTarget, lang, objFullPath.c_str(), srcFullPath.c_str());
}
@@ -453,7 +453,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
// Get the output paths for source and object files.
std::string sourceFile = this->Convert(
- source.GetFullPath(), cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ source.GetFullPath(), cmOutputConverter::NONE, cmOutputConverter::SHELL);
// Construct the build message.
std::vector<std::string> no_commands;
@@ -502,13 +502,13 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
}
targetOutPathReal =
- this->Convert(targetFullPathReal, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
- targetOutPathPDB = this->Convert(targetFullPathPDB, cmLocalGenerator::NONE,
- cmLocalGenerator::SHELL);
+ this->Convert(targetFullPathReal, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
+ targetOutPathPDB = this->Convert(
+ targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
targetOutPathCompilePDB =
- this->Convert(targetFullPathCompilePDB, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ this->Convert(targetFullPathCompilePDB, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
if (this->LocalGenerator->IsMinGWMake() &&
cmHasLiteralSuffix(targetOutPathCompilePDB, "\\")) {
@@ -527,15 +527,15 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
vars.TargetCompilePDB = targetOutPathCompilePDB.c_str();
vars.Source = sourceFile.c_str();
std::string shellObj =
- this->Convert(obj, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ this->Convert(obj, cmOutputConverter::NONE, cmOutputConverter::SHELL);
vars.Object = shellObj.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
- objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ objectDir = this->Convert(objectDir, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
vars.ObjectDir = objectDir.c_str();
std::string objectFileDir = cmSystemTools::GetFilenamePath(obj);
- objectFileDir = this->Convert(objectFileDir, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ objectFileDir = this->Convert(objectFileDir, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::SHELL);
vars.ObjectFileDir = objectFileDir.c_str();
vars.Flags = flags.c_str();
@@ -574,7 +574,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
this->LocalGenerator->ExpandRuleVariables(compileCommand, vars);
std::string workingDirectory = this->LocalGenerator->Convert(
this->LocalGenerator->GetCurrentBinaryDirectory(),
- cmLocalGenerator::FULL);
+ cmOutputConverter::FULL);
compileCommand.replace(compileCommand.find(langFlags), langFlags.size(),
this->GetFlags(lang));
std::string langDefines = std::string("$(") + lang + "_DEFINES)";
@@ -637,7 +637,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
// Change the command working directory to the local build tree.
this->LocalGenerator->CreateCDCommand(
compileCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), compileCommands.begin(),
compileCommands.end());
}
@@ -687,8 +687,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
std::vector<std::string> preprocessCommands;
cmSystemTools::ExpandListArgument(preprocessRule, preprocessCommands);
- std::string shellObjI =
- this->Convert(objI, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ std::string shellObjI = this->Convert(objI, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
vars.PreprocessedSource = shellObjI.c_str();
// Expand placeholders in the commands.
@@ -700,7 +700,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
this->LocalGenerator->CreateCDCommand(
preprocessCommands,
this->LocalGenerator->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), preprocessCommands.begin(),
preprocessCommands.end());
} else {
@@ -735,8 +735,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
std::vector<std::string> assemblyCommands;
cmSystemTools::ExpandListArgument(assemblyRule, assemblyCommands);
- std::string shellObjS =
- this->Convert(objS, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ std::string shellObjS = this->Convert(objS, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
vars.AssemblySource = shellObjS.c_str();
// Expand placeholders in the commands.
@@ -747,7 +747,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
this->LocalGenerator->CreateCDCommand(
assemblyCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
commands.insert(commands.end(), assemblyCommands.begin(),
assemblyCommands.end());
} else {
@@ -836,7 +836,7 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules()
this->GeneratorTarget);
this->LocalGenerator->CreateCDCommand(
commands, this->LocalGenerator->GetCurrentBinaryDirectory(),
- cmLocalGenerator::HOME_OUTPUT);
+ cmOutputConverter::HOME_OUTPUT);
// Write the rule.
this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, cleanTarget,
@@ -879,8 +879,8 @@ bool cmMakefileTargetGenerator::WriteMakeRule(
o != outputs.end(); ++o) {
// Touch the extra output so "make" knows that it was updated,
// but only if the output was acually created.
- std::string const out = this->Convert(*o, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::SHELL);
+ std::string const out = this->Convert(*o, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::SHELL);
std::vector<std::string> output_commands;
bool o_symbolic = false;
@@ -988,7 +988,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
// translation table for the dependency scanning process.
depCmd << "cd " << (this->LocalGenerator->Convert(
this->LocalGenerator->GetBinaryDirectory(),
- cmLocalGenerator::FULL, cmLocalGenerator::SHELL))
+ cmOutputConverter::FULL, cmOutputConverter::SHELL))
<< " && ";
#endif
// Generate a call this signature:
@@ -1003,19 +1003,19 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
depCmd << "$(CMAKE_COMMAND) -E cmake_depends \""
<< this->GlobalGenerator->GetName() << "\" "
<< this->Convert(this->LocalGenerator->GetSourceDirectory(),
- cmLocalGenerator::FULL, cmLocalGenerator::SHELL)
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->LocalGenerator->GetCurrentSourceDirectory(),
- cmLocalGenerator::FULL, cmLocalGenerator::SHELL)
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->LocalGenerator->GetBinaryDirectory(),
- cmLocalGenerator::FULL, cmLocalGenerator::SHELL)
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->LocalGenerator->GetCurrentBinaryDirectory(),
- cmLocalGenerator::FULL, cmLocalGenerator::SHELL)
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
- << this->Convert(this->InfoFileNameFull, cmLocalGenerator::FULL,
- cmLocalGenerator::SHELL);
+ << this->Convert(this->InfoFileNameFull, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
if (this->LocalGenerator->GetColorMakefile()) {
depCmd << " --color=$(COLOR)";
}
@@ -1081,8 +1081,8 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile(
// Now append the actual user-specified commands.
std::ostringstream content;
this->LocalGenerator->AppendCustomCommand(
- commands, ccg, this->GeneratorTarget, false, cmLocalGenerator::HOME_OUTPUT,
- &content);
+ commands, ccg, this->GeneratorTarget, false,
+ cmOutputConverter::HOME_OUTPUT, &content);
// Collect the dependencies.
std::vector<std::string> depends;
@@ -1103,9 +1103,9 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile(
ccg.GetCC().GetImplicitDepends().begin();
idi != ccg.GetCC().GetImplicitDepends().end(); ++idi) {
std::string objFullPath =
- this->Convert(outputs[0], cmLocalGenerator::FULL);
+ this->Convert(outputs[0], cmOutputConverter::FULL);
std::string srcFullPath =
- this->Convert(idi->second, cmLocalGenerator::FULL);
+ this->Convert(idi->second, cmOutputConverter::FULL);
this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, idi->first,
objFullPath.c_str(),
srcFullPath.c_str());
@@ -1161,7 +1161,7 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
- object = this->Convert(*i, cmLocalGenerator::START_OUTPUT);
+ object = this->Convert(*i, cmOutputConverter::START_OUTPUT);
*this->BuildFileStream << " " << lineContinue << "\n"
<< this->Makefile->GetSafeDefinition(
"CMAKE_OBJECT_NAME");
@@ -1195,7 +1195,7 @@ public:
{
// Construct the name of the next object.
this->NextObject = this->LocalGenerator->Convert(
- obj, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::RESPONSE);
+ obj, cmOutputConverter::START_OUTPUT, cmOutputConverter::RESPONSE);
// Roll over to next string if the limit will be exceeded.
if (this->LengthLimit != std::string::npos &&
@@ -1249,8 +1249,8 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule(
std::string buildTargetRuleName = dir;
buildTargetRuleName += relink ? "/preinstall" : "/build";
buildTargetRuleName =
- this->Convert(buildTargetRuleName, cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::UNCHANGED);
+ this->Convert(buildTargetRuleName, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::UNCHANGED);
// Build the list of target outputs to drive.
std::vector<std::string> depends;
@@ -1438,8 +1438,8 @@ void cmMakefileTargetGenerator::CreateLinkScript(
// Create the makefile command to invoke the link script.
std::string link_command = "$(CMAKE_COMMAND) -E cmake_link_script ";
- link_command += this->Convert(linkScriptName, cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::SHELL);
+ link_command += this->Convert(
+ linkScriptName, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
link_command += " --verbose=$(VERBOSE)";
makefile_commands.push_back(link_command);
makefile_depends.push_back(linkScriptName);
@@ -1496,8 +1496,8 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
// Reference the response file.
linkLibs = responseFlag;
- linkLibs +=
- this->Convert(link_rsp, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ linkLibs += this->Convert(link_rsp, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
}
}
@@ -1545,8 +1545,8 @@ void cmMakefileTargetGenerator::CreateObjectLists(
// Reference the response file.
buildObjs += responseFlag;
- buildObjs += this->Convert(objects_rsp, cmLocalGenerator::NONE,
- cmLocalGenerator::SHELL);
+ buildObjs += this->Convert(objects_rsp, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
}
} else if (useLinkScript) {
if (!useArchiveRules) {
diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx
index 697f123..6e44e8f 100644
--- a/Source/cmMakefileUtilityTargetGenerator.cxx
+++ b/Source/cmMakefileUtilityTargetGenerator.cxx
@@ -48,8 +48,8 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
<< "# Include the progress variables for this target.\n"
<< this->GlobalGenerator->IncludeDirective << " " << root
<< this->Convert(this->ProgressFileNameFull,
- cmLocalGenerator::HOME_OUTPUT,
- cmLocalGenerator::MAKERULE)
+ cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::MAKERULE)
<< "\n\n";
}
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index 8d7a892..90022c0 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -255,7 +255,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile)
!this->GetGeneratorTarget()->IsFrameworkOnApple()) {
std::string cmakeCommand =
this->GetLocalGenerator()->ConvertToOutputFormat(
- cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+ cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
if (targetType == cmState::EXECUTABLE)
this->GetGlobalGenerator()->AddRule(
"CMAKE_SYMLINK_EXECUTABLE",
@@ -304,7 +304,7 @@ std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeLinkCmd()
{
std::string cmakeCommand =
this->GetLocalGenerator()->ConvertToOutputFormat(
- cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+ cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
linkCmds.push_back(cmakeCommand + " -E remove $TARGET_FILE");
}
// TODO: Use ARCHIVE_APPEND for archives over a certain size.
@@ -432,7 +432,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
cmLocalNinjaGenerator& localGen = *this->GetLocalGenerator();
vars["TARGET_FILE"] =
- localGen.ConvertToOutputFormat(targetOutputReal, cmLocalGenerator::SHELL);
+ localGen.ConvertToOutputFormat(targetOutputReal, cmOutputConverter::SHELL);
localGen.GetTargetFlags(vars["LINK_LIBRARIES"], vars["FLAGS"],
vars["LINK_FLAGS"], frameworkPath, linkPath,
@@ -445,7 +445,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
name_of_def_file += ".def ";
vars["LINK_FLAGS"] += " /DEF:";
vars["LINK_FLAGS"] += this->GetLocalGenerator()->ConvertToOutputFormat(
- name_of_def_file.c_str(), cmLocalGenerator::SHELL);
+ name_of_def_file.c_str(), cmOutputConverter::SHELL);
}
}
@@ -492,7 +492,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName);
if (!install_dir.empty()) {
vars["INSTALLNAME_DIR"] = localGen.Convert(
- install_dir, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+ install_dir, cmOutputConverter::NONE, cmOutputConverter::SHELL);
}
}
}
@@ -501,7 +501,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
if (!this->TargetNameImport.empty()) {
const std::string impLibPath = localGen.ConvertToOutputFormat(
- targetOutputImplib, cmLocalGenerator::SHELL);
+ targetOutputImplib, cmOutputConverter::SHELL);
vars["TARGET_IMPLIB"] = impLibPath;
EnsureParentDirectoryExists(impLibPath);
if (genTarget.HasImportLibrary()) {
@@ -526,7 +526,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
const std::string objPath = GetGeneratorTarget()->GetSupportDirectory();
vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
- this->ConvertToNinjaPath(objPath), cmLocalGenerator::SHELL);
+ this->ConvertToNinjaPath(objPath), cmOutputConverter::SHELL);
EnsureDirectoryExists(objPath);
if (this->GetGlobalGenerator()->IsGCCOnWindows()) {
@@ -565,20 +565,20 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
if (gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) {
std::string cmakeCommand =
this->GetLocalGenerator()->ConvertToOutputFormat(
- cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+ cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
std::string name_of_def_file = gt.GetSupportDirectory();
name_of_def_file += "/" + gt.GetName();
name_of_def_file += ".def";
std::string cmd = cmakeCommand;
cmd += " -E __create_def ";
cmd += this->GetLocalGenerator()->ConvertToOutputFormat(
- name_of_def_file.c_str(), cmLocalGenerator::SHELL);
+ name_of_def_file.c_str(), cmOutputConverter::SHELL);
cmd += " ";
cmNinjaDeps objs = this->GetObjects();
std::string obj_list_file = name_of_def_file;
obj_list_file += ".objs";
cmd += this->GetLocalGenerator()->ConvertToOutputFormat(
- obj_list_file.c_str(), cmLocalGenerator::SHELL);
+ obj_list_file.c_str(), cmOutputConverter::SHELL);
preLinkCmdLines.push_back(cmd);
// create a list of obj files for the -E __create_def to read
cmGeneratedFileStream fout(obj_list_file.c_str());
@@ -593,7 +593,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
// the link commands.
if (!preLinkCmdLines.empty()) {
const std::string homeOutDir = localGen.ConvertToOutputFormat(
- localGen.GetBinaryDirectory(), cmLocalGenerator::SHELL);
+ localGen.GetBinaryDirectory(), cmOutputConverter::SHELL);
preLinkCmdLines.push_back("cd " + homeOutDir);
}
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 4d58242..86db8e0 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -274,10 +274,10 @@ bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(cmNinjaVars& vars) const
}
vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
- ConvertToNinjaPath(pdbPath), cmLocalGenerator::SHELL);
+ ConvertToNinjaPath(pdbPath), cmOutputConverter::SHELL);
vars["TARGET_COMPILE_PDB"] =
this->GetLocalGenerator()->ConvertToOutputFormat(
- ConvertToNinjaPath(compilePdbPath), cmLocalGenerator::SHELL);
+ ConvertToNinjaPath(compilePdbPath), cmOutputConverter::SHELL);
EnsureParentDirectoryExists(pdbPath);
EnsureParentDirectoryExists(compilePdbPath);
@@ -383,7 +383,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
const char* tidy = this->GeneratorTarget->GetProperty(tidy_prop);
if ((iwyu && *iwyu) || (tidy && *tidy)) {
std::string run_iwyu = this->GetLocalGenerator()->ConvertToOutputFormat(
- cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+ cmSystemTools::GetCMakeCommand(), cmOutputConverter::SHELL);
run_iwyu += " -E __run_iwyu";
if (iwyu && *iwyu) {
run_iwyu += " --iwyu=";
@@ -584,9 +584,9 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
EnsureParentDirectoryExists(objectFileName);
vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
- objectDir, cmLocalGenerator::SHELL);
+ objectDir, cmOutputConverter::SHELL);
vars["OBJECT_FILE_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
- objectFileDir, cmLocalGenerator::SHELL);
+ objectFileDir, cmOutputConverter::SHELL);
this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
vars);
@@ -634,7 +634,7 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
}
escapedSourceFileName = this->LocalGenerator->ConvertToOutputFormat(
- escapedSourceFileName, cmLocalGenerator::SHELL);
+ escapedSourceFileName, cmOutputConverter::SHELL);
compileObjectVars.Source = escapedSourceFileName.c_str();
compileObjectVars.Object = objectFileName.c_str();
diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx
index d07341c..f7a7f38 100644
--- a/Source/cmNinjaUtilityTargetGenerator.cxx
+++ b/Source/cmNinjaUtilityTargetGenerator.cxx
@@ -111,14 +111,14 @@ void cmNinjaUtilityTargetGenerator::Generate()
this->GetLocalGenerator()
->ConvertToOutputFormat(
this->GetLocalGenerator()->GetSourceDirectory(),
- cmLocalGenerator::SHELL)
+ cmOutputConverter::SHELL)
.c_str());
cmSystemTools::ReplaceString(
command, "$(CMAKE_BINARY_DIR)",
this->GetLocalGenerator()
->ConvertToOutputFormat(
this->GetLocalGenerator()->GetBinaryDirectory(),
- cmLocalGenerator::SHELL)
+ cmOutputConverter::SHELL)
.c_str());
cmSystemTools::ReplaceString(command, "$(ARGS)", "");
diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index 3d93e69..6121b28 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -2404,8 +2404,8 @@ void cmVisualStudio10TargetGenerator::AddLibraries(
for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
if (l->IsPath) {
std::string path = this->LocalGenerator->Convert(
- l->Value.c_str(), cmLocalGenerator::START_OUTPUT,
- cmLocalGenerator::UNCHANGED);
+ l->Value.c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
this->ConvertToWindowsSlash(path);
libVec.push_back(path);
} else if (!l->Target ||
--
2.8.2
--
Powered by www.kitware.com
Please keep messages on-topic and check the CMake FAQ at:
http://www.cmake.org/Wiki/CMake_FAQ
Kitware offers various services to support the CMake community. For more
information on each offering, please visit:
CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html
Visit other Kitware open-source projects at
http://www.kitware.com/opensource/opensource.html
Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake-developers
