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

Merge topic 'cleanup-Convert' 

4332131d Convert: Make variables a bit more clear
5aca066c Convert: Remove UNCHANGED enum value
146bf926 Convert: Remove 'FULL' conversion
58ba87f8 Convert: Replace Convert(FULL) with equivalent
e80314d7 Ninja: Replace ternary with if()
563ac22a Convert: Replace trivial conversion with new method
08be47cf Convert: Replace UNCHANGED conversions with new API call
564d3a1d Convert: Extract ConvertToRelativePath from Convert()
95a659f1 Convert: Replace FULL conversions with equivalent
a8c7ccb1 VS: Replace FULL/UNCHANGED conversion with equivalent
5ad25ef4 Convert: Remove NONE conversion
ac463841 Convert: Replace uses of Convert(NONE)
998d9ee9 VS: Replace variable with an if()
ee49f006 Makefiles: Replace ternaries with if()s
51f7dcb0 Makefiles: Inline MakeLauncher into only caller
ba4ba7c3 Makefiles: Simplify MakeLauncher return value
...
This commit is contained in:
Brad King 2016-08-30 09:29:53 -04:00 committed by CMake Topic Stage
parent ef58e97362 4332131dcc
commit e3a4c2e02c
25 changed files with 346 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/cmCommonTargetGenerator.h
View File

@ -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 = cmOutputConverter::UNCHANGED);
std::string Convert(std::string const& source,
cmOutputConverter::RelativeRoot relative,
cmOutputConverter::OutputFormat output);
void AppendFortranFormatFlags(std::string& flags,
cmSourceFile const& source);

4
Source/cmDependsC.cxx
View File

