[Cmake-commits] CMake branch, next, updated. v3.6.1-1533-g2b114c4
Stephen Kelly
steveire at gmail.com
Sat Aug 27 08:46:14 EDT 2016
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via 2b114c41b54c4d14745b2b98c57ccc7c92111f7e (commit)
via 1fc076d1fe196d2112da45a6aced04ca39594401 (commit)
from 738e3e9d9af191e7f118e182bb3ba3690430e2af (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=2b114c41b54c4d14745b2b98c57ccc7c92111f7e
commit 2b114c41b54c4d14745b2b98c57ccc7c92111f7e
Merge: 738e3e9 1fc076d
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sat Aug 27 08:46:13 2016 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Sat Aug 27 08:46:13 2016 -0400
Merge topic 'cleanup-Convert' into next
1fc076d1 Revert part of branch
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1fc076d1fe196d2112da45a6aced04ca39594401
commit 1fc076d1fe196d2112da45a6aced04ca39594401
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sat Aug 27 14:45:29 2016 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Sat Aug 27 14:45:45 2016 +0200
Revert part of branch
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
index b433c18..d3f9d64 100644
--- a/Source/cmCommonTargetGenerator.h
+++ b/Source/cmCommonTargetGenerator.h
@@ -57,9 +57,9 @@ protected:
// The windows module definition source file (.def), if any.
cmSourceFile const* ModuleDefinitionFile;
- std::string Convert(std::string const& source,
- cmOutputConverter::RelativeRoot relative,
- cmOutputConverter::OutputFormat output);
+ std::string Convert(
+ 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 928f7ec..18e123e 100644
--- a/Source/cmDependsC.cxx
+++ b/Source/cmDependsC.cxx
@@ -238,8 +238,8 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
// written by the original local generator for this directory
// convert the dependencies to paths relative to the home output
// directory. We must do the same here.
- std::string obj_i = this->LocalGenerator->ConvertToRelativePath(
- obj, cmOutputConverter::HOME_OUTPUT);
+ std::string obj_i =
+ this->LocalGenerator->Convert(obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
obj_i, cmOutputConverter::MAKERULE);
internalDepends << obj_i << std::endl;
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index 8c0acce..c57b558 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -193,15 +193,15 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
stamp += ".mod.stamp";
fcStream << "\n";
fcStream << " \""
- << this->LocalGenerator->ConvertToRelativePath(
+ << this->LocalGenerator->Convert(
mod_lower, cmOutputConverter::START_OUTPUT)
<< "\"\n";
fcStream << " \""
- << this->LocalGenerator->ConvertToRelativePath(
+ << this->LocalGenerator->Convert(
mod_upper, cmOutputConverter::START_OUTPUT)
<< "\"\n";
fcStream << " \""
- << this->LocalGenerator->ConvertToRelativePath(
+ << this->LocalGenerator->Convert(
stamp, cmOutputConverter::START_OUTPUT)
<< "\"\n";
}
@@ -317,8 +317,8 @@ bool cmDependsFortran::WriteDependenciesReal(const char* obj,
const char* src = info.Source.c_str();
// Write the include dependencies to the output stream.
- std::string obj_i = this->LocalGenerator->ConvertToRelativePath(
- obj, cmOutputConverter::HOME_OUTPUT);
+ std::string obj_i =
+ this->LocalGenerator->Convert(obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
obj_i, cmOutputConverter::MAKERULE);
internalDepends << obj_i << std::endl;
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 945ee40..e617b08 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -904,8 +904,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
const std::vector<cmGeneratorTarget*> targets =
(*it)->GetGeneratorTargets();
- std::string subdir = (*it)->ConvertToRelativePath(
- (*it)->GetCurrentBinaryDirectory(), cmOutputConverter::HOME_OUTPUT);
+ std::string subdir = (*it)->Convert((*it)->GetCurrentBinaryDirectory(),
+ cmOutputConverter::HOME_OUTPUT);
if (subdir == ".") {
subdir = "";
}
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 50c5a42..295f65b 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -2547,8 +2547,8 @@ 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.ConvertToRelativePath(
- outputs[0], cmOutputConverter::HOME_OUTPUT);
+ std::string fname =
+ 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 939c5ad..2b83479 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -747,8 +747,7 @@ std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
{
cmLocalNinjaGenerator* ng =
static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
- std::string convPath =
- ng->ConvertToRelativePath(path, cmOutputConverter::HOME_OUTPUT);
+ std::string convPath = ng->Convert(path, cmOutputConverter::HOME_OUTPUT);
convPath = this->NinjaOutputPath(convPath);
#ifdef _WIN32
std::replace(convPath.begin(), convPath.end(), '/', '\\');
@@ -761,8 +760,7 @@ std::string cmGlobalNinjaGenerator::ConvertToNinjaFolderRule(
{
cmLocalNinjaGenerator* ng =
static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
- std::string convPath =
- ng->ConvertToRelativePath(path + "/all", cmOutputConverter::HOME);
+ std::string convPath = ng->Convert(path + "/all", cmOutputConverter::HOME);
convPath = this->NinjaOutputPath(convPath);
#ifdef _WIN32
std::replace(convPath.begin(), convPath.end(), '/', '\\');
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 77fbbe9..f115ecb 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -311,14 +311,11 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream
<< "# The top level Makefile was generated from the following files:\n"
<< "set(CMAKE_MAKEFILE_DEPENDS\n"
- << " \""
- << lg->ConvertToRelativePath(cache, cmOutputConverter::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->ConvertToRelativePath(
- *i, cmOutputConverter::START_OUTPUT)
+ << lg->Convert(*i, cmOutputConverter::START_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@@ -332,12 +329,10 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream << "# The corresponding makefile is:\n"
<< "set(CMAKE_MAKEFILE_OUTPUTS\n"
<< " \""
- << lg->ConvertToRelativePath(makefileName,
- cmOutputConverter::START_OUTPUT)
+ << lg->Convert(makefileName, cmOutputConverter::START_OUTPUT)
<< "\"\n"
<< " \""
- << lg->ConvertToRelativePath(check,
- cmOutputConverter::START_OUTPUT)
+ << lg->Convert(check, cmOutputConverter::START_OUTPUT)
<< "\"\n";
cmakefileStream << " )\n\n";
@@ -350,8 +345,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
for (std::vector<std::string>::const_iterator k = outfiles.begin();
k != outfiles.end(); ++k) {
cmakefileStream << " \""
- << lg->ConvertToRelativePath(
- *k, cmOutputConverter::HOME_OUTPUT)
+ << lg->Convert(*k, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
@@ -364,8 +358,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
tmpStr += cmake::GetCMakeFilesDirectory();
tmpStr += "/CMakeDirectoryInformation.cmake";
cmakefileStream << " \""
- << lg->ConvertToRelativePath(
- tmpStr, cmOutputConverter::HOME_OUTPUT)
+ << lg->Convert(tmpStr, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@@ -526,7 +519,7 @@ void cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
tname += "/fast";
}
cmOutputConverter conv(mf->GetStateSnapshot());
- tname = conv.ConvertToRelativePath(tname, cmOutputConverter::HOME_OUTPUT);
+ tname = conv.Convert(tname, cmOutputConverter::HOME_OUTPUT);
cmSystemTools::ConvertToOutputSlashes(tname);
makeCommand.push_back(tname);
if (this->Makefiles.empty()) {
@@ -723,9 +716,8 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
// # in target
- progCmd << lg->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(progress.Dir),
- cmOutputConverter::SHELL);
+ progCmd << lg->Convert(progress.Dir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
//
std::set<cmGeneratorTarget const*> emitted;
progCmd << " " << this->CountProgressMarksInTarget(gtarget, emitted);
@@ -737,9 +729,8 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
- progCmd << lg->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(progress.Dir),
- cmOutputConverter::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 67ac230..0a83b3a 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -385,8 +385,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
if (vcprojName) {
cmLocalGenerator* lg = target->GetLocalGenerator();
std::string dir = lg->GetCurrentBinaryDirectory();
- dir = root->ConvertToRelativePath(dir.c_str(),
- cmOutputConverter::START_OUTPUT);
+ dir = root->Convert(dir.c_str(), cmOutputConverter::START_OUTPUT);
if (dir == ".") {
dir = ""; // msbuild cannot handle ".\" prefix
}
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 3c5e333..39d9e97 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -402,8 +402,7 @@ void cmListFileBacktrace::PrintTitle(std::ostream& out) const
cmOutputConverter converter(this->Bottom);
cmListFileContext lfc = *this->Cur;
if (!this->Bottom.GetState()->GetIsInTryCompile()) {
- lfc.FilePath =
- converter.ConvertToRelativePath(lfc.FilePath, cmOutputConverter::HOME);
+ lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
}
out << (lfc.Line ? " at " : " in ") << lfc;
}
@@ -428,8 +427,7 @@ void cmListFileBacktrace::PrintCallStack(std::ostream& out) const
}
cmListFileContext lfc = *i;
if (!this->Bottom.GetState()->GetIsInTryCompile()) {
- lfc.FilePath =
- converter.ConvertToRelativePath(lfc.FilePath, cmOutputConverter::HOME);
+ lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
}
out << " " << lfc << "\n";
}
diff --git a/Source/cmLocalCommonGenerator.cxx b/Source/cmLocalCommonGenerator.cxx
index 1383421..5502296 100644
--- a/Source/cmLocalCommonGenerator.cxx
+++ b/Source/cmLocalCommonGenerator.cxx
@@ -74,7 +74,8 @@ std::string cmLocalCommonGenerator::GetTargetFortranFlags(
for (std::vector<std::string>::const_iterator idi = includes.begin();
idi != includes.end(); ++idi) {
std::string flg = modpath_flag;
- flg += this->ConvertToOutputFormat(*idi, cmOutputConverter::SHELL);
+ flg +=
+ this->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL);
this->AppendFlags(flags, flg);
}
}
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index de9e1e5..d8f6bdf 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -176,7 +176,7 @@ void cmLocalGenerator::GenerateTestFiles()
// TODO: Use add_subdirectory instead?
fout << "subdirs(";
std::string outP = children[i].GetDirectory().GetCurrentBinary();
- fout << this->ConvertToRelativePath(outP, START_OUTPUT);
+ fout << this->Convert(outP, START_OUTPUT);
fout << ")" << std::endl;
}
}
@@ -688,9 +688,7 @@ std::string cmLocalGenerator::ExpandRuleVariable(
}
}
if (variable == "CMAKE_COMMAND") {
- return this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(cmSystemTools::GetCMakeCommand()),
- SHELL);
+ return this->Convert(cmSystemTools::GetCMakeCommand(), FULL, SHELL);
}
std::vector<std::string> enabledLanguages =
this->GetState()->GetEnabledLanguages();
@@ -1185,8 +1183,7 @@ void cmLocalGenerator::GetTargetFlags(
if (sf->GetExtension() == "def") {
linkFlags +=
this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
- linkFlags += this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(sf->GetFullPath()), SHELL);
+ linkFlags += this->Convert(sf->GetFullPath(), FULL, SHELL);
linkFlags += " ";
}
}
@@ -1396,7 +1393,7 @@ std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
sp += lib.substr(pos);
// Convert to an output path.
- return this->ConvertToOutputFormat(sp.c_str(), format);
+ return this->Convert(sp.c_str(), NONE, format);
}
}
}
@@ -1492,7 +1489,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
for (std::vector<std::string>::const_iterator fdi = fwDirs.begin();
fdi != fwDirs.end(); ++fdi) {
frameworkPath += fwSearchFlag;
- frameworkPath += this->ConvertToOutputFormat(*fdi, shellFormat);
+ frameworkPath += this->Convert(*fdi, NONE, shellFormat);
frameworkPath += " ";
}
}
@@ -1538,7 +1535,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
for (std::vector<std::string>::iterator ri = runtimeDirs.begin();
ri != runtimeDirs.end(); ++ri) {
rpath += cli.GetRuntimeFlag();
- rpath += this->ConvertToOutputFormat(*ri, shellFormat);
+ rpath += this->Convert(*ri, NONE, shellFormat);
rpath += " ";
}
fout << rpath;
@@ -1608,7 +1605,7 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
flags += " ";
flags += sysrootFlag;
flags += " ";
- flags += this->ConvertToOutputFormat(sysroot, SHELL);
+ flags += this->Convert(sysroot, NONE, SHELL);
}
if (deploymentTargetFlag && *deploymentTargetFlag && deploymentTarget &&
@@ -2240,8 +2237,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->ConvertToRelativePath(*o, cmOutputConverter::START_OUTPUT);
+ comment += this->Convert(*o, cmOutputConverter::START_OUTPUT);
sep = ", ";
}
return comment;
@@ -2509,14 +2505,13 @@ std::string cmLocalGenerator::GetObjectFileNameWithoutTarget(
const char* fullPath = source.GetFullPath().c_str();
// Try referencing the source relative to the source tree.
- std::string relFromSource = this->ConvertToRelativePath(fullPath, START);
+ std::string relFromSource = this->Convert(fullPath, START);
assert(!relFromSource.empty());
bool relSource = !cmSystemTools::FileIsFullPath(relFromSource.c_str());
bool subSource = relSource && relFromSource[0] != '.';
// Try referencing the source relative to the binary tree.
- std::string relFromBinary =
- this->ConvertToRelativePath(fullPath, START_OUTPUT);
+ std::string relFromBinary = this->Convert(fullPath, START_OUTPUT);
assert(!relFromBinary.empty());
bool relBinary = !cmSystemTools::FileIsFullPath(relFromBinary.c_str());
bool subBinary = relBinary && relFromBinary[0] != '.';
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index d07bfaa..46d7e18 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -41,7 +41,7 @@ void cmLocalNinjaGenerator::Generate()
{
// Compute the path to use when referencing the current output
// directory from the top output directory.
- this->HomeRelativeOutputPath = this->ConvertToRelativePath(
+ this->HomeRelativeOutputPath = this->Convert(
this->GetCurrentBinaryDirectory(), cmOutputConverter::HOME_OUTPUT);
if (this->HomeRelativeOutputPath == ".") {
this->HomeRelativeOutputPath = "";
@@ -132,11 +132,9 @@ std::string cmLocalNinjaGenerator::ConvertToIncludeReference(
std::string const& path, cmOutputConverter::OutputFormat format,
bool forceFullPaths)
{
- if (forceFullPaths) {
- return this->ConvertToOutputFormat(cmSystemTools::CollapseFullPath(path),
- format);
- }
- return this->Convert(path, cmOutputConverter::HOME_OUTPUT, format);
+ return this->Convert(path, forceFullPaths ? cmOutputConverter::FULL
+ : cmOutputConverter::HOME_OUTPUT,
+ format);
}
// Private methods.
@@ -488,13 +486,12 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
std::string output;
const std::vector<std::string>& outputs = ccg.GetOutputs();
if (!outputs.empty()) {
- if (ccg.GetWorkingDirectory().empty()) {
- output = this->Convert(outputs[0], cmOutputConverter::START_OUTPUT,
- cmOutputConverter::SHELL);
- } else {
- output =
- this->ConvertToOutputFormat(outputs[0], cmOutputConverter::SHELL);
- }
+ cmOutputConverter::RelativeRoot relative_root =
+ ccg.GetWorkingDirectory().empty() ? cmOutputConverter::START_OUTPUT
+ : cmOutputConverter::NONE;
+
+ output =
+ this->Convert(outputs[0], relative_root, cmOutputConverter::SHELL);
}
vars.Output = output.c_str();
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 81251f9..b3d601a 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -140,7 +140,7 @@ void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath()
{
// Compute the path to use when referencing the current output
// directory from the top output directory.
- this->HomeRelativeOutputPath = this->ConvertToRelativePath(
+ this->HomeRelativeOutputPath = this->Convert(
this->GetCurrentBinaryDirectory(), cmOutputConverter::HOME_OUTPUT);
if (this->HomeRelativeOutputPath == ".") {
this->HomeRelativeOutputPath = "";
@@ -602,7 +602,8 @@ std::string cmLocalUnixMakefileGenerator3::MaybeConvertWacomShellCommand(
// lines with shell redirection operators.
std::string scmd;
if (cmSystemTools::GetShortPath(cmd, scmd)) {
- return this->ConvertToOutputFormat(scmd, cmOutputConverter::SHELL);
+ return this->Convert(scmd, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
}
}
return std::string();
@@ -640,9 +641,9 @@ void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
std::string cmakeShellCommand =
this->MaybeConvertWacomShellCommand(cmSystemTools::GetCMakeCommand());
if (cmakeShellCommand.empty()) {
- cmakeShellCommand = this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(cmSystemTools::GetCMakeCommand()),
- cmOutputConverter::SHELL);
+ cmakeShellCommand =
+ this->Convert(cmSystemTools::GetCMakeCommand(), cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
}
/* clang-format off */
@@ -665,14 +666,16 @@ void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
makefileStream
<< "# The top-level source directory on which CMake was run.\n"
<< "CMAKE_SOURCE_DIR = "
- << this->ConvertToOutputFormat(cmSystemTools::CollapseFullPath(this->GetSourceDirectory()),
+ << this->Convert(this->GetSourceDirectory(),
+ cmOutputConverter::FULL,
cmOutputConverter::SHELL)
<< "\n"
<< "\n";
makefileStream
<< "# The top-level build directory on which CMake was run.\n"
<< "CMAKE_BINARY_DIR = "
- << this->ConvertToOutputFormat(cmSystemTools::CollapseFullPath(this->GetBinaryDirectory()),
+ << this->Convert(this->GetBinaryDirectory(),
+ cmOutputConverter::FULL,
cmOutputConverter::SHELL)
<< "\n"
<< "\n";
@@ -787,8 +790,8 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system ";
- runRule +=
- this->ConvertToOutputFormat(cmakefileName, cmOutputConverter::SHELL);
+ runRule += this->Convert(cmakefileName, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
runRule += " 0";
std::vector<std::string> no_depends;
@@ -964,8 +967,7 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
// working directory will be the start-output directory.
bool had_slash = cmd.find('/') != cmd.npos;
if (workingDir.empty()) {
- cmd =
- this->ConvertToRelativePath(cmd, cmOutputConverter::START_OUTPUT);
+ cmd = this->Convert(cmd, cmOutputConverter::START_OUTPUT);
}
bool has_slash = cmd.find('/') != cmd.npos;
if (had_slash && !has_slash) {
@@ -974,37 +976,9 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
// without the current directory being in the search path.
cmd = "./" + cmd;
}
-
- std::string launcher;
- // Short-circuit if there is no launcher.
- const char* prop = "RULE_LAUNCH_CUSTOM";
- const char* val = this->GetRuleLauncher(target, prop);
- if (val && *val) {
- // Expand rules in the empty string. It may insert the launcher and
- // perform replacements.
- RuleVariables vars;
- vars.RuleLauncher = prop;
- vars.CMTarget = target;
- std::string output;
- const std::vector<std::string>& outputs = ccg.GetOutputs();
- if (!outputs.empty()) {
- if (workingDir.empty()) {
- output = this->Convert(outputs[0], cmOutputConverter::START_OUTPUT,
- cmOutputConverter::SHELL);
-
- } else {
- output = this->ConvertToOutputFormat(outputs[0],
- cmOutputConverter::SHELL);
- }
- }
- vars.Output = output.c_str();
-
- this->ExpandRuleVariables(launcher, vars);
- if (!launcher.empty()) {
- launcher += " ";
- }
- }
-
+ std::string launcher = this->MakeLauncher(
+ ccg, target, workingDir.empty() ? cmOutputConverter::START_OUTPUT
+ : cmOutputConverter::NONE);
std::string shellCommand = this->MaybeConvertWacomShellCommand(cmd);
if (shellCommand.empty()) {
shellCommand = cmd;
@@ -1052,6 +1026,37 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
commands.insert(commands.end(), commands1.begin(), commands1.end());
}
+std::string cmLocalUnixMakefileGenerator3::MakeLauncher(
+ cmCustomCommandGenerator const& ccg, cmGeneratorTarget* target,
+ cmOutputConverter::RelativeRoot relative)
+{
+ // Short-circuit if there is no launcher.
+ const char* prop = "RULE_LAUNCH_CUSTOM";
+ const char* val = this->GetRuleLauncher(target, prop);
+ if (!(val && *val)) {
+ return "";
+ }
+
+ // Expand rules in the empty string. It may insert the launcher and
+ // perform replacements.
+ RuleVariables vars;
+ vars.RuleLauncher = prop;
+ vars.CMTarget = target;
+ std::string output;
+ const std::vector<std::string>& outputs = ccg.GetOutputs();
+ if (!outputs.empty()) {
+ output = this->Convert(outputs[0], relative, cmOutputConverter::SHELL);
+ }
+ vars.Output = output.c_str();
+
+ std::string launcher;
+ this->ExpandRuleVariables(launcher, vars);
+ if (!launcher.empty()) {
+ launcher += " ";
+ }
+ return launcher;
+}
+
void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
std::vector<std::string>& commands, const std::vector<std::string>& files,
cmGeneratorTarget* target, const char* filename)
@@ -1065,7 +1070,8 @@ void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
cleanfile += filename;
}
cleanfile += ".cmake";
- std::string cleanfilePath = cmSystemTools::CollapseFullPath(cleanfile);
+ std::string cleanfilePath =
+ this->Convert(cleanfile, cmOutputConverter::FULL);
cmsys::ofstream fout(cleanfilePath.c_str());
if (!fout) {
cmSystemTools::Error("Could not create ", cleanfilePath.c_str());
@@ -1074,8 +1080,8 @@ void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
fout << "file(REMOVE_RECURSE\n";
for (std::vector<std::string>::const_iterator f = files.begin();
f != files.end(); ++f) {
- std::string fc =
- this->ConvertToRelativePath(*f, cmOutputConverter::START_OUTPUT);
+ std::string fc = this->Convert(*f, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n";
}
fout << ")\n";
@@ -1151,9 +1157,8 @@ void cmLocalUnixMakefileGenerator3::AppendEcho(
cmd += color_name;
if (progress) {
cmd += "--progress-dir=";
- cmd += this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(progress->Dir),
- cmOutputConverter::SHELL);
+ cmd += this->Convert(progress->Dir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
cmd += " ";
cmd += "--progress-num=";
cmd += progress->Arg;
@@ -1601,16 +1606,15 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
- progCmd << this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(progressDir), cmOutputConverter::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->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(progressFileNameFull),
- cmOutputConverter::SHELL);
+ << this->Convert(progressFileNameFull, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
commands.push_back(progCmd.str());
}
std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash();
@@ -1622,8 +1626,8 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
- progCmd << this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(progressDir), cmOutputConverter::SHELL);
+ progCmd << this->Convert(progressDir, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
progCmd << " 0";
commands.push_back(progCmd.str());
}
@@ -1679,8 +1683,8 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system ";
- runRule +=
- this->ConvertToOutputFormat(cmakefileName, cmOutputConverter::SHELL);
+ runRule += this->Convert(cmakefileName, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
runRule += " 1";
commands.push_back(runRule);
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
@@ -1851,8 +1855,7 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
cmakefileStream << " \""
- << this->ConvertToRelativePath(
- *i, cmOutputConverter::HOME_OUTPUT)
+ << this->Convert(*i, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n";
@@ -1894,7 +1897,8 @@ std::string cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall(
// Call make on the given file.
std::string cmd;
cmd += "$(MAKE) -f ";
- cmd += this->ConvertToOutputFormat(makefile, cmOutputConverter::SHELL);
+ cmd +=
+ this->Convert(makefile, cmOutputConverter::NONE, cmOutputConverter::SHELL);
cmd += " ";
cmGlobalUnixMakefileGenerator3* gg =
@@ -1916,8 +1920,7 @@ std::string cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall(
// Add the target.
if (!tgt.empty()) {
// The make target is always relative to the top of the build tree.
- std::string tgt2 =
- this->ConvertToRelativePath(tgt, cmOutputConverter::HOME_OUTPUT);
+ std::string tgt2 = this->Convert(tgt, cmOutputConverter::HOME_OUTPUT);
// The target may have been written with windows paths.
cmSystemTools::ConvertToOutputSlashes(tgt2);
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index bc7566e..9541f65 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -251,6 +251,9 @@ protected:
private:
std::string MaybeConvertWacomShellCommand(std::string const& cmd);
+ std::string MakeLauncher(cmCustomCommandGenerator const& ccg,
+ cmGeneratorTarget* target,
+ cmOutputConverter::RelativeRoot relative);
void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index 70fe819..e72abe9 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -269,8 +269,8 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
args += this->GetBinaryDirectory();
commandLine.push_back(args);
commandLine.push_back("--check-stamp-file");
- std::string stampFilename = this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(stampName), cmOutputConverter::SHELL);
+ std::string stampFilename = this->Convert(
+ stampName.c_str(), cmOutputConverter::FULL, cmOutputConverter::SHELL);
commandLine.push_back(stampFilename.c_str());
std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
@@ -278,8 +278,8 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
cmCustomCommandLines commandLines;
commandLines.push_back(commandLine);
const char* no_working_directory = 0;
- std::string fullpathStampName =
- cmSystemTools::CollapseFullPath(stampName.c_str());
+ std::string fullpathStampName = this->Convert(
+ stampName.c_str(), cmOutputConverter::FULL, cmOutputConverter::UNCHANGED);
this->Makefile->AddCustomCommandToOutput(
fullpathStampName.c_str(), listFiles, makefileIn.c_str(), commandLines,
comment.c_str(), no_working_directory, true);
@@ -788,8 +788,8 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
target->GetProperty("Fortran_MODULE_DIRECTORY");
std::string modDir;
if (target_mod_dir) {
- modDir = this->ConvertToRelativePath(target_mod_dir,
- cmOutputConverter::START_OUTPUT);
+ modDir = this->Convert(target_mod_dir, cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
} else {
modDir = ".";
}
@@ -1300,8 +1300,9 @@ void cmLocalVisualStudio7GeneratorInternals::OutputLibraries(
cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
if (l->IsPath) {
- std::string rel = lg->ConvertToRelativePath(
- l->Value.c_str(), cmOutputConverter::START_OUTPUT);
+ std::string rel =
+ 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) {
@@ -1321,8 +1322,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->ConvertToRelativePath(oi->c_str(), cmOutputConverter::START_OUTPUT);
+ std::string rel = lg->Convert(oi->c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
fout << sep << lg->ConvertToXMLOutputPath(rel.c_str());
sep = " ";
}
@@ -1345,8 +1346,9 @@ void cmLocalVisualStudio7Generator::OutputLibraryDirectories(
// Switch to a relative path specification if it is shorter.
if (cmSystemTools::FileIsFullPath(dir.c_str())) {
- std::string rel = this->ConvertToRelativePath(
- dir.c_str(), cmOutputConverter::START_OUTPUT);
+ std::string rel =
+ this->Convert(dir.c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
if (rel.size() < dir.size()) {
dir = rel;
}
diff --git a/Source/cmLocalVisualStudioGenerator.cxx b/Source/cmLocalVisualStudioGenerator.cxx
index b492962..bdb1c2b 100644
--- a/Source/cmLocalVisualStudioGenerator.cxx
+++ b/Source/cmLocalVisualStudioGenerator.cxx
@@ -127,6 +127,7 @@ std::string cmLocalVisualStudioGenerator::ConstructScript(
{
bool useLocal = this->CustomCommandUseLocal();
std::string workingDirectory = ccg.GetWorkingDirectory();
+ RelativeRoot relativeRoot = workingDirectory.empty() ? START_OUTPUT : NONE;
// Avoid leading or trailing newlines.
std::string newline = "";
@@ -155,8 +156,7 @@ std::string cmLocalVisualStudioGenerator::ConstructScript(
script += newline;
newline = newline_text;
script += "cd ";
- script += this->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(workingDirectory), SHELL);
+ script += this->Convert(workingDirectory, FULL, SHELL);
script += check_error;
// Change the working drive.
@@ -203,11 +203,7 @@ std::string cmLocalVisualStudioGenerator::ConstructScript(
}
}
- if (workingDirectory.empty()) {
- script += this->Convert(cmd.c_str(), START_OUTPUT, SHELL);
- } else {
- script += this->ConvertToOutputFormat(cmd.c_str(), SHELL);
- }
+ script += this->Convert(cmd.c_str(), relativeRoot, SHELL);
ccg.AppendArguments(c, script);
// After each custom command, check for an error result.
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 66e1ca2..74bfedc 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -135,8 +135,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
std::string targetFullPathReal = outpath + targetNameReal;
std::string targetFullPathPDB = pdbOutputPath + targetNamePDB;
std::string targetFullPathImport = outpathImp + targetNameImport;
- std::string targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
- targetFullPathPDB, cmOutputConverter::SHELL);
+ std::string targetOutPathPDB = this->Convert(
+ targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
// Convert to the output path to use in constructing commands.
std::string targetOutPath = this->Convert(
targetFullPath, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
@@ -218,34 +218,40 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// Construct a list of files associated with this executable that
// may need to be cleaned.
std::vector<std::string> exeCleanFiles;
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPath, cmOutputConverter::START_OUTPUT));
+ exeCleanFiles.push_back(this->Convert(targetFullPath,
+ 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->LocalGenerator->ConvertToRelativePath(
- (targetFullPath + ".manifest").c_str(), cmOutputConverter::START_OUTPUT));
+ exeCleanFiles.push_back(this->Convert((targetFullPath + ".manifest").c_str(),
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
#endif
if (targetNameReal != targetName) {
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathReal, cmOutputConverter::START_OUTPUT));
+ exeCleanFiles.push_back(this->Convert(targetFullPathReal,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
if (!targetNameImport.empty()) {
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathImport, cmOutputConverter::START_OUTPUT));
+ exeCleanFiles.push_back(this->Convert(targetFullPathImport,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- implib, cmOutputConverter::START_OUTPUT));
+ exeCleanFiles.push_back(this->Convert(implib,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
}
// List the PDB for cleaning only when the whole target is
// cleaned. We do not want to delete the .pdb file just before
// linking the target.
- this->CleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathPDB, cmOutputConverter::START_OUTPUT));
+ this->CleanFiles.push_back(this->Convert(targetFullPathPDB,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
// Add the pre-build and pre-link rules building but not when relinking.
if (!relink) {
@@ -351,8 +357,9 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
vars.Manifests = manifests.c_str();
if (this->GeneratorTarget->GetProperty("LINK_WHAT_YOU_USE")) {
- std::string cmakeCommand = this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+ std::string cmakeCommand =
+ this->Convert(cmSystemTools::GetCMakeCommand(), cmLocalGenerator::NONE,
+ cmLocalGenerator::SHELL);
cmakeCommand += " -E __run_iwyu --lwyu=";
cmakeCommand += targetOutPathReal;
real_link_commands.push_back(cmakeCommand);
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index b85243e..6727bd0 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -310,8 +310,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Construct the output path version of the names for use in command
// arguments.
- std::string targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
- targetFullPathPDB, cmOutputConverter::SHELL);
+ std::string targetOutPathPDB = this->Convert(
+ targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
std::string targetOutPath = this->Convert(
targetFullPath, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
std::string targetOutPathSO =
@@ -367,40 +367,46 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Clean files associated with this library.
std::vector<std::string> libCleanFiles;
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPath, cmOutputConverter::START_OUTPUT));
+ libCleanFiles.push_back(this->Convert(targetFullPath,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
if (targetNameReal != targetName) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathReal, cmOutputConverter::START_OUTPUT));
+ libCleanFiles.push_back(this->Convert(targetFullPathReal,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
if (targetNameSO != targetName && targetNameSO != targetNameReal) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathSO, cmOutputConverter::START_OUTPUT));
+ libCleanFiles.push_back(this->Convert(targetFullPathSO,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
if (!targetNameImport.empty()) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathImport, cmOutputConverter::START_OUTPUT));
+ libCleanFiles.push_back(this->Convert(targetFullPathImport,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- implib, cmOutputConverter::START_OUTPUT));
+ libCleanFiles.push_back(this->Convert(implib,
+ cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
}
// List the PDB for cleaning only when the whole target is
// cleaned. We do not want to delete the .pdb file just before
// linking the target.
- this->CleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- targetFullPathPDB, cmOutputConverter::START_OUTPUT));
+ this->CleanFiles.push_back(this->Convert(targetFullPathPDB,
+ 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->ConvertToRelativePath((targetFullPath + ".manifest").c_str(),
- cmOutputConverter::START_OUTPUT));
+ libCleanFiles.push_back(this->Convert(
+ (targetFullPath + ".manifest").c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED));
}
#endif
@@ -566,8 +572,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
vars.TargetInstallNameDir = "";
} else {
// Convert to a path for the native build tool.
- install_name_dir = this->LocalGenerator->ConvertToOutputFormat(
- install_name_dir, cmOutputConverter::SHELL);
+ install_name_dir = this->LocalGenerator->Convert(
+ install_name_dir, cmOutputConverter::NONE, cmOutputConverter::SHELL);
vars.TargetInstallNameDir = install_name_dir.c_str();
}
}
@@ -634,8 +640,9 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
if (this->GeneratorTarget->GetProperty("LINK_WHAT_YOU_USE") &&
(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY)) {
- std::string cmakeCommand = this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+ std::string cmakeCommand =
+ this->Convert(cmSystemTools::GetCMakeCommand(),
+ cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
cmakeCommand += " -E __run_iwyu --lwyu=";
cmakeCommand += targetOutPathReal;
real_link_commands.push_back(cmakeCommand);
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index 165f96c..5bba29c 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -172,8 +172,8 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
const std::vector<std::string>& outputs = ccg.GetOutputs();
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
- this->CleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
- *o, cmOutputConverter::START_OUTPUT));
+ this->CleanFiles.push_back(this->Convert(
+ *o, cmOutputConverter::START_OUTPUT, cmOutputConverter::UNCHANGED));
}
}
}
@@ -312,10 +312,8 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
output += "/";
output += cmSystemTools::GetFilenameName(input);
this->Generator->CleanFiles.push_back(
- this->Generator->LocalGenerator->ConvertToRelativePath(
- output, cmOutputConverter::START_OUTPUT));
- output = this->Generator->LocalGenerator->ConvertToRelativePath(
- output, cmOutputConverter::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;
@@ -326,11 +324,11 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
this->Generator->LocalGenerator->AppendEcho(
commands, copyEcho, cmLocalUnixMakefileGenerator3::EchoBuild);
std::string copyCommand = "$(CMAKE_COMMAND) -E copy ";
- copyCommand += this->Generator->LocalGenerator->ConvertToOutputFormat(
- input, cmOutputConverter::SHELL);
+ copyCommand += this->Generator->Convert(input, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
copyCommand += " ";
- copyCommand += this->Generator->LocalGenerator->ConvertToOutputFormat(
- output, cmOutputConverter::SHELL);
+ copyCommand += this->Generator->Convert(output, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
commands.push_back(copyCommand);
this->Generator->LocalGenerator->WriteMakeRule(
*this->Generator->BuildFileStream, CM_NULLPTR, output, depends, commands,
@@ -395,9 +393,9 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
std::string objFullPath = this->LocalGenerator->GetCurrentBinaryDirectory();
objFullPath += "/";
objFullPath += obj;
- objFullPath = cmSystemTools::CollapseFullPath(objFullPath);
+ objFullPath = this->Convert(objFullPath, cmOutputConverter::FULL);
std::string srcFullPath =
- cmSystemTools::CollapseFullPath(source.GetFullPath());
+ this->Convert(source.GetFullPath(), cmOutputConverter::FULL);
this->LocalGenerator->AddImplicitDepends(
this->GeneratorTarget, lang, objFullPath.c_str(), srcFullPath.c_str());
}
@@ -466,8 +464,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
}
// Get the output paths for source and object files.
- std::string sourceFile = this->LocalGenerator->ConvertToOutputFormat(
- source.GetFullPath(), cmOutputConverter::SHELL);
+ std::string sourceFile = this->Convert(
+ source.GetFullPath(), cmOutputConverter::NONE, cmOutputConverter::SHELL);
// Construct the build message.
std::vector<std::string> no_commands;
@@ -518,8 +516,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
targetOutPathReal =
this->Convert(targetFullPathReal, cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);
- targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
- targetFullPathPDB, cmOutputConverter::SHELL);
+ targetOutPathPDB = this->Convert(
+ targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
targetOutPathCompilePDB =
this->Convert(targetFullPathCompilePDB, cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);
@@ -541,7 +539,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
vars.TargetCompilePDB = targetOutPathCompilePDB.c_str();
vars.Source = sourceFile.c_str();
std::string shellObj =
- this->LocalGenerator->ConvertToOutputFormat(obj, cmOutputConverter::SHELL);
+ this->Convert(obj, cmOutputConverter::NONE, cmOutputConverter::SHELL);
vars.Object = shellObj.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
objectDir = this->Convert(objectDir, cmOutputConverter::START_OUTPUT,
@@ -586,8 +584,9 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
lang_can_export_cmds && compileCommands.size() == 1) {
std::string compileCommand = compileCommands[0];
this->LocalGenerator->ExpandRuleVariables(compileCommand, vars);
- std::string workingDirectory = cmSystemTools::CollapseFullPath(
- this->LocalGenerator->GetCurrentBinaryDirectory());
+ std::string workingDirectory = this->LocalGenerator->Convert(
+ this->LocalGenerator->GetCurrentBinaryDirectory(),
+ cmOutputConverter::FULL);
compileCommand.replace(compileCommand.find(langFlags), langFlags.size(),
this->GetFlags(lang));
std::string langDefines = std::string("$(") + lang + "_DEFINES)";
@@ -700,8 +699,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
std::vector<std::string> preprocessCommands;
cmSystemTools::ExpandListArgument(preprocessRule, preprocessCommands);
- std::string shellObjI = this->LocalGenerator->ConvertToOutputFormat(
- objI, cmOutputConverter::SHELL);
+ std::string shellObjI = this->Convert(objI, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
vars.PreprocessedSource = shellObjI.c_str();
// Expand placeholders in the commands.
@@ -747,8 +746,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
std::vector<std::string> assemblyCommands;
cmSystemTools::ExpandListArgument(assemblyRule, assemblyCommands);
- std::string shellObjS = this->LocalGenerator->ConvertToOutputFormat(
- objS, cmOutputConverter::SHELL);
+ std::string shellObjS = this->Convert(objS, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
vars.AssemblySource = shellObjS.c_str();
// Expand placeholders in the commands.
@@ -1000,10 +999,9 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
// paths. Make sure PWD is set to the original name of the home
// output directory to help cmSystemTools to create the same
// translation table for the dependency scanning process.
- depCmd << "cd " << (this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(
- this->LocalGenerator->GetBinaryDirectory()),
- cmOutputConverter::SHELL))
+ depCmd << "cd " << (this->LocalGenerator->Convert(
+ this->LocalGenerator->GetBinaryDirectory(),
+ cmOutputConverter::FULL, cmOutputConverter::SHELL))
<< " && ";
#endif
// Generate a call this signature:
@@ -1017,29 +1015,20 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
// the state of our local generator sufficiently for its needs.
depCmd << "$(CMAKE_COMMAND) -E cmake_depends \""
<< this->GlobalGenerator->GetName() << "\" "
- << this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(
- this->LocalGenerator->GetSourceDirectory()),
- cmOutputConverter::SHELL)
+ << this->Convert(this->LocalGenerator->GetSourceDirectory(),
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
- << this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(
- this->LocalGenerator->GetCurrentSourceDirectory()),
- cmOutputConverter::SHELL)
+ << this->Convert(this->LocalGenerator->GetCurrentSourceDirectory(),
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
- << this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(
- this->LocalGenerator->GetBinaryDirectory()),
- cmOutputConverter::SHELL)
+ << this->Convert(this->LocalGenerator->GetBinaryDirectory(),
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
- << this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(
- this->LocalGenerator->GetCurrentBinaryDirectory()),
- cmOutputConverter::SHELL)
+ << this->Convert(this->LocalGenerator->GetCurrentBinaryDirectory(),
+ cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< " "
- << this->LocalGenerator->ConvertToOutputFormat(
- cmSystemTools::CollapseFullPath(this->InfoFileNameFull),
- cmOutputConverter::SHELL);
+ << this->Convert(this->InfoFileNameFull, cmOutputConverter::FULL,
+ cmOutputConverter::SHELL);
if (this->LocalGenerator->GetColorMakefile()) {
depCmd << " --color=$(COLOR)";
}
@@ -1126,8 +1115,10 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile(
for (cmCustomCommand::ImplicitDependsList::const_iterator idi =
ccg.GetCC().GetImplicitDepends().begin();
idi != ccg.GetCC().GetImplicitDepends().end(); ++idi) {
- std::string objFullPath = cmSystemTools::CollapseFullPath(outputs[0]);
- std::string srcFullPath = cmSystemTools::CollapseFullPath(idi->second);
+ std::string objFullPath =
+ this->Convert(outputs[0], cmOutputConverter::FULL);
+ std::string srcFullPath =
+ this->Convert(idi->second, cmOutputConverter::FULL);
this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, idi->first,
objFullPath.c_str(),
srcFullPath.c_str());
@@ -1183,8 +1174,7 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
- object = this->LocalGenerator->ConvertToRelativePath(
- *i, cmOutputConverter::START_OUTPUT);
+ object = this->Convert(*i, cmOutputConverter::START_OUTPUT);
*this->BuildFileStream << " " << lineContinue << "\n"
<< this->Makefile->GetSafeDefinition(
"CMAKE_OBJECT_NAME");
@@ -1271,8 +1261,9 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule(
this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
std::string buildTargetRuleName = dir;
buildTargetRuleName += relink ? "/preinstall" : "/build";
- buildTargetRuleName = this->LocalGenerator->ConvertToRelativePath(
- buildTargetRuleName, cmOutputConverter::HOME_OUTPUT);
+ buildTargetRuleName =
+ this->Convert(buildTargetRuleName, cmOutputConverter::HOME_OUTPUT,
+ cmOutputConverter::UNCHANGED);
// Build the list of target outputs to drive.
std::vector<std::string> depends;
@@ -1585,8 +1576,8 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
// Reference the response file.
linkLibs = responseFlag;
- linkLibs += this->LocalGenerator->ConvertToOutputFormat(
- link_rsp, cmOutputConverter::SHELL);
+ linkLibs += this->Convert(link_rsp, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
}
}
@@ -1634,8 +1625,8 @@ void cmMakefileTargetGenerator::CreateObjectLists(
// Reference the response file.
buildObjs += responseFlag;
- buildObjs += this->LocalGenerator->ConvertToOutputFormat(
- objects_rsp, cmOutputConverter::SHELL);
+ buildObjs += this->Convert(objects_rsp, cmOutputConverter::NONE,
+ cmOutputConverter::SHELL);
}
} else if (useLinkScript) {
if (!useArchiveRules) {
@@ -1692,8 +1683,8 @@ void cmMakefileTargetGenerator::GenDefFile(
name_of_def_file += std::string("/") + this->GeneratorTarget->GetName();
name_of_def_file += ".def";
std::string cmd = cmSystemTools::GetCMakeCommand();
- cmd = this->LocalGenerator->ConvertToOutputFormat(
- cmd, cmOutputConverter::SHELL);
+ cmd =
+ this->Convert(cmd, cmOutputConverter::NONE, cmOutputConverter::SHELL);
cmd += " -E __create_def ";
cmd += this->Convert(name_of_def_file, cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index 335b552..d0db133 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -543,8 +543,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
std::string install_dir =
this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName);
if (!install_dir.empty()) {
- vars["INSTALLNAME_DIR"] = localGen.ConvertToOutputFormat(
- install_dir, cmOutputConverter::SHELL);
+ vars["INSTALLNAME_DIR"] = localGen.Convert(
+ install_dir, cmOutputConverter::NONE, cmOutputConverter::SHELL);
}
}
}
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 630da42..98872d6 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -46,40 +46,38 @@ std::string cmOutputConverter::ConvertToOutputForExisting(
return this->ConvertToOutputFormat(remote, format);
}
-std::string cmOutputConverter::ConvertToRelativePath(
- const std::string& source, RelativeRoot relative) const
+std::string cmOutputConverter::Convert(const std::string& source,
+ RelativeRoot relative,
+ OutputFormat output) const
{
- std::string result;
+ // Convert the path to a relative path.
+ std::string result = source;
switch (relative) {
case HOME:
result = this->ConvertToRelativePath(
- this->GetState()->GetSourceDirectoryComponents(), source);
+ this->GetState()->GetSourceDirectoryComponents(), result);
break;
case START:
result = this->ConvertToRelativePath(
this->StateSnapshot.GetDirectory().GetCurrentSourceComponents(),
- source);
+ result);
break;
case HOME_OUTPUT:
result = this->ConvertToRelativePath(
- this->GetState()->GetBinaryDirectoryComponents(), source);
+ this->GetState()->GetBinaryDirectoryComponents(), result);
break;
case START_OUTPUT:
result = this->ConvertToRelativePath(
this->StateSnapshot.GetDirectory().GetCurrentBinaryComponents(),
- source);
+ result);
+ break;
+ case FULL:
+ result = cmSystemTools::CollapseFullPath(result);
+ break;
+ case NONE:
break;
}
- return result;
-}
-
-std::string cmOutputConverter::Convert(const std::string& source,
- RelativeRoot relative,
- OutputFormat output) const
-{
- // Convert the path to a relative path.
- std::string result = this->ConvertToRelativePath(source, relative);
return this->ConvertToOutputFormat(result, output);
}
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index 9af9659..ff06ab6 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -38,6 +38,8 @@ public:
*/
enum RelativeRoot
{
+ NONE,
+ FULL,
HOME,
START,
HOME_OUTPUT,
@@ -45,6 +47,7 @@ public:
};
enum OutputFormat
{
+ UNCHANGED,
MAKERULE,
SHELL,
WATCOMQUOTE,
@@ -53,9 +56,7 @@ public:
std::string ConvertToOutputFormat(const std::string& source,
OutputFormat output) const;
std::string Convert(const std::string& remote, RelativeRoot local,
- OutputFormat output) const;
- std::string ConvertToRelativePath(const std::string& remote,
- RelativeRoot local) const;
+ OutputFormat output = UNCHANGED) const;
std::string ConvertDirectorySeparatorsForShell(
const std::string& source) const;
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index d5274cd..ed04d2f 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -602,8 +602,7 @@ void cmTarget::GetTllSignatureTraces(std::ostream& s, TLLSignature sig) const
it != this->TLLCommands.end(); ++it) {
if (it->first == sig) {
cmListFileContext lfc = it->second;
- lfc.FilePath =
- converter.ConvertToRelativePath(lfc.FilePath, cmOutputConverter::HOME);
+ lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
s << " * " << lfc << std::endl;
}
}
diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index 216de03..1b1d04b 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -2416,8 +2416,9 @@ void cmVisualStudio10TargetGenerator::AddLibraries(
ItemVector libs = cli.GetItems();
for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
if (l->IsPath) {
- std::string path = this->LocalGenerator->ConvertToRelativePath(
- l->Value.c_str(), cmOutputConverter::START_OUTPUT);
+ std::string path = this->LocalGenerator->Convert(
+ l->Value.c_str(), cmOutputConverter::START_OUTPUT,
+ cmOutputConverter::UNCHANGED);
this->ConvertToWindowsSlash(path);
libVec.push_back(path);
} else if (!l->Target ||
-----------------------------------------------------------------------
Summary of changes:
Source/cmCommonTargetGenerator.h | 6 +-
Source/cmDependsC.cxx | 4 +-
Source/cmDependsFortran.cxx | 10 +-
Source/cmExtraEclipseCDT4Generator.cxx | 4 +-
Source/cmGlobalGenerator.cxx | 4 +-
Source/cmGlobalNinjaGenerator.cxx | 6 +-
Source/cmGlobalUnixMakefileGenerator3.cxx | 31 ++----
Source/cmGlobalVisualStudio7Generator.cxx | 3 +-
Source/cmListFileCache.cxx | 6 +-
Source/cmLocalCommonGenerator.cxx | 3 +-
Source/cmLocalGenerator.cxx | 25 ++---
Source/cmLocalNinjaGenerator.cxx | 23 ++---
Source/cmLocalUnixMakefileGenerator3.cxx | 127 ++++++++++++------------
Source/cmLocalUnixMakefileGenerator3.h | 3 +
Source/cmLocalVisualStudio7Generator.cxx | 26 ++---
Source/cmLocalVisualStudioGenerator.cxx | 10 +-
Source/cmMakefileExecutableTargetGenerator.cxx | 39 +++++---
Source/cmMakefileLibraryTargetGenerator.cxx | 49 +++++----
Source/cmMakefileTargetGenerator.cxx | 107 +++++++++-----------
Source/cmNinjaNormalTargetGenerator.cxx | 4 +-
Source/cmOutputConverter.cxx | 30 +++---
Source/cmOutputConverter.h | 7 +-
Source/cmTarget.cxx | 3 +-
Source/cmVisualStudio10TargetGenerator.cxx | 5 +-
24 files changed, 261 insertions(+), 274 deletions(-)
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list