@ -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->Convert(obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_i = this->LocalGenerator->ConvertToRelativePath(
obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
obj_i, cmOutputConverter::MAKERULE);
internalDepends << obj_i << std::endl;

10
Source/cmDependsFortran.cxx
View File

@ -193,15 +193,15 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
stamp += ".mod.stamp";
fcStream << "\n";
fcStream << " \""
<< this->LocalGenerator->Convert(
<< this->LocalGenerator->ConvertToRelativePath(
mod_lower, cmOutputConverter::START_OUTPUT)
<< "\"\n";
fcStream << " \""
<< this->LocalGenerator->Convert(
<< this->LocalGenerator->ConvertToRelativePath(
mod_upper, cmOutputConverter::START_OUTPUT)
<< "\"\n";
fcStream << " \""
<< this->LocalGenerator->Convert(
<< this->LocalGenerator->ConvertToRelativePath(
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->Convert(obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_i = this->LocalGenerator->ConvertToRelativePath(
obj, cmOutputConverter::HOME_OUTPUT);
std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
obj_i, cmOutputConverter::MAKERULE);
internalDepends << obj_i << std::endl;

4
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -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)->Convert((*it)->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
std::string subdir = (*it)->ConvertToRelativePath(
(*it)->GetCurrentBinaryDirectory(), cmOutputConverter::HOME_OUTPUT);
if (subdir == ".") {
subdir = "";
}

4
Source/cmGlobalGenerator.cxx
View File

@ -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.Convert(outputs[0], cmOutputConverter::HOME_OUTPUT);
std::string fname = converter.ConvertToRelativePath(
outputs[0], cmOutputConverter::HOME_OUTPUT);
// Associate the hash with this output.
this->RuleHashes[fname] = hash;

6
Source/cmGlobalNinjaGenerator.cxx
View File

@ -749,7 +749,8 @@ std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
{
cmLocalNinjaGenerator* ng =
static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
std::string convPath = ng->Convert(path, cmOutputConverter::HOME_OUTPUT);
std::string convPath =
ng->ConvertToRelativePath(path, cmOutputConverter::HOME_OUTPUT);
convPath = this->NinjaOutputPath(convPath);
#ifdef _WIN32
std::replace(convPath.begin(), convPath.end(), '/', '\\');
@ -762,7 +763,8 @@ std::string cmGlobalNinjaGenerator::ConvertToNinjaFolderRule(
{
cmLocalNinjaGenerator* ng =
static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
std::string convPath = ng->Convert(path + "/all", cmOutputConverter::HOME);
std::string convPath =
ng->ConvertToRelativePath(path + "/all", cmOutputConverter::HOME);
convPath = this->NinjaOutputPath(convPath);
#ifdef _WIN32
std::replace(convPath.begin(), convPath.end(), '/', '\\');

27
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -311,11 +311,14 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream
<< "# The top level Makefile was generated from the following files:\n"
<< "set(CMAKE_MAKEFILE_DEPENDS\n"
<< " \"" << lg->Convert(cache, cmOutputConverter::START_OUTPUT) << "\"\n";
<< " \""
<< lg->ConvertToRelativePath(cache, cmOutputConverter::START_OUTPUT)
<< "\"\n";
for (std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i) {
cmakefileStream << " \""
<< lg->Convert(*i, cmOutputConverter::START_OUTPUT)
<< lg->ConvertToRelativePath(
*i, cmOutputConverter::START_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@ -329,10 +332,12 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream << "# The corresponding makefile is:\n"
<< "set(CMAKE_MAKEFILE_OUTPUTS\n"
<< " \""
<< lg->Convert(makefileName, cmOutputConverter::START_OUTPUT)
<< lg->ConvertToRelativePath(makefileName,
cmOutputConverter::START_OUTPUT)
<< "\"\n"
<< " \""
<< lg->Convert(check, cmOutputConverter::START_OUTPUT)
<< lg->ConvertToRelativePath(check,
cmOutputConverter::START_OUTPUT)
<< "\"\n";
cmakefileStream << " )\n\n";
@ -345,7 +350,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
for (std::vector<std::string>::const_iterator k = outfiles.begin();
k != outfiles.end(); ++k) {
cmakefileStream << " \""
<< lg->Convert(*k, cmOutputConverter::HOME_OUTPUT)
<< lg->ConvertToRelativePath(
*k, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
@ -358,7 +364,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
tmpStr += cmake::GetCMakeFilesDirectory();
tmpStr += "/CMakeDirectoryInformation.cmake";
cmakefileStream << " \""
<< lg->Convert(tmpStr, cmOutputConverter::HOME_OUTPUT)
<< lg->ConvertToRelativePath(
tmpStr, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n\n";
@ -519,7 +526,7 @@ void cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
tname += "/fast";
}
cmOutputConverter conv(mf->GetStateSnapshot());
tname = conv.Convert(tname, cmOutputConverter::HOME_OUTPUT);
tname = conv.ConvertToRelativePath(tname, cmOutputConverter::HOME_OUTPUT);
cmSystemTools::ConvertToOutputSlashes(tname);
makeCommand.push_back(tname);
if (this->Makefiles.empty()) {
@ -716,7 +723,8 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
// # in target
progCmd << lg->Convert(progress.Dir, cmOutputConverter::FULL,
progCmd << lg->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(progress.Dir),
cmOutputConverter::SHELL);
//
std::set<cmGeneratorTarget const*> emitted;
@ -729,7 +737,8 @@ void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
progCmd << lg->Convert(progress.Dir, cmOutputConverter::FULL,
progCmd << lg->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(progress.Dir),
cmOutputConverter::SHELL);
progCmd << " 0";
commands.push_back(progCmd.str());

3
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -385,7 +385,8 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
if (vcprojName) {
cmLocalGenerator* lg = target->GetLocalGenerator();
std::string dir = lg->GetCurrentBinaryDirectory();
dir = root->Convert(dir.c_str(), cmOutputConverter::START_OUTPUT);
dir = root->ConvertToRelativePath(dir.c_str(),
cmOutputConverter::START_OUTPUT);
if (dir == ".") {
dir = ""; // msbuild cannot handle ".\" prefix
}

6
Source/cmListFileCache.cxx
View File

@ -402,7 +402,8 @@ void cmListFileBacktrace::PrintTitle(std::ostream& out) const
cmOutputConverter converter(this->Bottom);
cmListFileContext lfc = *this->Cur;
if (!this->Bottom.GetState()->GetIsInTryCompile()) {
lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
lfc.FilePath =
converter.ConvertToRelativePath(lfc.FilePath, cmOutputConverter::HOME);
}
out << (lfc.Line ? " at " : " in ") << lfc;
}
@ -427,7 +428,8 @@ void cmListFileBacktrace::PrintCallStack(std::ostream& out) const
}
cmListFileContext lfc = *i;
if (!this->Bottom.GetState()->GetIsInTryCompile()) {
lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
lfc.FilePath =
converter.ConvertToRelativePath(lfc.FilePath, cmOutputConverter::HOME);
}
out << " " << lfc << "\n";
}

3
Source/cmLocalCommonGenerator.cxx
View File

@ -74,8 +74,7 @@ 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->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL);
flg += this->ConvertToOutputFormat(*idi, cmOutputConverter::SHELL);
this->AppendFlags(flags, flg);
}
}

25
Source/cmLocalGenerator.cxx
View File

@ -176,7 +176,7 @@ void cmLocalGenerator::GenerateTestFiles()
// TODO: Use add_subdirectory instead?
fout << "subdirs(";
std::string outP = children[i].GetDirectory().GetCurrentBinary();
fout << this->Convert(outP, START_OUTPUT);
fout << this->ConvertToRelativePath(outP, START_OUTPUT);
fout << ")" << std::endl;
}
}
@ -688,7 +688,9 @@ std::string cmLocalGenerator::ExpandRuleVariable(
}
}
if (variable == "CMAKE_COMMAND") {
return this->Convert(cmSystemTools::GetCMakeCommand(), FULL, SHELL);
return this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(cmSystemTools::GetCMakeCommand()),
SHELL);
}
std::vector<std::string> enabledLanguages =
this->GetState()->GetEnabledLanguages();
@ -1183,7 +1185,8 @@ void cmLocalGenerator::GetTargetFlags(
if (sf->GetExtension() == "def") {
linkFlags +=
this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
linkFlags += this->Convert(sf->GetFullPath(), FULL, SHELL);
linkFlags += this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(sf->GetFullPath()), SHELL);
linkFlags += " ";
}
}
@ -1393,7 +1396,7 @@ std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
sp += lib.substr(pos);
// Convert to an output path.
return this->Convert(sp.c_str(), NONE, format);
return this->ConvertToOutputFormat(sp.c_str(), format);
}
}
}
@ -1489,7 +1492,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->Convert(*fdi, NONE, shellFormat);
frameworkPath += this->ConvertToOutputFormat(*fdi, shellFormat);
frameworkPath += " ";
}
}
@ -1535,7 +1538,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->Convert(*ri, NONE, shellFormat);
rpath += this->ConvertToOutputFormat(*ri, shellFormat);
rpath += " ";
}
fout << rpath;
@ -1605,7 +1608,7 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
flags += " ";
flags += sysrootFlag;
flags += " ";
flags += this->Convert(sysroot, NONE, SHELL);
flags += this->ConvertToOutputFormat(sysroot, SHELL);
}
if (deploymentTargetFlag && *deploymentTargetFlag && deploymentTarget &&
@ -2237,7 +2240,8 @@ 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, cmOutputConverter::START_OUTPUT);
comment +=
this->ConvertToRelativePath(*o, cmOutputConverter::START_OUTPUT);
sep = ", ";
}
return comment;
@ -2505,13 +2509,14 @@ std::string cmLocalGenerator::GetObjectFileNameWithoutTarget(
const char* fullPath = source.GetFullPath().c_str();
// Try referencing the source relative to the source tree.
std::string relFromSource = this->Convert(fullPath, START);
std::string relFromSource = this->ConvertToRelativePath(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->Convert(fullPath, START_OUTPUT);
std::string relFromBinary =
this->ConvertToRelativePath(fullPath, START_OUTPUT);
assert(!relFromBinary.empty());
bool relBinary = !cmSystemTools::FileIsFullPath(relFromBinary.c_str());
bool subBinary = relBinary && relFromBinary[0] != '.';

19
Source/cmLocalNinjaGenerator.cxx
View File

@ -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->Convert(
this->HomeRelativeOutputPath = this->ConvertToRelativePath(
this->GetCurrentBinaryDirectory(), cmOutputConverter::HOME_OUTPUT);
if (this->HomeRelativeOutputPath == ".") {
this->HomeRelativeOutputPath = "";
@ -132,10 +132,12 @@ std::string cmLocalNinjaGenerator::ConvertToIncludeReference(
std::string const& path, cmOutputConverter::OutputFormat format,
bool forceFullPaths)
{
return this->Convert(path, forceFullPaths ? cmOutputConverter::FULL
: cmOutputConverter::HOME_OUTPUT,
if (forceFullPaths) {
return this->ConvertToOutputFormat(cmSystemTools::CollapseFullPath(path),
format);
}
return this->Convert(path, cmOutputConverter::HOME_OUTPUT, format);
}
// Private methods.
@ -487,12 +489,13 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
std::string output;
const std::vector<std::string>& outputs = ccg.GetOutputs();
if (!outputs.empty()) {
cmOutputConverter::RelativeRoot relative_root =
ccg.GetWorkingDirectory().empty() ? cmOutputConverter::START_OUTPUT
: cmOutputConverter::NONE;
if (ccg.GetWorkingDirectory().empty()) {
output = this->Convert(outputs[0], cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);
} else {
output =
this->Convert(outputs[0], relative_root, cmOutputConverter::SHELL);
this->ConvertToOutputFormat(outputs[0], cmOutputConverter::SHELL);
}
}
vars.Output = output.c_str();

187
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -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->Convert(
this->HomeRelativeOutputPath = this->ConvertToRelativePath(
this->GetCurrentBinaryDirectory(), cmOutputConverter::HOME_OUTPUT);
if (this->HomeRelativeOutputPath == ".") {
this->HomeRelativeOutputPath = "";
@ -358,7 +358,7 @@ void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule(
this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName));
}
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
// 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(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
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(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
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(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
this->WriteMakeRule(ruleFileStream,
"Manual pre-install relink rule for target.",
localName, depends, commands, true);
@ -592,8 +592,8 @@ void cmLocalUnixMakefileGenerator3::WriteMakeRule(
}
}
std::string cmLocalUnixMakefileGenerator3::ConvertShellCommand(
std::string const& cmd, cmOutputConverter::RelativeRoot root)
std::string cmLocalUnixMakefileGenerator3::MaybeConvertWatcomShellCommand(
std::string const& cmd)
{
if (this->IsWatcomWMake() && cmSystemTools::FileIsFullPath(cmd.c_str()) &&
cmd.find_first_of("( )") != cmd.npos) {
@ -602,11 +602,10 @@ std::string cmLocalUnixMakefileGenerator3::ConvertShellCommand(
// lines with shell redirection operators.
std::string scmd;
if (cmSystemTools::GetShortPath(cmd, scmd)) {
return this->Convert(scmd, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
return this->ConvertToOutputFormat(scmd, cmOutputConverter::SHELL);
}
}
return this->Convert(cmd, root, cmOutputConverter::SHELL);
return std::string();
}
void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
@ -638,19 +637,25 @@ void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
#endif
}
std::string cmakeShellCommand =
this->MaybeConvertWatcomShellCommand(cmSystemTools::GetCMakeCommand());
if (cmakeShellCommand.empty()) {
cmakeShellCommand = this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(cmSystemTools::GetCMakeCommand()),
cmOutputConverter::SHELL);
}
/* clang-format off */
makefileStream
<< "# The CMake executable.\n"
<< "CMAKE_COMMAND = "
<< this->ConvertShellCommand(cmSystemTools::GetCMakeCommand(),
cmOutputConverter::FULL)
<< cmakeShellCommand
<< "\n"
<< "\n";
makefileStream
<< "# The command to remove a file.\n"
<< "RM = "
<< this->ConvertShellCommand(cmSystemTools::GetCMakeCommand(),
cmOutputConverter::FULL)
<< cmakeShellCommand
<< " -E remove -f\n"
<< "\n";
makefileStream
@ -660,16 +665,16 @@ void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
makefileStream
<< "# The top-level source directory on which CMake was run.\n"
<< "CMAKE_SOURCE_DIR = "
<< this->Convert(this->GetSourceDirectory(),
cmOutputConverter::FULL,
<< this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(this->GetSourceDirectory()),
cmOutputConverter::SHELL)
<< "\n"
<< "\n";
makefileStream
<< "# The top-level build directory on which CMake was run.\n"
<< "CMAKE_BINARY_DIR = "
<< this->Convert(this->GetBinaryDirectory(),
cmOutputConverter::FULL,
<< this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(this->GetBinaryDirectory()),
cmOutputConverter::SHELL)
<< "\n"
<< "\n";
@ -784,8 +789,8 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
std::string runRule =
"$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
runRule += " --check-build-system ";
runRule += this->Convert(cmakefileName, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
runRule +=
this->ConvertToOutputFormat(cmakefileName, cmOutputConverter::SHELL);
runRule += " 0";
std::vector<std::string> no_depends;
@ -793,7 +798,7 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
commands.push_back(runRule);
if (!this->IsRootMakefile()) {
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
}
this->WriteMakeRule(
makefileStream, "Special rule to run CMake to check the build system "
@ -829,8 +834,7 @@ std::string cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory(
{
std::string dir = this->HomeRelativeOutputPath;
dir += this->GetTargetDirectory(target);
return this->Convert(dir, cmOutputConverter::NONE,
cmOutputConverter::UNCHANGED);
return dir;
}
void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
@ -900,19 +904,19 @@ void cmLocalUnixMakefileGenerator3::AppendCustomDepend(
void cmLocalUnixMakefileGenerator3::AppendCustomCommands(
std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs,
cmGeneratorTarget* target, cmOutputConverter::RelativeRoot relative)
cmGeneratorTarget* target, std::string const& relative)
{
for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i) {
cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
this->AppendCustomCommand(commands, ccg, target, true, relative);
this->AppendCustomCommand(commands, ccg, target, relative, true);
}
}
void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target, bool echo_comment,
cmOutputConverter::RelativeRoot relative, std::ostream* content)
cmGeneratorTarget* target, std::string const& relative, bool echo_comment,
std::ostream* content)
{
// Optionally create a command to display the custom command's
// comment text. This is used for pre-build, pre-link, and
@ -962,7 +966,8 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
// working directory will be the start-output directory.
bool had_slash = cmd.find('/') != cmd.npos;
if (workingDir.empty()) {
cmd = this->Convert(cmd, cmOutputConverter::START_OUTPUT);
cmd =
this->ConvertToRelativePath(cmd, cmOutputConverter::START_OUTPUT);
}
bool has_slash = cmd.find('/') != cmd.npos;
if (had_slash && !has_slash) {
@ -971,10 +976,43 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
// without the current directory being in the search path.
cmd = "./" + cmd;
}
std::string launcher = this->MakeLauncher(
ccg, target, workingDir.empty() ? cmOutputConverter::START_OUTPUT
: cmOutputConverter::NONE);
cmd = launcher + this->ConvertShellCommand(cmd, cmOutputConverter::NONE);
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 shellCommand = this->MaybeConvertWatcomShellCommand(cmd);
if (shellCommand.empty()) {
shellCommand =
this->ConvertToOutputFormat(cmd, cmOutputConverter::SHELL);
}
cmd = launcher + shellCommand;
ccg.AppendArguments(c, cmd);
if (content) {
@ -1017,37 +1055,6 @@ 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)
@ -1061,8 +1068,7 @@ void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
cleanfile += filename;
}
cleanfile += ".cmake";
std::string cleanfilePath =
this->Convert(cleanfile, cmOutputConverter::FULL);
std::string cleanfilePath = cmSystemTools::CollapseFullPath(cleanfile);
cmsys::ofstream fout(cleanfilePath.c_str());
if (!fout) {
cmSystemTools::Error("Could not create ", cleanfilePath.c_str());
@ -1071,8 +1077,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->Convert(*f, cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED);
std::string fc =
this->ConvertToRelativePath(*f, cmOutputConverter::START_OUTPUT);
fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n";
}
fout << ")\n";
@ -1148,7 +1154,8 @@ void cmLocalUnixMakefileGenerator3::AppendEcho(
cmd += color_name;
if (progress) {
cmd += "--progress-dir=";
cmd += this->Convert(progress->Dir, cmOutputConverter::FULL,
cmd += this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(progress->Dir),
cmOutputConverter::SHELL);
cmd += " ";
cmd += "--progress-num=";
@ -1558,9 +1565,9 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
this->AppendCustomDepends(depends, gt->GetPreBuildCommands());
this->AppendCustomDepends(depends, gt->GetPostBuildCommands());
this->AppendCustomCommands(commands, gt->GetPreBuildCommands(), gt,
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
this->AppendCustomCommands(commands, gt->GetPostBuildCommands(), gt,
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
std::string targetName = gt->GetName();
this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName,
depends, commands, true);
@ -1597,14 +1604,15 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
progCmd << this->Convert(progressDir, cmOutputConverter::FULL,
cmOutputConverter::SHELL);
progCmd << this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(progressDir), cmOutputConverter::SHELL);
std::string progressFile = cmake::GetCMakeFilesDirectory();
progressFile += "/progress.marks";
std::string progressFileNameFull = this->ConvertToFullPath(progressFile);
progCmd << " "
<< this->Convert(progressFileNameFull, cmOutputConverter::FULL,
<< this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(progressFileNameFull),
cmOutputConverter::SHELL);
commands.push_back(progCmd.str());
}
@ -1613,12 +1621,12 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
commands.push_back(
this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
{
std::ostringstream progCmd;
progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
progCmd << this->Convert(progressDir, cmOutputConverter::FULL,
cmOutputConverter::SHELL);
progCmd << this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(progressDir), cmOutputConverter::SHELL);
progCmd << " 0";
commands.push_back(progCmd.str());
}
@ -1633,7 +1641,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
commands.push_back(
this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
this->WriteMakeRule(ruleFileStream, "The main clean target", "clean",
depends, commands, true);
commands.clear();
@ -1659,7 +1667,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
commands.push_back(
this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
"preinstall", depends, commands, true);
depends.clear();
@ -1674,12 +1682,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, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
runRule +=
this->ConvertToOutputFormat(cmakefileName, cmOutputConverter::SHELL);
runRule += " 1";
commands.push_back(runRule);
this->CreateCDCommand(commands, this->GetBinaryDirectory(),
cmOutputConverter::START_OUTPUT);
this->GetCurrentBinaryDirectory());
this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends,
commands, true);
}
@ -1846,7 +1854,8 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
cmakefileStream << " \""
<< this->Convert(*i, cmOutputConverter::HOME_OUTPUT)
<< this->ConvertToRelativePath(
*i, cmOutputConverter::HOME_OUTPUT)
<< "\"\n";
}
cmakefileStream << " )\n";
@ -1888,8 +1897,7 @@ std::string cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall(
// Call make on the given file.
std::string cmd;
cmd += "$(MAKE) -f ";
cmd +=
this->Convert(makefile, cmOutputConverter::NONE, cmOutputConverter::SHELL);
cmd += this->ConvertToOutputFormat(makefile, cmOutputConverter::SHELL);
cmd += " ";
cmGlobalUnixMakefileGenerator3* gg =
@ -1911,7 +1919,8 @@ 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->Convert(tgt, cmOutputConverter::HOME_OUTPUT);
std::string tgt2 =
this->ConvertToRelativePath(tgt, cmOutputConverter::HOME_OUTPUT);
// The target may have been written with windows paths.
cmSystemTools::ConvertToOutputSlashes(tgt2);
@ -2046,12 +2055,10 @@ void cmLocalUnixMakefileGenerator3::AddImplicitDepends(
void cmLocalUnixMakefileGenerator3::CreateCDCommand(
std::vector<std::string>& commands, const char* tgtDir,
cmOutputConverter::RelativeRoot relRetDir)
std::string const& relDir)
{
const char* retDir = this->GetRelativeRootPath(relRetDir);
// do we need to cd?
if (!strcmp(tgtDir, retDir)) {
if (tgtDir == relDir) {
return;
}
@ -2073,7 +2080,7 @@ void cmLocalUnixMakefileGenerator3::CreateCDCommand(
// Change back to the starting directory.
cmd = cd_cmd;
cmd += this->ConvertToOutputForExisting(relRetDir);
cmd += this->ConvertToOutputForExisting(relDir);
commands.push_back(cmd);
} else {
// On UNIX we must construct a single shell command to change

26
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -121,8 +121,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,
cmOutputConverter::RelativeRoot returnDir);
const char* targetDir, std::string const& relDir);
static std::string ConvertToQuotedOutputPath(const char* p,
bool useWatcomQuote);
@ -229,14 +228,15 @@ protected:
const std::vector<cmCustomCommand>& ccs);
void AppendCustomDepend(std::vector<std::string>& depends,
cmCustomCommandGenerator const& cc);
void AppendCustomCommands(
std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs, cmGeneratorTarget* target,
cmOutputConverter::RelativeRoot relative = cmOutputConverter::HOME_OUTPUT);
void AppendCustomCommand(
std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target, bool echo_comment = false,
cmOutputConverter::RelativeRoot relative = cmOutputConverter::HOME_OUTPUT,
void AppendCustomCommands(std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs,
cmGeneratorTarget* target,
std::string const& relative);
void AppendCustomCommand(std::vector<std::string>& commands,
cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target,
std::string const& relative,
bool echo_comment = false,
std::ostream* content = CM_NULLPTR);
void AppendCleanCommand(std::vector<std::string>& commands,
const std::vector<std::string>& files,
@ -250,11 +250,7 @@ protected:
void CheckMultipleOutputs(bool verbose);
private:
std::string ConvertShellCommand(std::string const& cmd,
cmOutputConverter::RelativeRoot root);
std::string MakeLauncher(cmCustomCommandGenerator const& ccg,
cmGeneratorTarget* target,
cmOutputConverter::RelativeRoot relative);
std::string MaybeConvertWatcomShellCommand(std::string const& cmd);
void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,

26
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -269,8 +269,8 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
args += this->GetBinaryDirectory();
commandLine.push_back(args);
commandLine.push_back("--check-stamp-file");
std::string stampFilename = this->Convert(
stampName.c_str(), cmOutputConverter::FULL, cmOutputConverter::SHELL);
std::string stampFilename = this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(stampName), 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 = this->Convert(
stampName.c_str(), cmOutputConverter::FULL, cmOutputConverter::UNCHANGED);
std::string fullpathStampName =
cmSystemTools::CollapseFullPath(stampName.c_str());
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->Convert(target_mod_dir, cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED);
modDir = this->ConvertToRelativePath(target_mod_dir,
cmOutputConverter::START_OUTPUT);
} else {
modDir = ".";
}
@ -1300,9 +1300,8 @@ 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->Convert(l->Value.c_str(), cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED);
std::string rel = lg->ConvertToRelativePath(
l->Value.c_str(), cmOutputConverter::START_OUTPUT);
fout << lg->ConvertToXMLOutputPath(rel.c_str()) << " ";
} else if (!l->Target ||
l->Target->GetType() != cmState::INTERFACE_LIBRARY) {
@ -1322,8 +1321,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(), cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED);
std::string rel =
lg->ConvertToRelativePath(oi->c_str(), cmOutputConverter::START_OUTPUT);
fout << sep << lg->ConvertToXMLOutputPath(rel.c_str());
sep = " ";
}
@ -1346,9 +1345,8 @@ void cmLocalVisualStudio7Generator::OutputLibraryDirectories(
// Switch to a relative path specification if it is shorter.
if (cmSystemTools::FileIsFullPath(dir.c_str())) {
std::string rel =
this->Convert(dir.c_str(), cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED);
std::string rel = this->ConvertToRelativePath(
dir.c_str(), cmOutputConverter::START_OUTPUT);
if (rel.size() < dir.size()) {
dir = rel;
}

10
Source/cmLocalVisualStudioGenerator.cxx
View File

@ -127,7 +127,6 @@ 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 = "";
@ -156,7 +155,8 @@ std::string cmLocalVisualStudioGenerator::ConstructScript(
script += newline;
newline = newline_text;
script += "cd ";
script += this->Convert(workingDirectory, FULL, SHELL);
script += this->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(workingDirectory), SHELL);
script += check_error;
// Change the working drive.
@ -203,7 +203,11 @@ std::string cmLocalVisualStudioGenerator::ConstructScript(
}
}
script += this->Convert(cmd.c_str(), relativeRoot, SHELL);
if (workingDirectory.empty()) {
script += this->Convert(cmd.c_str(), START_OUTPUT, SHELL);
} else {
script += this->ConvertToOutputFormat(cmd.c_str(), SHELL);
}
ccg.AppendArguments(c, script);
// After each custom command, check for an error result.

49
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@ -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->Convert(
targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
std::string targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
targetFullPathPDB, cmOutputConverter::SHELL);
// Convert to the output path to use in constructing commands.
std::string targetOutPath = this->Convert(
targetFullPath, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
@ -218,49 +218,43 @@ 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->Convert(targetFullPath,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPath, cmOutputConverter::START_OUTPUT));
#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(),
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
(targetFullPath + ".manifest").c_str(), cmOutputConverter::START_OUTPUT));
#endif
if (targetNameReal != targetName) {
exeCleanFiles.push_back(this->Convert(targetFullPathReal,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathReal, cmOutputConverter::START_OUTPUT));
}
if (!targetNameImport.empty()) {
exeCleanFiles.push_back(this->Convert(targetFullPathImport,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathImport, cmOutputConverter::START_OUTPUT));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
exeCleanFiles.push_back(this->Convert(implib,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
implib, cmOutputConverter::START_OUTPUT));
}
}
// 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->Convert(targetFullPathPDB,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
this->CleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathPDB, cmOutputConverter::START_OUTPUT));
// Add the pre-build and pre-link rules building but not when relinking.
if (!relink) {
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPreBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPreLinkCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
}
// Determine whether a link script will be used.
@ -357,9 +351,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
vars.Manifests = manifests.c_str();
if (this->GeneratorTarget->GetProperty("LINK_WHAT_YOU_USE")) {
std::string cmakeCommand =
this->Convert(cmSystemTools::GetCMakeCommand(), cmLocalGenerator::NONE,
cmLocalGenerator::SHELL);
std::string cmakeCommand = this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
cmakeCommand += " -E __run_iwyu --lwyu=";
cmakeCommand += targetOutPathReal;
real_link_commands.push_back(cmakeCommand);
@ -389,7 +382,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
}
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
@ -402,7 +395,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
commands1.push_back(symlink);
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
}
@ -411,7 +404,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
if (!relink) {
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
}
// Write the build rule.

63
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -112,7 +112,7 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules()
// Add post-build rules.
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
// Depend on the object files.
this->AppendObjectDepends(depends);
@ -310,8 +310,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Construct the output path version of the names for use in command
// arguments.
std::string targetOutPathPDB = this->Convert(
targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
std::string targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
targetFullPathPDB, cmOutputConverter::SHELL);
std::string targetOutPath = this->Convert(
targetFullPath, cmOutputConverter::START_OUTPUT, cmOutputConverter::SHELL);
std::string targetOutPathSO =
@ -367,46 +367,40 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Clean files associated with this library.
std::vector<std::string> libCleanFiles;
libCleanFiles.push_back(this->Convert(targetFullPath,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPath, cmOutputConverter::START_OUTPUT));
if (targetNameReal != targetName) {
libCleanFiles.push_back(this->Convert(targetFullPathReal,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathReal, cmOutputConverter::START_OUTPUT));
}
if (targetNameSO != targetName && targetNameSO != targetNameReal) {
libCleanFiles.push_back(this->Convert(targetFullPathSO,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathSO, cmOutputConverter::START_OUTPUT));
}
if (!targetNameImport.empty()) {
libCleanFiles.push_back(this->Convert(targetFullPathImport,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathImport, cmOutputConverter::START_OUTPUT));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
libCleanFiles.push_back(this->Convert(implib,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
implib, cmOutputConverter::START_OUTPUT));
}
}
// 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->Convert(targetFullPathPDB,
cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
this->CleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
targetFullPathPDB, cmOutputConverter::START_OUTPUT));
#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(), cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED));
libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
(targetFullPath + ".manifest").c_str(),
cmOutputConverter::START_OUTPUT));
}
#endif
@ -418,7 +412,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
this->GeneratorTarget, "target");
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
}
@ -427,10 +421,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
if (!relink) {
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPreBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPreLinkCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
}
// Determine whether a link script will be used.
@ -572,8 +566,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
vars.TargetInstallNameDir = "";
} else {
// Convert to a path for the native build tool.
install_name_dir = this->LocalGenerator->Convert(
install_name_dir, cmOutputConverter::NONE, cmOutputConverter::SHELL);
install_name_dir = this->LocalGenerator->ConvertToOutputFormat(
install_name_dir, cmOutputConverter::SHELL);
vars.TargetInstallNameDir = install_name_dir.c_str();
}
}
@ -640,9 +634,8 @@ 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->Convert(cmSystemTools::GetCMakeCommand(),
cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
std::string cmakeCommand = this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
cmakeCommand += " -E __run_iwyu --lwyu=";
cmakeCommand += targetOutPathReal;
real_link_commands.push_back(cmakeCommand);
@ -672,7 +665,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
}
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
@ -689,7 +682,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
commands1.push_back(symlink);
this->LocalGenerator->CreateCDCommand(
commands1, this->Makefile->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), commands1.begin(), commands1.end());
commands1.clear();
}
@ -698,7 +691,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
if (!relink) {
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
}
// Compute the list of outputs.

117
Source/cmMakefileTargetGenerator.cxx
View File

@ -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->Convert(
*o, cmOutputConverter::START_OUTPUT, cmOutputConverter::UNCHANGED));
this->CleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
*o, cmOutputConverter::START_OUTPUT));
}
}
}
@ -312,8 +312,10 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
output += "/";
output += cmSystemTools::GetFilenameName(input);
this->Generator->CleanFiles.push_back(
this->Generator->Convert(output, cmOutputConverter::START_OUTPUT));
output = this->Generator->Convert(output, cmOutputConverter::HOME_OUTPUT);
this->Generator->LocalGenerator->ConvertToRelativePath(
output, cmOutputConverter::START_OUTPUT));
output = this->Generator->LocalGenerator->ConvertToRelativePath(
output, cmOutputConverter::HOME_OUTPUT);
// Create a rule to copy the content into the bundle.
std::vector<std::string> depends;
@ -324,11 +326,11 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
this->Generator->LocalGenerator->AppendEcho(
commands, copyEcho, cmLocalUnixMakefileGenerator3::EchoBuild);
std::string copyCommand = "$(CMAKE_COMMAND) -E copy ";
copyCommand += this->Generator->Convert(input, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
copyCommand += this->Generator->LocalGenerator->ConvertToOutputFormat(
input, cmOutputConverter::SHELL);
copyCommand += " ";
copyCommand += this->Generator->Convert(output, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
copyCommand += this->Generator->LocalGenerator->ConvertToOutputFormat(
output, cmOutputConverter::SHELL);
commands.push_back(copyCommand);
this->Generator->LocalGenerator->WriteMakeRule(
*this->Generator->BuildFileStream, CM_NULLPTR, output, depends, commands,
@ -393,9 +395,9 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
std::string objFullPath = this->LocalGenerator->GetCurrentBinaryDirectory();
objFullPath += "/";
objFullPath += obj;
objFullPath = this->Convert(objFullPath, cmOutputConverter::FULL);
objFullPath = cmSystemTools::CollapseFullPath(objFullPath);
std::string srcFullPath =
this->Convert(source.GetFullPath(), cmOutputConverter::FULL);
cmSystemTools::CollapseFullPath(source.GetFullPath());
this->LocalGenerator->AddImplicitDepends(
this->GeneratorTarget, lang, objFullPath.c_str(), srcFullPath.c_str());
}
@ -464,8 +466,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
}
// Get the output paths for source and object files.
std::string sourceFile = this->Convert(
source.GetFullPath(), cmOutputConverter::NONE, cmOutputConverter::SHELL);
std::string sourceFile = this->LocalGenerator->ConvertToOutputFormat(
source.GetFullPath(), cmOutputConverter::SHELL);
// Construct the build message.
std::vector<std::string> no_commands;
@ -516,8 +518,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
targetOutPathReal =
this->Convert(targetFullPathReal, cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);
targetOutPathPDB = this->Convert(
targetFullPathPDB, cmOutputConverter::NONE, cmOutputConverter::SHELL);
targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
targetFullPathPDB, cmOutputConverter::SHELL);
targetOutPathCompilePDB =
this->Convert(targetFullPathCompilePDB, cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);
@ -539,7 +541,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
vars.TargetCompilePDB = targetOutPathCompilePDB.c_str();
vars.Source = sourceFile.c_str();
std::string shellObj =
this->Convert(obj, cmOutputConverter::NONE, cmOutputConverter::SHELL);
this->LocalGenerator->ConvertToOutputFormat(obj, cmOutputConverter::SHELL);
vars.Object = shellObj.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
objectDir = this->Convert(objectDir, cmOutputConverter::START_OUTPUT,
@ -584,9 +586,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
lang_can_export_cmds && compileCommands.size() == 1) {
std::string compileCommand = compileCommands[0];
this->LocalGenerator->ExpandRuleVariables(compileCommand, vars);
std::string workingDirectory = this->LocalGenerator->Convert(
this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::FULL);
std::string workingDirectory = cmSystemTools::CollapseFullPath(
this->LocalGenerator->GetCurrentBinaryDirectory());
compileCommand.replace(compileCommand.find(langFlags), langFlags.size(),
this->GetFlags(lang));
std::string langDefines = std::string("$(") + lang + "_DEFINES)";
@ -649,7 +650,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
// Change the command working directory to the local build tree.
this->LocalGenerator->CreateCDCommand(
compileCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), compileCommands.begin(),
compileCommands.end());
}
@ -699,8 +700,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
std::vector<std::string> preprocessCommands;
cmSystemTools::ExpandListArgument(preprocessRule, preprocessCommands);
std::string shellObjI = this->Convert(objI, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
std::string shellObjI = this->LocalGenerator->ConvertToOutputFormat(
objI, cmOutputConverter::SHELL);
vars.PreprocessedSource = shellObjI.c_str();
// Expand placeholders in the commands.
@ -712,7 +713,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
this->LocalGenerator->CreateCDCommand(
preprocessCommands,
this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), preprocessCommands.begin(),
preprocessCommands.end());
} else {
@ -746,8 +747,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
std::vector<std::string> assemblyCommands;
cmSystemTools::ExpandListArgument(assemblyRule, assemblyCommands);
std::string shellObjS = this->Convert(objS, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
std::string shellObjS = this->LocalGenerator->ConvertToOutputFormat(
objS, cmOutputConverter::SHELL);
vars.AssemblySource = shellObjS.c_str();
// Expand placeholders in the commands.
@ -758,7 +759,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
this->LocalGenerator->CreateCDCommand(
assemblyCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
commands.insert(commands.end(), assemblyCommands.begin(),
assemblyCommands.end());
} else {
@ -849,7 +850,7 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules()
this->GeneratorTarget);
this->LocalGenerator->CreateCDCommand(
commands, this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::HOME_OUTPUT);
this->LocalGenerator->GetBinaryDirectory());
// Write the rule.
this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR,
@ -999,9 +1000,10 @@ 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->Convert(
this->LocalGenerator->GetBinaryDirectory(),
cmOutputConverter::FULL, cmOutputConverter::SHELL))
depCmd << "cd " << (this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(
this->LocalGenerator->GetBinaryDirectory()),
cmOutputConverter::SHELL))
<< " && ";
#endif
// Generate a call this signature:
@ -1015,19 +1017,28 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
// the state of our local generator sufficiently for its needs.
depCmd << "$(CMAKE_COMMAND) -E cmake_depends \""
<< this->GlobalGenerator->GetName() << "\" "
<< this->Convert(this->LocalGenerator->GetSourceDirectory(),
cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(
this->LocalGenerator->GetSourceDirectory()),
cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->LocalGenerator->GetCurrentSourceDirectory(),
cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(
this->LocalGenerator->GetCurrentSourceDirectory()),
cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->LocalGenerator->GetBinaryDirectory(),
cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(
this->LocalGenerator->GetBinaryDirectory()),
cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->LocalGenerator->GetCurrentBinaryDirectory(),
cmOutputConverter::FULL, cmOutputConverter::SHELL)
<< this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(
this->LocalGenerator->GetCurrentBinaryDirectory()),
cmOutputConverter::SHELL)
<< " "
<< this->Convert(this->InfoFileNameFull, cmOutputConverter::FULL,
<< this->LocalGenerator->ConvertToOutputFormat(
cmSystemTools::CollapseFullPath(this->InfoFileNameFull),
cmOutputConverter::SHELL);
if (this->LocalGenerator->GetColorMakefile()) {
depCmd << " --color=$(COLOR)";
@ -1094,8 +1105,8 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile(
// Now append the actual user-specified commands.
std::ostringstream content;
this->LocalGenerator->AppendCustomCommand(
commands, ccg, this->GeneratorTarget, false,
cmOutputConverter::HOME_OUTPUT, &content);
commands, ccg, this->GeneratorTarget,
this->LocalGenerator->GetBinaryDirectory(), false, &content);
// Collect the dependencies.
std::vector<std::string> depends;
@ -1115,10 +1126,8 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile(
for (cmCustomCommand::ImplicitDependsList::const_iterator idi =
ccg.GetCC().GetImplicitDepends().begin();
idi != ccg.GetCC().GetImplicitDepends().end(); ++idi) {
std::string objFullPath =
this->Convert(outputs[0], cmOutputConverter::FULL);
std::string srcFullPath =
this->Convert(idi->second, cmOutputConverter::FULL);
std::string objFullPath = cmSystemTools::CollapseFullPath(outputs[0]);
std::string srcFullPath = cmSystemTools::CollapseFullPath(idi->second);
this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, idi->first,
objFullPath.c_str(),
srcFullPath.c_str());
@ -1174,7 +1183,8 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
object = this->Convert(*i, cmOutputConverter::START_OUTPUT);
object = this->LocalGenerator->ConvertToRelativePath(
*i, cmOutputConverter::START_OUTPUT);
*this->BuildFileStream << " " << lineContinue << "\n"
<< this->Makefile->GetSafeDefinition(
"CMAKE_OBJECT_NAME");
@ -1261,9 +1271,8 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule(
this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
std::string buildTargetRuleName = dir;
buildTargetRuleName += relink ? "/preinstall" : "/build";
buildTargetRuleName =
this->Convert(buildTargetRuleName, cmOutputConverter::HOME_OUTPUT,
cmOutputConverter::UNCHANGED);
buildTargetRuleName = this->LocalGenerator->ConvertToRelativePath(
buildTargetRuleName, cmOutputConverter::HOME_OUTPUT);
// Build the list of target outputs to drive.
std::vector<std::string> depends;
@ -1576,8 +1585,8 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
// Reference the response file.
linkLibs = responseFlag;
linkLibs += this->Convert(link_rsp, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
linkLibs += this->LocalGenerator->ConvertToOutputFormat(
link_rsp, cmOutputConverter::SHELL);
}
}
@ -1625,8 +1634,8 @@ void cmMakefileTargetGenerator::CreateObjectLists(
// Reference the response file.
buildObjs += responseFlag;
buildObjs += this->Convert(objects_rsp, cmOutputConverter::NONE,
cmOutputConverter::SHELL);
buildObjs += this->LocalGenerator->ConvertToOutputFormat(
objects_rsp, cmOutputConverter::SHELL);
}
} else if (useLinkScript) {
if (!useArchiveRules) {
@ -1683,8 +1692,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->Convert(cmd, cmOutputConverter::NONE, cmOutputConverter::SHELL);
cmd = this->LocalGenerator->ConvertToOutputFormat(
cmd, cmOutputConverter::SHELL);
cmd += " -E __create_def ";
cmd += this->Convert(name_of_def_file, cmOutputConverter::START_OUTPUT,
cmOutputConverter::SHELL);

4
Source/cmMakefileUtilityTargetGenerator.cxx
View File

@ -75,14 +75,14 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPreBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
// Depend on all custom command outputs for sources
this->DriveCustomCommands(depends);
this->LocalGenerator->AppendCustomCommands(
commands, this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
this->GeneratorTarget, this->LocalGenerator->GetBinaryDirectory());
// Add dependencies on targets that must be built first.
this->AppendTargetDepends(depends);

4
Source/cmNinjaNormalTargetGenerator.cxx
View File

@ -543,8 +543,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
std::string install_dir =
this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName);
if (!install_dir.empty()) {
vars["INSTALLNAME_DIR"] = localGen.Convert(
install_dir, cmOutputConverter::NONE, cmOutputConverter::SHELL);
vars["INSTALLNAME_DIR"] = localGen.ConvertToOutputFormat(
install_dir, cmOutputConverter::SHELL);
}
}
}

87
Source/cmOutputConverter.cxx
View File

@ -46,34 +46,32 @@ std::string cmOutputConverter::ConvertToOutputForExisting(
return this->ConvertToOutputFormat(remote, format);
}
std::string cmOutputConverter::ConvertToOutputForExisting(
RelativeRoot remote, OutputFormat format) const
std::string cmOutputConverter::ConvertToRelativePath(
const std::string& source, RelativeRoot relative) const
{
// The relative root must have a path (i.e. not FULL or NONE)
assert(remote != FULL);
assert(remote != NONE);
std::string result;
const char* remotePath = this->GetRelativeRootPath(remote);
assert(remotePath != CM_NULLPTR);
return this->ConvertToOutputForExisting(remotePath, format);
}
const char* cmOutputConverter::GetRelativeRootPath(RelativeRoot relroot) const
{
switch (relroot) {
switch (relative) {
case HOME:
return this->GetState()->GetSourceDirectory();
result = this->ConvertToRelativePath(
this->GetState()->GetSourceDirectoryComponents(), source);
break;
case START:
return this->StateSnapshot.GetDirectory().GetCurrentSource();
result = this->ConvertToRelativePath(
this->StateSnapshot.GetDirectory().GetCurrentSourceComponents(),
source);
break;
case HOME_OUTPUT:
return this->GetState()->GetBinaryDirectory();
result = this->ConvertToRelativePath(
this->GetState()->GetBinaryDirectoryComponents(), source);
break;
case START_OUTPUT:
return this->StateSnapshot.GetDirectory().GetCurrentBinary();
default:
result = this->ConvertToRelativePath(
this->StateSnapshot.GetDirectory().GetCurrentBinaryComponents(),
source);
break;
}
return CM_NULLPTR;
return result;
}
std::string cmOutputConverter::Convert(const std::string& source,
@ -81,33 +79,7 @@ std::string cmOutputConverter::Convert(const std::string& source,
OutputFormat output) const
{
// Convert the path to a relative path.
std::string result = source;
switch (relative) {
case HOME:
result = this->ConvertToRelativePath(
this->GetState()->GetSourceDirectoryComponents(), result);
break;
case START:
result = this->ConvertToRelativePath(
this->StateSnapshot.GetDirectory().GetCurrentSourceComponents(),
result);
break;
case HOME_OUTPUT:
result = this->ConvertToRelativePath(
this->GetState()->GetBinaryDirectoryComponents(), result);
break;
case START_OUTPUT:
result = this->ConvertToRelativePath(
this->StateSnapshot.GetDirectory().GetCurrentBinaryComponents(),
result);
break;
case FULL:
result = cmSystemTools::CollapseFullPath(result);
break;
case NONE:
break;
}
std::string result = this->ConvertToRelativePath(source, relative);
return this->ConvertToOutputFormat(result, output);
}
@ -146,27 +118,6 @@ std::string cmOutputConverter::ConvertDirectorySeparatorsForShell(
return result;
}
std::string cmOutputConverter::Convert(RelativeRoot remote,
const std::string& local,
OutputFormat output) const
{
// The relative root must have a path (i.e. not FULL or NONE)
assert(remote != FULL);
assert(remote != NONE);
const char* remotePath = this->GetRelativeRootPath(remote);
assert(remotePath != CM_NULLPTR);
if (local.empty()) {
return this->ConvertToOutputFormat(remotePath, output);
}
std::vector<std::string> components;
cmSystemTools::SplitPath(local, components);
std::string result = this->ConvertToRelativePath(components, remotePath);
return this->ConvertToOutputFormat(result, output);
}
static bool cmOutputConverterNotAbove(const char* a, const char* b)
{
return (cmSystemTools::ComparePath(a, b) ||

19
Source/cmOutputConverter.h
View File

@ -38,8 +38,6 @@ public:
*/
enum RelativeRoot
{
NONE,
FULL,
HOME,
START,
HOME_OUTPUT,
@ -47,7 +45,6 @@ public:
};
enum OutputFormat
{
UNCHANGED,
MAKERULE,
SHELL,
WATCOMQUOTE,
@ -56,26 +53,16 @@ public:
std::string ConvertToOutputFormat(const std::string& source,
OutputFormat output) const;
std::string Convert(const std::string& remote, RelativeRoot local,
OutputFormat output = UNCHANGED) const;
std::string Convert(RelativeRoot remote, const std::string& local,
OutputFormat output = UNCHANGED) const;
OutputFormat output) const;
std::string ConvertToRelativePath(const std::string& remote,
RelativeRoot local) const;
std::string ConvertDirectorySeparatorsForShell(
const std::string& source) const;
/**
* Get path for the specified relative root.
*/
const char* GetRelativeRootPath(RelativeRoot relroot) const;
///! for existing files convert to output path and short path if spaces
std::string ConvertToOutputForExisting(const std::string& remote,
OutputFormat format = SHELL) const;
/** For existing path identified by RelativeRoot convert to output
path and short path if spaces. */
std::string ConvertToOutputForExisting(RelativeRoot remote,
OutputFormat format = SHELL) const;
void SetLinkScriptShell(bool linkScriptShell);
/**

3
Source/cmTarget.cxx
View File

@ -602,7 +602,8 @@ 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.Convert(lfc.FilePath, cmOutputConverter::HOME);
lfc.FilePath =
converter.ConvertToRelativePath(lfc.FilePath, cmOutputConverter::HOME);
s << " * " << lfc << std::endl;
}
}

5
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -2415,9 +2415,8 @@ 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->Convert(
l->Value.c_str(), cmOutputConverter::START_OUTPUT,
cmOutputConverter::UNCHANGED);
std::string path = this->LocalGenerator->ConvertToRelativePath(
l->Value.c_str(), cmOutputConverter::START_OUTPUT);
this->ConvertToWindowsSlash(path);
libVec.push_back(path);
} else if (!l->Target ||