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 74adf4e543d506a44500d0aa9bf1203c2270b217 (commit)
via dfa27f07b492d1aaa94b32a11b4e24ca73d5e420 (commit)
via 511ed264e1b2816d519fb45bd1a86f650d35dbed (commit)
via 6e77e10712d852322e28a9283e7b1385fed01da0 (commit)
via e5f9caf1260a17aea799487aa7abb2950d3252ce (commit)
via abb1e1d227f3f5e61fa22c57c7f6f0fdca745ace (commit)
via ee661eb0e937bbb683f1deb24faf927add5f060a (commit)
via ec5115eab84226573a8d6903db68d432c1fe147a (commit)
via 44aa69e750a730fde6610acecfef09663d42098f (commit)
via 4bd19454ed652c54d278546992f9c3606e1de966 (commit)
via 8081600219bc8638dd8ce99e6d25a7f35c0cc8f0 (commit)
via fb932b367e1678c3d4395d7af422fa9627666f1a (commit)
via 608e6fe5f24bc6cbf8f4296994fa3878b49a4557 (commit)
via 5dcf248bc167a04886fb5388c42d1d11aae61cec (commit)
via 3288481c22337a8bdd785d0cd8b725d5abc1351d (commit)
via c7926fe8890a80bb3e9072e903dcadcf4faac4cf (commit)
via a41cf74b1836899ad9e3c80a8013446e849049ed (commit)
via 41aa789e0b1d498e0a160bc2848c9a16fea9d2b5 (commit)
via cc7832e9bcfea870de73911f1017bdef6a9ff956 (commit)
via aa1ab4c0c975ca81ca7005e0359573836e930530 (commit)
via 1704cd340e9851e0041d275be54bb7be21b40288 (commit)
via 8de218ceaf8bd1c6a122f245228aa885c82985a7 (commit)
via 986d8c78d428c6d7ac5d3a8e4ada86e65901ad99 (commit)
via 21b23658deecb8a8ae0b0be1c7dbd53adb694fe2 (commit)
via 94af779a19c7ed4227a396fd26f1bc22ee26699a (commit)
via 06455f35cf076326134621cc44a446681e6c90e4 (commit)
via ca5ef925eb1ae2a1e63ae1b0762ddbbef19e49a2 (commit)
via 490b2d6ee5146c7f097ba8a2759bf720d528abce (commit)
from 1d6b62aa619dd4eba44c77587fc51349b73c9ce5 (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=74adf4e543d506a44500d0aa9bf1203c2270b217
commit 74adf4e543d506a44500d0aa9bf1203c2270b217
Merge: 1d6b62a dfa27f0
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 16:57:34 2016 -0400
Commit: CMake Topic Stage <kwro...@kitware.com>
CommitDate: Tue Oct 4 16:57:34 2016 -0400
Merge topic 'extract-cmLinkLineComputer' into next
dfa27f07 cmLinkLineComputer: Extract from cmLocalGenerator
511ed264 cmLocalGenerator: Inline conversion into link computation
6e77e107 Ninja: Inline code into ConvertToLinkReference
e5f9caf1 Ninja: Add a new accessor method
abb1e1d2 Ninja: Extract a static path conversion method
ee661eb0 Ninja: Inline conversion to relative path
ec5115ea Ninja: Get the binary directory from cmState::Directory
44aa69e7 Ninja: Inline output path conversion
4bd19454 Ninja: Simplify method
80816002 cmLocalGenerator: Simplify ConvertToLinkReference
fb932b36 cmOutputConverter: Add a flag for IsUnix
608e6fe5 Convert: Inline platform-specific methods
5dcf248b Ninja: Extract identical code from condition
3288481c Ninja: Replace array access with local variable
c7926fe8 Ninja: Separate two coupled calls
a41cf74b Makefiles: Introduce local RelativePath method
...
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=dfa27f07b492d1aaa94b32a11b4e24ca73d5e420
commit dfa27f07b492d1aaa94b32a11b4e24ca73d5e420
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:34 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:34 2016 +0200
cmLinkLineComputer: Extract from cmLocalGenerator
CMake has several classes which have too many responsibilities.
cmLocalGenerator is one of them. Start to extract the link line
computation. Create generator-specific implementations of the interface
to account for generator-specific behavior.
Unfortunately MSVC60 has different behavior to everything else and CMake
still generates makefiles for it. Isolate it with MSVC60-specific
names.
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index ec49481..81108ad 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -300,6 +300,8 @@ set(SRCS
cmInstallDirectoryGenerator.cxx
cmLinkedTree.h
cmLinkItem.h
+ cmLinkLineComputer.cxx
+ cmLinkLineComputer.h
cmListFileCache.cxx
cmListFileCache.h
cmListFileLexer.c
@@ -318,6 +320,8 @@ set(SRCS
cmMakefileUtilityTargetGenerator.cxx
cmMessenger.cxx
cmMessenger.h
+ cmMSVC60LinkLineComputer.cxx
+ cmMSVC60LinkLineComputer.h
cmOSXBundleGenerator.cxx
cmOSXBundleGenerator.h
cmOutputConverter.cxx
@@ -543,6 +547,8 @@ set(SRCS ${SRCS}
cmNinjaNormalTargetGenerator.h
cmNinjaUtilityTargetGenerator.cxx
cmNinjaUtilityTargetGenerator.h
+ cmNinjaLinkLineComputer.cxx
+ cmNinjaLinkLineComputer.h
)
# Temporary variable for tools targets
diff --git a/Source/cmCommonTargetGenerator.cxx
b/Source/cmCommonTargetGenerator.cxx
index 14ea1a9..b995fa1 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -12,6 +12,7 @@
#include "cmComputeLinkInformation.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalCommonGenerator.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalCommonGenerator.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
@@ -59,7 +60,8 @@ void cmCommonTargetGenerator::AddFeatureFlags(std::string&
flags,
}
}
-void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
+void cmCommonTargetGenerator::AddModuleDefinitionFlag(
+ cmLinkLineComputer* linkLineComputer, std::string& flags)
{
if (!this->ModuleDefinitionFile) {
return;
@@ -76,7 +78,7 @@ void
cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
// vs6's "cl -link" pass it to the linker.
std::string flag = defFileFlag;
flag += this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToLinkReference(
+ linkLineComputer->ConvertToLinkReference(
this->ModuleDefinitionFile->GetFullPath()),
cmOutputConverter::SHELL);
this->LocalGenerator->AppendFlags(flags, flag);
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
index 707b81e..fe27038 100644
--- a/Source/cmCommonTargetGenerator.h
+++ b/Source/cmCommonTargetGenerator.h
@@ -16,6 +16,7 @@ class cmGlobalCommonGenerator;
class cmLocalCommonGenerator;
class cmMakefile;
class cmSourceFile;
+class cmLinkLineComputer;
/** \class cmCommonTargetGenerator
* \brief Common infrastructure for Makefile and Ninja per-target generators
@@ -37,7 +38,8 @@ protected:
bool GetFeatureAsBool(const std::string& feature);
// Helper to add flag for windows .def file.
- void AddModuleDefinitionFlag(std::string& flags);
+ void AddModuleDefinitionFlag(cmLinkLineComputer* linkLineComputer,
+ std::string& flags);
cmGeneratorTarget* GeneratorTarget;
cmMakefile* Makefile;
diff --git a/Source/cmGhsMultiTargetGenerator.cxx
b/Source/cmGhsMultiTargetGenerator.cxx
index 959dfdb..9e43a52 100644
--- a/Source/cmGhsMultiTargetGenerator.cxx
+++ b/Source/cmGhsMultiTargetGenerator.cxx
@@ -362,9 +362,13 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries(
this->GeneratorTarget->GetCreateRuleVariable(language, config);
bool useWatcomQuote =
this->Makefile->IsOn(createRule + "_USE_WATCOM_QUOTE");
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer =
+ this->GetGlobalGenerator()->CreateLinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory());
+
this->LocalGenerator->GetTargetFlags(
- config, linkLibraries, flags, linkFlags, frameworkPath, linkPath,
- this->GeneratorTarget, useWatcomQuote);
+ linkLineComputer.get(), config, linkLibraries, flags, linkFlags,
+ frameworkPath, linkPath, this->GeneratorTarget, useWatcomQuote);
linkFlags = cmSystemTools::TrimWhitespace(linkFlags);
if (!linkPath.empty()) {
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index a446862..251555b 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -20,7 +20,9 @@
#include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h"
#include "cmInstallGenerator.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
+#include "cmMSVC60LinkLineComputer.h"
#include "cmMakefile.h"
#include "cmOutputConverter.h"
#include "cmPolicies.h"
@@ -1393,6 +1395,18 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
return autogenTargets;
}
+cmLinkLineComputer* cmGlobalGenerator::CreateLinkLineComputer(
+ cmState::Directory stateDir) const
+{
+ return new cmLinkLineComputer(stateDir);
+}
+
+cmLinkLineComputer* cmGlobalGenerator::CreateMSVC60LinkLineComputer(
+ cmState::Directory stateDir) const
+{
+ return new cmMSVC60LinkLineComputer(stateDir);
+}
+
void cmGlobalGenerator::FinalizeTargetCompileInfo()
{
std::vector<std::string> const langs =
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 4120b52..3ae2ebd 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -33,6 +33,7 @@ class cmExportBuildFileGenerator;
class cmExternalMakefileProjectGenerator;
class cmGeneratorTarget;
class cmLocalGenerator;
+class cmLinkLineComputer;
class cmMakefile;
class cmake;
@@ -98,6 +99,12 @@ public:
*/
virtual void Generate();
+ virtual cmLinkLineComputer* CreateLinkLineComputer(
+ cmState::Directory stateDir) const;
+
+ cmLinkLineComputer* CreateMSVC60LinkLineComputer(
+ cmState::Directory stateDir) const;
+
/**
* Set/Get and Clear the enabled languages.
*/
diff --git a/Source/cmGlobalNinjaGenerator.cxx
b/Source/cmGlobalNinjaGenerator.cxx
index 4e74a94..9e0c5b6 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -11,6 +11,7 @@
#include "cmLocalGenerator.h"
#include "cmLocalNinjaGenerator.h"
#include "cmMakefile.h"
+#include "cmNinjaLinkLineComputer.h"
#include "cmOutputConverter.h"
#include "cmState.h"
#include "cmSystemTools.h"
@@ -64,6 +65,12 @@ void cmGlobalNinjaGenerator::WriteComment(std::ostream& os,
os << "# " << comment.substr(lpos) << "\n\n";
}
+cmLinkLineComputer* cmGlobalNinjaGenerator::CreateLinkLineComputer(
+ cmState::Directory stateDir) const
+{
+ return new cmNinjaLinkLineComputer(stateDir, this->OutputPathPrefix);
+}
+
std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name)
{
// Ninja rule names must match "[a-zA-Z0-9_.-]+". Use ".xx" to encode
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 6543c9e..c0e0dff 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -70,6 +70,9 @@ public:
std::string EncodePath(const std::string& path);
static std::string EncodeDepfileSpace(const std::string& path);
+ cmLinkLineComputer* CreateLinkLineComputer(cmState::Directory stateDir) const
+ CM_OVERRIDE;
+
/**
* Write the given @a comment to the output stream @a os. It
* handles new line character properly.
diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx
new file mode 100644
index 0000000..7103a5b
--- /dev/null
+++ b/Source/cmLinkLineComputer.cxx
@@ -0,0 +1,27 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+
+#include "cmLinkLineComputer.h"
+#include "cmOutputConverter.h"
+
+cmLinkLineComputer::cmLinkLineComputer(cmState::Directory stateDir)
+ : StateDir(stateDir)
+{
+}
+
+cmLinkLineComputer::~cmLinkLineComputer()
+{
+}
+
+std::string cmLinkLineComputer::ConvertToLinkReference(
+ std::string const& lib) const
+{
+ std::string relLib = lib;
+
+ if (cmOutputConverter::ContainedInDirectory(
+ this->StateDir.GetCurrentBinary(), lib, this->StateDir)) {
+ relLib = cmOutputConverter::ForceToRelativePath(
+ this->StateDir.GetCurrentBinary(), lib);
+ }
+ return relLib;
+}
diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h
new file mode 100644
index 0000000..b25cbf9
--- /dev/null
+++ b/Source/cmLinkLineComputer.h
@@ -0,0 +1,21 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+
+#ifndef cmLinkLineComputer_h
+#define cmLinkLineComputer_h
+
+#include "cmState.h"
+
+class cmLinkLineComputer
+{
+public:
+ cmLinkLineComputer(cmState::Directory stateDir);
+ virtual ~cmLinkLineComputer();
+
+ virtual std::string ConvertToLinkReference(std::string const& input) const;
+
+protected:
+ cmState::Directory StateDir;
+};
+
+#endif
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 40b7999..7db0282 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -12,6 +12,7 @@
#include "cmInstallGenerator.h"
#include "cmInstallScriptGenerator.h"
#include "cmInstallTargetGenerator.h"
+#include "cmLinkLineComputer.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSystemTools.h"
@@ -1149,9 +1150,10 @@ void
cmLocalGenerator::GetStaticLibraryFlags(std::string& flags,
}
void cmLocalGenerator::GetTargetFlags(
- const std::string& config, std::string& linkLibs, std::string& flags,
- std::string& linkFlags, std::string& frameworkPath, std::string& linkPath,
- cmGeneratorTarget* target, bool useWatcomQuote)
+ cmLinkLineComputer* linkLineComputer, const std::string& config,
+ std::string& linkLibs, std::string& flags, std::string& linkFlags,
+ std::string& frameworkPath, std::string& linkPath, cmGeneratorTarget* target,
+ bool useWatcomQuote)
{
const std::string buildType = cmSystemTools::UpperCase(config);
const char* libraryLinkVariable =
@@ -1203,8 +1205,9 @@ void cmLocalGenerator::GetTargetFlags(
linkFlags += " ";
}
}
- this->OutputLinkLibraries(linkLibs, frameworkPath, linkPath, *target,
- false, false, useWatcomQuote);
+ this->OutputLinkLibraries(linkLineComputer, linkLibs, frameworkPath,
+ linkPath, *target, false, false,
+ useWatcomQuote);
} break;
case cmState::EXECUTABLE: {
linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
@@ -1223,8 +1226,9 @@ void cmLocalGenerator::GetTargetFlags(
return;
}
this->AddLanguageFlags(flags, linkLanguage, buildType);
- this->OutputLinkLibraries(linkLibs, frameworkPath, linkPath, *target,
- false, false, useWatcomQuote);
+ this->OutputLinkLibraries(linkLineComputer, linkLibs, frameworkPath,
+ linkPath, *target, false, false,
+ useWatcomQuote);
if (cmSystemTools::IsOn(
this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_") +
@@ -1375,51 +1379,15 @@ std::string cmLocalGenerator::GetTargetFortranFlags(
return std::string();
}
-std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib)
-{
-#if defined(_WIN32) && !defined(__CYGWIN__)
- // Work-ardound command line parsing limitations in MSVC 6.0
- if (this->Makefile->IsOn("MSVC60")) {
- // Search for the last space.
- std::string::size_type pos = lib.rfind(' ');
- if (pos != lib.npos) {
- // Find the slash after the last space, if any.
- pos = lib.find('/', pos);
-
- // Convert the portion of the path with a space to a short path.
- std::string sp;
- if (cmSystemTools::GetShortPath(lib.substr(0, pos).c_str(), sp)) {
- // Append the rest of the path with no space.
- sp += lib.substr(pos);
-
- return sp;
- }
- }
- }
-#endif
-
- // Normal behavior.
- std::string relLib = lib;
- cmState::Directory stateDir = this->GetStateSnapshot().GetDirectory();
- if (cmOutputConverter::ContainedInDirectory(
- stateDir.GetCurrentBinary(), lib, stateDir)) {
- relLib = cmOutputConverter::ForceToRelativePath(
- stateDir.GetCurrentBinary(), lib);
- }
- return relLib;
-}
-
/**
* Output the linking rules on a command line. For executables,
* targetLibrary should be a NULL pointer. For libraries, it should point
* to the name of the library. This will not link a library against itself.
*/
-void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
- std::string& frameworkPath,
- std::string& linkPath,
- cmGeneratorTarget& tgt, bool relink,
- bool forResponseFile,
- bool useWatcomQuote)
+void cmLocalGenerator::OutputLinkLibraries(
+ cmLinkLineComputer* linkLineComputer, std::string& linkLibraries,
+ std::string& frameworkPath, std::string& linkPath, cmGeneratorTarget& tgt,
+ bool relink, bool forResponseFile, bool useWatcomQuote)
{
OutputFormat shellFormat =
(forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL);
@@ -1521,7 +1489,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string&
linkLibraries,
}
if (li->IsPath) {
linkLibs += this->ConvertToOutputFormat(
- this->ConvertToLinkReference(li->Value), shellFormat);
+ linkLineComputer->ConvertToLinkReference(li->Value), shellFormat);
} else {
linkLibs += li->Value;
}
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 703a507..1b49dd1 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -24,6 +24,7 @@ class cmGeneratorTarget;
class cmGlobalGenerator;
class cmMakefile;
class cmSourceFile;
+class cmLinkLineComputer;
/** \class cmLocalGenerator
* \brief Create required build files for a directory.
@@ -309,7 +310,8 @@ public:
/** Fill out these strings for the given target. Libraries to link,
* flags, and linkflags. */
- void GetTargetFlags(const std::string& config, std::string& linkLibs,
+ void GetTargetFlags(cmLinkLineComputer* linkLineComputer,
+ const std::string& config, std::string& linkLibs,
std::string& flags, std::string& linkFlags,
std::string& frameworkPath, std::string& linkPath,
cmGeneratorTarget* target, bool useWatcomQuote);
@@ -342,7 +344,8 @@ public:
protected:
///! put all the libraries for a target on into the given stream
- void OutputLinkLibraries(std::string& linkLibraries,
+ void OutputLinkLibraries(cmLinkLineComputer* linkLineComputer,
+ std::string& linkLibraries,
std::string& frameworkPath, std::string& linkPath,
cmGeneratorTarget&, bool relink,
bool forResponseFile, bool useWatcomQuote);
@@ -367,8 +370,6 @@ protected:
std::string& CreateSafeUniqueObjectFileName(const std::string& sin,
std::string const& dir_max);
- virtual std::string ConvertToLinkReference(std::string const& lib);
-
/** Check whether the native build system supports the given
definition. Issues a warning. */
virtual bool CheckDefinition(std::string const& define) const;
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index e2bce1b..e25eb0f 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -120,17 +120,6 @@ cmGlobalNinjaGenerator*
cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
// Virtual protected methods.
-std::string cmLocalNinjaGenerator::ConvertToLinkReference(
- std::string const& lib)
-{
- cmLocalNinjaGenerator* ng = static_cast<cmLocalNinjaGenerator*>(
- this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0]);
-
- return cmGlobalNinjaGenerator::ConvertToNinjaPath(
- lib, ng->GetStateSnapshot().GetDirectory(),
- this->GetGlobalNinjaGenerator()->GetOutputPathPrefix());
-}
-
std::string cmLocalNinjaGenerator::ConvertToIncludeReference(
std::string const& path, cmOutputConverter::OutputFormat format,
bool forceFullPaths)
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index 3061b57..b04788d 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -76,8 +76,6 @@ public:
void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg,
cmNinjaDeps& ninjaDeps);
- std::string ConvertToLinkReference(std::string const& lib) CM_OVERRIDE;
-
void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,
cmGeneratorTarget const* gt = CM_NULLPTR) CM_OVERRIDE;
diff --git a/Source/cmMSVC60LinkLineComputer.cxx
b/Source/cmMSVC60LinkLineComputer.cxx
new file mode 100644
index 0000000..fbd8022
--- /dev/null
+++ b/Source/cmMSVC60LinkLineComputer.cxx
@@ -0,0 +1,33 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+
+#include "cmMSVC60LinkLineComputer.h"
+
+cmMSVC60LinkLineComputer::cmMSVC60LinkLineComputer(cmState::Directory stateDir)
+ : cmLinkLineComputer(stateDir)
+{
+}
+
+std::string cmMSVC60LinkLineComputer::ConvertToLinkReference(
+ std::string const& lib) const
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ // Work-ardound command line parsing limitations in MSVC 6.0
+ // Search for the last space.
+ std::string::size_type pos = lib.rfind(' ');
+ if (pos != lib.npos) {
+ // Find the slash after the last space, if any.
+ pos = lib.find('/', pos);
+
+ // Convert the portion of the path with a space to a short path.
+ std::string sp;
+ if (cmSystemTools::GetShortPath(lib.substr(0, pos).c_str(), sp)) {
+ // Append the rest of the path with no space.
+ sp += lib.substr(pos);
+ return sp;
+ }
+ }
+#endif
+
+ return cmLinkLineComputer::ConvertToLinkReference(lib);
+}
diff --git a/Source/cmMSVC60LinkLineComputer.h
b/Source/cmMSVC60LinkLineComputer.h
new file mode 100644
index 0000000..c159b61
--- /dev/null
+++ b/Source/cmMSVC60LinkLineComputer.h
@@ -0,0 +1,18 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+
+#ifndef cmMSVC60LinkLineComputer_h
+#define cmMSVC60LinkLineComputer_h
+
+#include "cmLinkLineComputer.h"
+
+class cmMSVC60LinkLineComputer : public cmLinkLineComputer
+{
+public:
+ cmMSVC60LinkLineComputer(cmState::Directory stateDir);
+
+ std::string ConvertToLinkReference(std::string const& input) const
+ CM_OVERRIDE;
+};
+
+#endif
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx
b/Source/cmMakefileExecutableTargetGenerator.cxx
index ff97696..8bc7ddf 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -5,6 +5,7 @@
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalUnixMakefileGenerator3.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
@@ -210,7 +211,20 @@ void
cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
this->LocalGenerator->AppendFlags(
linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
- this->AddModuleDefinitionFlag(linkFlags);
+ {
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer;
+
+ if (this->Makefile->IsOn("MSVC60")) {
+ linkLineComputer.reset(
+ this->GlobalGenerator->CreateMSVC60LinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ } else {
+ linkLineComputer.reset(this->GlobalGenerator->CreateLinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ }
+
+ this->AddModuleDefinitionFlag(linkLineComputer.get(), linkFlags);
+ }
// Construct a list of files associated with this executable that
// may need to be cleaned.
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx
b/Source/cmMakefileLibraryTargetGenerator.cxx
index 8e25f43..f6f4a00 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -5,8 +5,10 @@
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalUnixMakefileGenerator3.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
#include "cmLocalUnixMakefileGenerator3.h"
+#include "cmMSVC60LinkLineComputer.h"
#include "cmMakefile.h"
#include "cmOSXBundleGenerator.h"
#include "cmOutputConverter.h"
@@ -159,7 +161,18 @@ void
cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
this->LocalGenerator->AddConfigVariableFlags(
extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName);
- this->AddModuleDefinitionFlag(extraFlags);
+
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer;
+
+ if (this->Makefile->IsOn("MSVC60")) {
+ linkLineComputer.reset(this->GlobalGenerator->CreateMSVC60LinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ } else {
+ linkLineComputer.reset(this->GlobalGenerator->CreateLinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ }
+
+ this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags);
if (this->GeneratorTarget->GetProperty("LINK_WHAT_YOU_USE")) {
this->LocalGenerator->AppendFlags(extraFlags, " -Wl,--no-as-needed");
@@ -184,7 +197,18 @@ void
cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink)
extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
this->LocalGenerator->AddConfigVariableFlags(
extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->ConfigName);
- this->AddModuleDefinitionFlag(extraFlags);
+
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer;
+
+ if (this->Makefile->IsOn("MSVC60")) {
+ linkLineComputer.reset(this->GlobalGenerator->CreateMSVC60LinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ } else {
+ linkLineComputer.reset(this->GlobalGenerator->CreateLinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ }
+
+ this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags);
this->WriteLibraryRules(linkRuleVar, extraFlags, relink);
}
diff --git a/Source/cmMakefileTargetGenerator.cxx
b/Source/cmMakefileTargetGenerator.cxx
index a9b2f4e..d6c496f 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -10,6 +10,7 @@
#include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalUnixMakefileGenerator3.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
@@ -1585,9 +1586,20 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
{
std::string frameworkPath;
std::string linkPath;
- this->LocalGenerator->OutputLinkLibraries(linkLibs, frameworkPath, linkPath,
- *this->GeneratorTarget, relink,
- useResponseFile, useWatcomQuote);
+
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer;
+
+ if (this->Makefile->IsOn("MSVC60")) {
+ linkLineComputer.reset(this->GlobalGenerator->CreateMSVC60LinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ } else {
+ linkLineComputer.reset(this->GlobalGenerator->CreateLinkLineComputer(
+ this->LocalGenerator->GetStateSnapshot().GetDirectory()));
+ }
+
+ this->LocalGenerator->OutputLinkLibraries(
+ linkLineComputer.get(), linkLibs, frameworkPath, linkPath,
+ *this->GeneratorTarget, relink, useResponseFile, useWatcomQuote);
linkLibs = frameworkPath + linkPath + linkLibs;
if (useResponseFile && linkLibs.find_first_not_of(' ') != linkLibs.npos) {
diff --git a/Source/cmNinjaLinkLineComputer.cxx
b/Source/cmNinjaLinkLineComputer.cxx
new file mode 100644
index 0000000..4bc7133
--- /dev/null
+++ b/Source/cmNinjaLinkLineComputer.cxx
@@ -0,0 +1,19 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+
+#include "cmNinjaLinkLineComputer.h"
+#include "cmGlobalNinjaGenerator.h"
+
+cmNinjaLinkLineComputer::cmNinjaLinkLineComputer(cmState::Directory stateDir,
+ std::string const& prefix)
+ : cmLinkLineComputer(stateDir)
+ , NinjaPrefix(prefix)
+{
+}
+
+std::string cmNinjaLinkLineComputer::ConvertToLinkReference(
+ std::string const& lib) const
+{
+ return cmGlobalNinjaGenerator::ConvertToNinjaPath(lib, this->StateDir,
+ this->NinjaPrefix);
+}
diff --git a/Source/cmNinjaLinkLineComputer.h b/Source/cmNinjaLinkLineComputer.h
new file mode 100644
index 0000000..370f6ce
--- /dev/null
+++ b/Source/cmNinjaLinkLineComputer.h
@@ -0,0 +1,23 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+
+#ifndef cmNinjaLinkLineComputer_h
+#define cmNinjaLinkLineComputer_h
+
+#include "cmLinkLineComputer.h"
+#include "cmState.h"
+
+class cmNinjaLinkLineComputer : public cmLinkLineComputer
+{
+public:
+ cmNinjaLinkLineComputer(cmState::Directory stateDir,
+ std::string const& ninjaPrefix);
+
+ std::string ConvertToLinkReference(std::string const& input) const
+ CM_OVERRIDE;
+
+private:
+ std::string NinjaPrefix;
+};
+
+#endif
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx
b/Source/cmNinjaNormalTargetGenerator.cxx
index 095c703..45baf8d 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -8,6 +8,7 @@
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalNinjaGenerator.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
#include "cmLocalNinjaGenerator.h"
#include "cmMakefile.h"
@@ -470,9 +471,14 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
vars["TARGET_FILE"] =
localGen.ConvertToOutputFormat(targetOutputReal, cmOutputConverter::SHELL);
- localGen.GetTargetFlags(this->GetConfigName(), vars["LINK_LIBRARIES"],
- vars["FLAGS"], vars["LINK_FLAGS"], frameworkPath,
- linkPath, &genTarget, useWatcomQuote);
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer(
+ this->GetGlobalGenerator()->CreateLinkLineComputer(
+ this->GetLocalGenerator()->GetStateSnapshot().GetDirectory()));
+
+ localGen.GetTargetFlags(linkLineComputer.get(), this->GetConfigName(),
+ vars["LINK_LIBRARIES"], vars["FLAGS"],
+ vars["LINK_FLAGS"], frameworkPath, linkPath,
+ &genTarget, useWatcomQuote);
if (this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") &&
(gt.GetType() == cmState::SHARED_LIBRARY ||
gt.IsExecutableWithExports())) {
@@ -497,7 +503,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
this->addPoolNinjaVariable("JOB_POOL_LINK", >, vars);
- this->AddModuleDefinitionFlag(vars["LINK_FLAGS"]);
+ this->AddModuleDefinitionFlag(linkLineComputer.get(), vars["LINK_FLAGS"]);
vars["LINK_FLAGS"] =
cmGlobalNinjaGenerator::EncodeLiteral(vars["LINK_FLAGS"]);
diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx
index a2bdf49..a58510e 100644
--- a/Source/cmServerProtocol.cxx
+++ b/Source/cmServerProtocol.cxx
@@ -7,6 +7,7 @@
#include "cmFileMonitor.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h"
+#include "cmLinkLineComputer.h"
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
@@ -728,8 +729,12 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
std::string linkLanguageFlags;
std::string frameworkPath;
std::string linkPath;
- lg->GetTargetFlags(config, linkLibs, linkLanguageFlags, linkFlags,
- frameworkPath, linkPath, target, false);
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer(
+ lg->GetGlobalGenerator()->CreateLinkLineComputer(
+ lg->GetStateSnapshot().GetDirectory()));
+ lg->GetTargetFlags(linkLineComputer.get(), config, linkLibs,
+ linkLanguageFlags, linkFlags, frameworkPath, linkPath,
+ target, false);
linkLibs = cmSystemTools::TrimWhitespace(linkLibs);
linkFlags = cmSystemTools::TrimWhitespace(linkFlags);
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 14124f8..4024ddd 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -12,6 +12,7 @@
#include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h"
#include "cmGlobalGeneratorFactory.h"
+#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessenger.h"
@@ -582,8 +583,10 @@ bool cmake::FindPackage(const std::vector<std::string>&
args)
gg->CreateGenerationObjects();
cmGeneratorTarget* gtgt = gg->FindGeneratorTarget(tgt->GetName());
cmLocalGenerator* lg = gtgt->GetLocalGenerator();
- lg->GetTargetFlags(buildType, linkLibs, flags, linkFlags, frameworkPath,
- linkPath, gtgt, false);
+ CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer(
+ gg->CreateLinkLineComputer(lg->GetStateSnapshot().GetDirectory()));
+ lg->GetTargetFlags(linkLineComputer.get(), buildType, linkLibs, flags,
+ linkFlags, frameworkPath, linkPath, gtgt, false);
linkLibs = frameworkPath + linkPath + linkLibs;
printf("%s\n", linkLibs.c_str());
diff --git a/bootstrap b/bootstrap
index 889cc33..fb8b1eb 100755
--- a/bootstrap
+++ b/bootstrap
@@ -297,6 +297,8 @@ CMAKE_CXX_SOURCES="\
cmFileTimeComparison \
cmGlobalUnixMakefileGenerator3 \
cmLocalUnixMakefileGenerator3 \
+ cmLinkLineComputer \
+ cmMSVC60LinkLineComputer \
cmMakefileExecutableTargetGenerator \
cmMakefileLibraryTargetGenerator \
cmMakefileTargetGenerator \
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=511ed264e1b2816d519fb45bd1a86f650d35dbed
commit 511ed264e1b2816d519fb45bd1a86f650d35dbed
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:34 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:34 2016 +0200
cmLocalGenerator: Inline conversion into link computation
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 8fcfb32..40b7999 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1399,7 +1399,14 @@ std::string
cmLocalGenerator::ConvertToLinkReference(std::string const& lib)
#endif
// Normal behavior.
- return this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), lib);
+ std::string relLib = lib;
+ cmState::Directory stateDir = this->GetStateSnapshot().GetDirectory();
+ if (cmOutputConverter::ContainedInDirectory(
+ stateDir.GetCurrentBinary(), lib, stateDir)) {
+ relLib = cmOutputConverter::ForceToRelativePath(
+ stateDir.GetCurrentBinary(), lib);
+ }
+ return relLib;
}
/**
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=6e77e10712d852322e28a9283e7b1385fed01da0
commit 6e77e10712d852322e28a9283e7b1385fed01da0
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:33 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:33 2016 +0200
Ninja: Inline code into ConvertToLinkReference
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index b04c11d..e2bce1b 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -123,7 +123,12 @@ cmGlobalNinjaGenerator*
cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
std::string cmLocalNinjaGenerator::ConvertToLinkReference(
std::string const& lib)
{
- return this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(lib);
+ cmLocalNinjaGenerator* ng = static_cast<cmLocalNinjaGenerator*>(
+ this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0]);
+
+ return cmGlobalNinjaGenerator::ConvertToNinjaPath(
+ lib, ng->GetStateSnapshot().GetDirectory(),
+ this->GetGlobalNinjaGenerator()->GetOutputPathPrefix());
}
std::string cmLocalNinjaGenerator::ConvertToIncludeReference(
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=e5f9caf1260a17aea799487aa7abb2950d3252ce
commit e5f9caf1260a17aea799487aa7abb2950d3252ce
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:33 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:33 2016 +0200
Ninja: Add a new accessor method
For use by extracted code.
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 51a8032..6543c9e 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -337,6 +337,7 @@ public:
bool SupportsImplicitOuts() const;
std::string NinjaOutputPath(std::string const& path);
+ std::string GetOutputPathPrefix() const { return this->OutputPathPrefix; }
bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); }
void StripNinjaOutputPathPrefixAsSuffix(std::string& path);
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=abb1e1d227f3f5e61fa22c57c7f6f0fdca745ace
commit abb1e1d227f3f5e61fa22c57c7f6f0fdca745ace
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:33 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:33 2016 +0200
Ninja: Extract a static path conversion method
It is independent of cmLocalGenerator.
diff --git a/Source/cmGlobalNinjaGenerator.cxx
b/Source/cmGlobalNinjaGenerator.cxx
index 9a7939e..4e74a94 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -830,13 +830,10 @@ static void EnsureTrailingSlash(std::string& path)
#endif
}
-std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
+std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(
+ const std::string& path, cmState::Directory stateDir,
+ std::string const& prefix)
{
- cmLocalNinjaGenerator* ng =
- static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
-
- cmState::Directory stateDir = ng->GetStateSnapshot().GetDirectory();
-
std::string convPath = path;
if (cmOutputConverter::ContainedInDirectory(stateDir.GetCurrentBinary(),
@@ -846,7 +843,7 @@ std::string
cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
}
if (!cmSystemTools::FileIsFullPath(convPath)) {
- convPath = this->OutputPathPrefix + convPath;
+ convPath = prefix + convPath;
}
#ifdef _WIN32
@@ -855,6 +852,15 @@ std::string
cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
return convPath;
}
+std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
+{
+ cmLocalNinjaGenerator* ng =
+ static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
+
+ return ConvertToNinjaPath(path, ng->GetStateSnapshot().GetDirectory(),
+ this->OutputPathPrefix);
+}
+
std::string cmGlobalNinjaGenerator::ConvertToNinjaFolderRule(
const std::string& path)
{
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index dcf7406..51a8032 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -233,6 +233,9 @@ public:
return this->RulesFileStream;
}
+ static std::string ConvertToNinjaPath(const std::string& path,
+ cmState::Directory stateDir,
+ std::string const& prefix);
std::string ConvertToNinjaPath(const std::string& path);
std::string ConvertToNinjaFolderRule(const std::string& path);
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ee661eb0e937bbb683f1deb24faf927add5f060a
commit ee661eb0e937bbb683f1deb24faf927add5f060a
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:33 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:33 2016 +0200
Ninja: Inline conversion to relative path
diff --git a/Source/cmGlobalNinjaGenerator.cxx
b/Source/cmGlobalNinjaGenerator.cxx
index 5bec420..9a7939e 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -837,8 +837,13 @@ std::string
cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
cmState::Directory stateDir = ng->GetStateSnapshot().GetDirectory();
- std::string convPath =
- ng->ConvertToRelativePath(stateDir.GetCurrentBinary(), path);
+ std::string convPath = path;
+
+ if (cmOutputConverter::ContainedInDirectory(stateDir.GetCurrentBinary(),
+ path, stateDir)) {
+ convPath = cmOutputConverter::ForceToRelativePath(
+ stateDir.GetCurrentBinary(), path);
+ }
if (!cmSystemTools::FileIsFullPath(convPath)) {
convPath = this->OutputPathPrefix + convPath;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ec5115eab84226573a8d6903db68d432c1fe147a
commit ec5115eab84226573a8d6903db68d432c1fe147a
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:33 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:33 2016 +0200
Ninja: Get the binary directory from cmState::Directory
This method will be extracted, so don't rely on cmLocalGenerator.
diff --git a/Source/cmGlobalNinjaGenerator.cxx
b/Source/cmGlobalNinjaGenerator.cxx
index aa1e7c2..5bec420 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -834,8 +834,12 @@ std::string
cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
{
cmLocalNinjaGenerator* ng =
static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
- std::string convPath = ng->ConvertToRelativePath(
- this->LocalGenerators[0]->GetState()->GetBinaryDirectory(), path);
+
+ cmState::Directory stateDir = ng->GetStateSnapshot().GetDirectory();
+
+ std::string convPath =
+ ng->ConvertToRelativePath(stateDir.GetCurrentBinary(), path);
+
if (!cmSystemTools::FileIsFullPath(convPath)) {
convPath = this->OutputPathPrefix + convPath;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=44aa69e750a730fde6610acecfef09663d42098f
commit 44aa69e750a730fde6610acecfef09663d42098f
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:32 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:32 2016 +0200
Ninja: Inline output path conversion
diff --git a/Source/cmGlobalNinjaGenerator.cxx
b/Source/cmGlobalNinjaGenerator.cxx
index 5d60c66..aa1e7c2 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -836,7 +836,10 @@ std::string
cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
std::string convPath = ng->ConvertToRelativePath(
this->LocalGenerators[0]->GetState()->GetBinaryDirectory(), path);
- convPath = this->NinjaOutputPath(convPath);
+ if (!cmSystemTools::FileIsFullPath(convPath)) {
+ convPath = this->OutputPathPrefix + convPath;
+ }
+
#ifdef _WIN32
std::replace(convPath.begin(), convPath.end(), '/', '\\');
#endif
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4bd19454ed652c54d278546992f9c3606e1de966
commit 4bd19454ed652c54d278546992f9c3606e1de966
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:32 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:32 2016 +0200
Ninja: Simplify method
HasOutputPathPrefix only checks if OutputPathPrefix is empty. The
following concatenation can be done without the check.
diff --git a/Source/cmGlobalNinjaGenerator.cxx
b/Source/cmGlobalNinjaGenerator.cxx
index f5a0e68..5d60c66 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -1423,7 +1423,7 @@ void cmGlobalNinjaGenerator::InitOutputPathPrefix()
std::string cmGlobalNinjaGenerator::NinjaOutputPath(std::string const& path)
{
- if (!this->HasOutputPathPrefix() || cmSystemTools::FileIsFullPath(path)) {
+ if (cmSystemTools::FileIsFullPath(path)) {
return path;
}
return this->OutputPathPrefix + path;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=8081600219bc8638dd8ce99e6d25a7f35c0cc8f0
commit 8081600219bc8638dd8ce99e6d25a7f35c0cc8f0
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:32 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:32 2016 +0200
cmLocalGenerator: Simplify ConvertToLinkReference
Make conversion to output format the caller responsibility, so that the
method only 'converts to a link reference'.
diff --git a/Source/cmCommonTargetGenerator.cxx
b/Source/cmCommonTargetGenerator.cxx
index 6887a31..14ea1a9 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -75,8 +75,10 @@ void
cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
// Append the flag and value. Use ConvertToLinkReference to help
// vs6's "cl -link" pass it to the linker.
std::string flag = defFileFlag;
- flag += (this->LocalGenerator->ConvertToLinkReference(
- this->ModuleDefinitionFile->GetFullPath()));
+ flag += this->LocalGenerator->ConvertToOutputFormat(
+ this->LocalGenerator->ConvertToLinkReference(
+ this->ModuleDefinitionFile->GetFullPath()),
+ cmOutputConverter::SHELL);
this->LocalGenerator->AppendFlags(flags, flag);
}
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 1f9e4cf..8fcfb32 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1375,8 +1375,7 @@ std::string cmLocalGenerator::GetTargetFortranFlags(
return std::string();
}
-std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
- OutputFormat format)
+std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
// Work-ardound command line parsing limitations in MSVC 6.0
@@ -1393,17 +1392,14 @@ std::string
cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
// Append the rest of the path with no space.
sp += lib.substr(pos);
- // Convert to an output path.
- return this->ConvertToOutputFormat(sp.c_str(), format);
+ return sp;
}
}
}
#endif
// Normal behavior.
- return this->ConvertToOutputFormat(
- this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), lib),
- format);
+ return this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), lib);
}
/**
@@ -1517,7 +1513,8 @@ void cmLocalGenerator::OutputLinkLibraries(std::string&
linkLibraries,
continue;
}
if (li->IsPath) {
- linkLibs += this->ConvertToLinkReference(li->Value, shellFormat);
+ linkLibs += this->ConvertToOutputFormat(
+ this->ConvertToLinkReference(li->Value), shellFormat);
} else {
linkLibs += li->Value;
}
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 19469be..703a507 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -367,9 +367,7 @@ protected:
std::string& CreateSafeUniqueObjectFileName(const std::string& sin,
std::string const& dir_max);
- virtual std::string ConvertToLinkReference(
- std::string const& lib,
- cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL);
+ virtual std::string ConvertToLinkReference(std::string const& lib);
/** Check whether the native build system supports the given
definition. Issues a warning. */
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 5783806..b04c11d 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -121,10 +121,9 @@ cmGlobalNinjaGenerator*
cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
// Virtual protected methods.
std::string cmLocalNinjaGenerator::ConvertToLinkReference(
- std::string const& lib, cmOutputConverter::OutputFormat format)
+ std::string const& lib)
{
- std::string path = this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(lib);
- return this->ConvertToOutputFormat(path, format);
+ return this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(lib);
}
std::string cmLocalNinjaGenerator::ConvertToIncludeReference(
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index 875f8c6..3061b57 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -76,9 +76,7 @@ public:
void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg,
cmNinjaDeps& ninjaDeps);
- std::string ConvertToLinkReference(std::string const& lib,
- cmOutputConverter::OutputFormat format =
- cmOutputConverter::SHELL) CM_OVERRIDE;
+ std::string ConvertToLinkReference(std::string const& lib) CM_OVERRIDE;
void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=fb932b367e1678c3d4395d7af422fa9627666f1a
commit fb932b367e1678c3d4395d7af422fa9627666f1a
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:32 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:32 2016 +0200
cmOutputConverter: Add a flag for IsUnix
Remove the need for method parameters to represent the distinction.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 0f2c60e..05e7d63 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -220,9 +220,11 @@ std::string cmOutputConverter::EscapeForShell(const
std::string& str,
if (this->GetState()->UseNMake()) {
flags |= Shell_Flag_NMake;
}
+ if (!this->GetState()->UseWindowsShell()) {
+ flags |= Shell_Flag_IsUnix;
+ }
- return Shell__GetArgument(str.c_str(), !this->GetState()->UseWindowsShell(),
- flags);
+ return Shell__GetArgument(str.c_str(), flags);
}
std::string cmOutputConverter::EscapeForCMake(const std::string& str)
@@ -251,7 +253,7 @@ std::string cmOutputConverter::EscapeForCMake(const
std::string& str)
std::string cmOutputConverter::EscapeWindowsShellArgument(const char* arg,
int shell_flags)
{
- return Shell__GetArgument(arg, 0, shell_flags);
+ return Shell__GetArgument(arg, shell_flags);
}
cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat(
@@ -337,10 +339,10 @@ int
cmOutputConverter::Shell__CharNeedsQuotesOnWindows(char c)
(c == '>') || (c == '|') || (c == '^'));
}
-int cmOutputConverter::Shell__CharNeedsQuotes(char c, int isUnix, int flags)
+int cmOutputConverter::Shell__CharNeedsQuotes(char c, int flags)
{
/* On Windows the built-in command shell echo never needs quotes. */
- if (!isUnix && (flags & Shell_Flag_EchoWindows)) {
+ if (!(flags & Shell_Flag_IsUnix) && (flags & Shell_Flag_EchoWindows)) {
return 0;
}
@@ -349,7 +351,7 @@ int cmOutputConverter::Shell__CharNeedsQuotes(char c, int
isUnix, int flags)
return 1;
}
- if (isUnix) {
+ if (flags & Shell_Flag_IsUnix) {
/* On UNIX several special characters need quotes to preserve them. */
if (Shell__CharNeedsQuotesOnUnix(c)) {
return 1;
@@ -407,8 +409,7 @@ flag later when we understand applications of this better.
*/
#define KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES 0
-int cmOutputConverter::Shell__ArgumentNeedsQuotes(const char* in, int isUnix,
- int flags)
+int cmOutputConverter::Shell__ArgumentNeedsQuotes(const char* in, int flags)
{
/* The empty string needs quotes. */
if (!*in) {
@@ -440,14 +441,14 @@ int cmOutputConverter::Shell__ArgumentNeedsQuotes(const
char* in, int isUnix,
}
/* Check whether this character needs quotes. */
- if (Shell__CharNeedsQuotes(*c, isUnix, flags)) {
+ if (Shell__CharNeedsQuotes(*c, flags)) {
return 1;
}
}
}
/* On Windows some single character arguments need quotes. */
- if (!isUnix && *in && !*(in + 1)) {
+ if (flags & Shell_Flag_IsUnix && *in && !*(in + 1)) {
char c = *in;
if ((c == '?') || (c == '&') || (c == '^') || (c == '|') || (c == '#')) {
return 1;
@@ -457,8 +458,7 @@ int cmOutputConverter::Shell__ArgumentNeedsQuotes(const
char* in, int isUnix,
return 0;
}
-std::string cmOutputConverter::Shell__GetArgument(const char* in, int isUnix,
- int flags)
+std::string cmOutputConverter::Shell__GetArgument(const char* in, int flags)
{
std::ostringstream out;
@@ -469,11 +469,11 @@ std::string cmOutputConverter::Shell__GetArgument(const
char* in, int isUnix,
int windows_backslashes = 0;
/* Whether the argument must be quoted. */
- int needQuotes = Shell__ArgumentNeedsQuotes(in, isUnix, flags);
+ int needQuotes = Shell__ArgumentNeedsQuotes(in, flags);
if (needQuotes) {
/* Add the opening quote for this argument. */
if (flags & Shell_Flag_WatcomQuote) {
- if (isUnix) {
+ if (flags & Shell_Flag_IsUnix) {
out << '"';
}
out << '\'';
@@ -505,7 +505,7 @@ std::string cmOutputConverter::Shell__GetArgument(const
char* in, int isUnix,
}
/* Check whether this character needs escaping for the shell. */
- if (isUnix) {
+ if (flags & Shell_Flag_IsUnix) {
/* On Unix a few special characters need escaping even inside a
quoted argument. */
if (*c == '\\' || *c == '"' || *c == '`' || *c == '$') {
@@ -602,7 +602,7 @@ std::string cmOutputConverter::Shell__GetArgument(const
char* in, int isUnix,
/* Add the closing quote for this argument. */
if (flags & Shell_Flag_WatcomQuote) {
out << '\'';
- if (isUnix) {
+ if (flags & Shell_Flag_IsUnix) {
out << '"';
}
} else {
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index c3c7e36..596bdf0 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -62,7 +62,9 @@ public:
Shell_Flag_AllowMakeVariables = (1 << 6),
/** The target shell quoting uses extra single Quotes for Watcom tools. */
- Shell_Flag_WatcomQuote = (1 << 7)
+ Shell_Flag_WatcomQuote = (1 << 7),
+
+ Shell_Flag_IsUnix = (1 << 8),
};
std::string EscapeForShell(const std::string& str, bool makeVars = false,
@@ -112,11 +114,11 @@ private:
static int Shell__CharIsWhitespace(char c);
static int Shell__CharNeedsQuotesOnUnix(char c);
static int Shell__CharNeedsQuotesOnWindows(char c);
- static int Shell__CharNeedsQuotes(char c, int isUnix, int flags);
+ static int Shell__CharNeedsQuotes(char c, int flags);
static int Shell__CharIsMakeVariableName(char c);
static const char* Shell__SkipMakeVariables(const char* c);
- static int Shell__ArgumentNeedsQuotes(const char* in, int isUnix, int flags);
- static std::string Shell__GetArgument(const char* in, int isUnix, int flags);
+ static int Shell__ArgumentNeedsQuotes(const char* in, int flags);
+ static std::string Shell__GetArgument(const char* in, int flags);
private:
cmState::Snapshot StateSnapshot;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=608e6fe5f24bc6cbf8f4296994fa3878b49a4557
commit 608e6fe5f24bc6cbf8f4296994fa3878b49a4557
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:32 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:32 2016 +0200
Convert: Inline platform-specific methods
They don't provide real value.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index ec43c57..0f2c60e 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -221,9 +221,8 @@ std::string cmOutputConverter::EscapeForShell(const
std::string& str,
flags |= Shell_Flag_NMake;
}
- return this->GetState()->UseWindowsShell()
- ? Shell_GetArgumentForWindows(str.c_str(), flags)
- : Shell_GetArgumentForUnix(str.c_str(), flags);
+ return Shell__GetArgument(str.c_str(), !this->GetState()->UseWindowsShell(),
+ flags);
}
std::string cmOutputConverter::EscapeForCMake(const std::string& str)
@@ -252,7 +251,7 @@ std::string cmOutputConverter::EscapeForCMake(const
std::string& str)
std::string cmOutputConverter::EscapeWindowsShellArgument(const char* arg,
int shell_flags)
{
- return Shell_GetArgumentForWindows(arg, shell_flags);
+ return Shell__GetArgument(arg, 0, shell_flags);
}
cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat(
@@ -613,15 +612,3 @@ std::string cmOutputConverter::Shell__GetArgument(const
char* in, int isUnix,
return out.str();
}
-
-std::string cmOutputConverter::Shell_GetArgumentForWindows(const char* in,
- int flags)
-{
- return Shell__GetArgument(in, 0, flags);
-}
-
-std::string cmOutputConverter::Shell_GetArgumentForUnix(const char* in,
- int flags)
-{
- return Shell__GetArgument(in, 1, flags);
-}
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index aa0e379..c3c7e36 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -29,8 +29,7 @@ public:
void SetLinkScriptShell(bool linkScriptShell);
/**
- * Flags to pass to Shell_GetArgumentForWindows or
- * Shell_GetArgumentForUnix. These modify the generated
+ * Flags to pass to Shell_GetArgument. These modify the generated
* quoting and escape sequences to work under alternative
* environments.
*/
@@ -66,16 +65,6 @@ public:
Shell_Flag_WatcomQuote = (1 << 7)
};
- /**
- * Transform the given command line argument for use in a Windows or
- * Unix shell. Returns a pointer to the end of the command line
- * argument in the provided output buffer. Flags may be passed to
- * modify the generated quoting and escape sequences to work under
- * alternative environments.
- */
- static std::string Shell_GetArgumentForWindows(const char* in, int flags);
- static std::string Shell_GetArgumentForUnix(const char* in, int flags);
-
std::string EscapeForShell(const std::string& str, bool makeVars = false,
bool forEcho = false,
bool useWatcomQuote = false) const;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=5dcf248bc167a04886fb5388c42d1d11aae61cec
commit 5dcf248bc167a04886fb5388c42d1d11aae61cec
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:32 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:32 2016 +0200
Ninja: Extract identical code from condition
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 4f95415..5783806 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -493,10 +493,8 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
if (ccg.GetWorkingDirectory().empty()) {
output =
this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), output);
- output = this->ConvertToOutputFormat(output, cmOutputConverter::SHELL);
- } else {
- output = this->ConvertToOutputFormat(output, cmOutputConverter::SHELL);
}
+ output = this->ConvertToOutputFormat(output, cmOutputConverter::SHELL);
}
vars.Output = output.c_str();
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3288481c22337a8bdd785d0cd8b725d5abc1351d
commit 3288481c22337a8bdd785d0cd8b725d5abc1351d
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:31 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:31 2016 +0200
Ninja: Replace array access with local variable
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index a681c18..4f95415 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -489,13 +489,13 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
std::string output;
const std::vector<std::string>& outputs = ccg.GetOutputs();
if (!outputs.empty()) {
+ output = outputs[0];
if (ccg.GetWorkingDirectory().empty()) {
- output = this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(),
- outputs[0]);
+ output =
+ this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), output);
output = this->ConvertToOutputFormat(output, cmOutputConverter::SHELL);
} else {
- output =
- this->ConvertToOutputFormat(outputs[0], cmOutputConverter::SHELL);
+ output = this->ConvertToOutputFormat(output, cmOutputConverter::SHELL);
}
}
vars.Output = output.c_str();
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=c7926fe8890a80bb3e9072e903dcadcf4faac4cf
commit c7926fe8890a80bb3e9072e903dcadcf4faac4cf
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:31 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:31 2016 +0200
Ninja: Separate two coupled calls
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 11b87e3..a681c18 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -490,10 +490,9 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
const std::vector<std::string>& outputs = ccg.GetOutputs();
if (!outputs.empty()) {
if (ccg.GetWorkingDirectory().empty()) {
- output = this->ConvertToOutputFormat(
- this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(),
- outputs[0]),
- cmOutputConverter::SHELL);
+ output = this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(),
+ outputs[0]);
+ output = this->ConvertToOutputFormat(output, cmOutputConverter::SHELL);
} else {
output =
this->ConvertToOutputFormat(outputs[0], cmOutputConverter::SHELL);
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=a41cf74b1836899ad9e3c80a8013446e849049ed
commit a41cf74b1836899ad9e3c80a8013446e849049ed
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:31 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:31 2016 +0200
Makefiles: Introduce local RelativePath method
This makes it easier to remove directory-specific state from
cmOutputConverter where it doesn't belong. Of course, this just
relocates the problem to the makefiles generator for now, but that's
better than affecting the core.
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx
b/Source/cmLocalUnixMakefileGenerator3.cxx
index 07b40b7..401319e 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -141,7 +141,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->MaybeConvertToRelativePath(
this->GetBinaryDirectory(), this->GetCurrentBinaryDirectory());
if (this->HomeRelativeOutputPath == ".") {
this->HomeRelativeOutputPath = "";
@@ -548,7 +548,8 @@ void cmLocalUnixMakefileGenerator3::WriteMakeRule(
// Construct the left hand side of the rule.
std::string tgt = cmSystemTools::ConvertToOutputPath(
- this->ConvertToRelativePath(this->GetBinaryDirectory(), target).c_str());
+ this->MaybeConvertToRelativePath(this->GetBinaryDirectory(), target)
+ .c_str());
const char* space = "";
if (tgt.size() == 1) {
@@ -577,7 +578,7 @@ void cmLocalUnixMakefileGenerator3::WriteMakeRule(
dep != depends.end(); ++dep) {
replace = *dep;
replace = cmSystemTools::ConvertToOutputPath(
- this->ConvertToRelativePath(binDir, replace).c_str());
+ this->MaybeConvertToRelativePath(binDir, replace).c_str());
os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n";
}
}
@@ -969,7 +970,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(currentBinDir, cmd);
+ cmd = this->MaybeConvertToRelativePath(currentBinDir, cmd);
}
bool has_slash = cmd.find('/') != cmd.npos;
if (had_slash && !has_slash) {
@@ -994,8 +995,8 @@ void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
if (!outputs.empty()) {
if (workingDir.empty()) {
output = this->ConvertToOutputFormat(
- this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(),
- outputs[0]),
+ this->MaybeConvertToRelativePath(
+ this->GetCurrentBinaryDirectory(), outputs[0]),
cmOutputConverter::SHELL);
} else {
@@ -1082,14 +1083,15 @@ 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(currentBinDir, *f);
+ std::string fc = this->MaybeConvertToRelativePath(currentBinDir, *f);
fout << " " << cmOutputConverter::EscapeForCMake(fc) << "\n";
}
fout << ")\n";
}
std::string remove = "$(CMAKE_COMMAND) -P ";
remove += this->ConvertToOutputFormat(
- this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), cleanfile),
+ this->MaybeConvertToRelativePath(this->GetCurrentBinaryDirectory(),
+ cleanfile),
cmOutputConverter::SHELL);
commands.push_back(remove);
@@ -1858,7 +1860,8 @@ void
cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
}
for (std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i) {
- cmakefileStream << " \"" << this->ConvertToRelativePath(binaryDir, *i)
+ cmakefileStream << " \""
+ << this->MaybeConvertToRelativePath(binaryDir, *i)
<< "\"\n";
}
cmakefileStream << " )\n";
@@ -1923,7 +1926,7 @@ std::string
cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall(
if (!tgt.empty()) {
// The make target is always relative to the top of the build tree.
std::string tgt2 =
- this->ConvertToRelativePath(this->GetBinaryDirectory(), tgt);
+ this->MaybeConvertToRelativePath(this->GetBinaryDirectory(), tgt);
// The target may have been written with windows paths.
cmSystemTools::ConvertToOutputSlashes(tgt2);
@@ -2096,3 +2099,13 @@ void cmLocalUnixMakefileGenerator3::CreateCDCommand(
std::bind1st(std::plus<std::string>(), prefix));
}
}
+
+std::string cmLocalUnixMakefileGenerator3::MaybeConvertToRelativePath(
+ std::string const& base, std::string const& path)
+{
+ if (!cmOutputConverter::ContainedInDirectory(
+ base, path, this->GetStateSnapshot().GetDirectory())) {
+ return path;
+ }
+ return cmOutputConverter::ForceToRelativePath(base, path);
+}
diff --git a/Source/cmLocalUnixMakefileGenerator3.h
b/Source/cmLocalUnixMakefileGenerator3.h
index fc5c8e7..c3ecda4 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -184,6 +184,9 @@ public:
// Eclipse generator.
void GetIndividualFileTargets(std::vector<std::string>& targets);
+ std::string MaybeConvertToRelativePath(std::string const& base,
+ std::string const& path);
+
protected:
void WriteLocalMakefile();
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx
b/Source/cmMakefileExecutableTargetGenerator.cxx
index cb20117..ff97696 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -130,16 +130,16 @@ void
cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
targetFullPathPDB, cmOutputConverter::SHELL);
// Convert to the output path to use in constructing commands.
std::string targetOutPath = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPath),
cmOutputConverter::SHELL);
std::string targetOutPathReal = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal),
cmOutputConverter::SHELL);
std::string targetOutPathImport =
this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
targetFullPathImport),
cmOutputConverter::SHELL);
@@ -215,27 +215,27 @@ 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(
+ exeCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPath));
#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(
+ exeCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
(targetFullPath + ".manifest").c_str()));
#endif
if (targetNameReal != targetName) {
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ exeCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal));
}
if (!targetNameImport.empty()) {
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ exeCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
targetFullPathImport));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
- exeCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ exeCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), implib));
}
}
@@ -243,7 +243,7 @@ void
cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// 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(
+ this->CleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathPDB));
// Add the pre-build and pre-link rules building but not when relinking.
@@ -318,7 +318,7 @@ void
cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
objectDir = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), objectDir),
cmOutputConverter::SHELL);
vars.ObjectDir = objectDir.c_str();
@@ -326,7 +326,7 @@ void
cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
? cmOutputConverter::WATCOMQUOTE
: cmOutputConverter::SHELL;
std::string target = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal),
output);
vars.Target = target.c_str();
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx
b/Source/cmMakefileLibraryTargetGenerator.cxx
index b969bfb..8e25f43 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -305,20 +305,20 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
targetFullPathPDB, cmOutputConverter::SHELL);
std::string targetOutPath = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPath),
cmOutputConverter::SHELL);
std::string targetOutPathSO = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathSO),
cmOutputConverter::SHELL);
std::string targetOutPathReal = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal),
cmOutputConverter::SHELL);
std::string targetOutPathImport =
this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
targetFullPathImport),
cmOutputConverter::SHELL);
@@ -366,24 +366,24 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Clean files associated with this library.
std::vector<std::string> libCleanFiles;
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPath));
if (targetNameReal != targetName) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal));
}
if (targetNameSO != targetName && targetNameSO != targetNameReal) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathSO));
}
if (!targetNameImport.empty()) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
targetFullPathImport));
std::string implib;
if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
implib)) {
- libCleanFiles.push_back(this->LocalGenerator->ConvertToRelativePath(
+ libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), implib));
}
}
@@ -391,14 +391,14 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// 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(
+ this->CleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathPDB));
#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->LocalGenerator->ConvertToRelativePath(
+ libCleanFiles.push_back(this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
(targetFullPath + ".manifest").c_str()));
}
@@ -537,7 +537,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
objectDir = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), objectDir),
cmOutputConverter::SHELL);
@@ -546,7 +546,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
? cmOutputConverter::WATCOMQUOTE
: cmOutputConverter::SHELL;
std::string target = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal),
output);
vars.Target = target.c_str();
diff --git a/Source/cmMakefileTargetGenerator.cxx
b/Source/cmMakefileTargetGenerator.cxx
index e70f09e..a9b2f4e 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -166,7 +166,7 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
for (std::vector<std::string>::const_iterator o = outputs.begin();
o != outputs.end(); ++o) {
this->CleanFiles.push_back(
- this->LocalGenerator->ConvertToRelativePath(currentBinDir, *o));
+ this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir, *o));
}
}
}
@@ -209,8 +209,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
<< this->GlobalGenerator->IncludeDirective << " " << root
<< cmSystemTools::ConvertToOutputPath(
this->LocalGenerator
- ->ConvertToRelativePath(this->LocalGenerator->GetBinaryDirectory(),
- dependFileNameFull)
+ ->MaybeConvertToRelativePath(
+ this->LocalGenerator->GetBinaryDirectory(), dependFileNameFull)
.c_str())
<< "\n\n";
@@ -221,7 +221,7 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
<< this->GlobalGenerator->IncludeDirective << " " << root
<< cmSystemTools::ConvertToOutputPath(
this->LocalGenerator
- ->ConvertToRelativePath(
+ ->MaybeConvertToRelativePath(
this->LocalGenerator->GetBinaryDirectory(),
this->ProgressFileNameFull)
.c_str())
@@ -256,8 +256,9 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
<< this->GlobalGenerator->IncludeDirective << " " << root
<< cmSystemTools::ConvertToOutputPath(
this->LocalGenerator
- ->ConvertToRelativePath(this->LocalGenerator->GetBinaryDirectory(),
- this->FlagFileNameFull)
+ ->MaybeConvertToRelativePath(
+ this->LocalGenerator->GetBinaryDirectory(),
+ this->FlagFileNameFull)
.c_str())
<< "\n\n";
}
@@ -314,9 +315,9 @@ void
cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
output += "/";
output += cmSystemTools::GetFilenameName(input);
this->Generator->CleanFiles.push_back(
- this->Generator->LocalGenerator->ConvertToRelativePath(
+ this->Generator->LocalGenerator->MaybeConvertToRelativePath(
this->Generator->LocalGenerator->GetCurrentBinaryDirectory(), output));
- output = this->Generator->LocalGenerator->ConvertToRelativePath(
+ output = this->Generator->LocalGenerator->MaybeConvertToRelativePath(
this->Generator->LocalGenerator->GetBinaryDirectory(), output);
// Create a rule to copy the content into the bundle.
@@ -518,13 +519,13 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
}
targetOutPathReal = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), targetFullPathReal),
cmOutputConverter::SHELL);
targetOutPathPDB = this->LocalGenerator->ConvertToOutputFormat(
targetFullPathPDB, cmOutputConverter::SHELL);
targetOutPathCompilePDB = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(),
targetFullPathCompilePDB),
cmOutputConverter::SHELL);
@@ -550,13 +551,13 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile(
vars.Object = shellObj.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
objectDir = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), objectDir),
cmOutputConverter::SHELL);
vars.ObjectDir = objectDir.c_str();
std::string objectFileDir = cmSystemTools::GetFilenamePath(obj);
objectFileDir = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), objectFileDir),
cmOutputConverter::SHELL);
vars.ObjectFileDir = objectFileDir.c_str();
@@ -904,7 +905,7 @@ bool cmMakefileTargetGenerator::WriteMakeRule(
// Touch the extra output so "make" knows that it was updated,
// but only if the output was acually created.
std::string const out = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(binDir, *o),
+ this->LocalGenerator->MaybeConvertToRelativePath(binDir, *o),
cmOutputConverter::SHELL);
std::vector<std::string> output_commands;
@@ -1200,7 +1201,8 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
for (std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
i != this->ExternalObjects.end(); ++i) {
- object = this->LocalGenerator->ConvertToRelativePath(currentBinDir, *i);
+ object =
+ this->LocalGenerator->MaybeConvertToRelativePath(currentBinDir, *i);
*this->BuildFileStream << " " << lineContinue << "\n"
<< this->Makefile->GetSafeDefinition(
"CMAKE_OBJECT_NAME");
@@ -1234,7 +1236,7 @@ public:
{
// Construct the name of the next object.
this->NextObject = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), obj),
cmOutputConverter::RESPONSE);
@@ -1289,7 +1291,7 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule(
this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
std::string buildTargetRuleName = dir;
buildTargetRuleName += relink ? "/preinstall" : "/build";
- buildTargetRuleName = this->LocalGenerator->ConvertToRelativePath(
+ buildTargetRuleName = this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetBinaryDirectory(), buildTargetRuleName);
// Build the list of target outputs to drive.
@@ -1479,7 +1481,7 @@ void cmMakefileTargetGenerator::CreateLinkScript(
// Create the makefile command to invoke the link script.
std::string link_command = "$(CMAKE_COMMAND) -E cmake_link_script ";
link_command += this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), linkScriptName),
cmOutputConverter::SHELL);
link_command += " --verbose=$(VERBOSE)";
@@ -1716,14 +1718,14 @@ void cmMakefileTargetGenerator::GenDefFile(
cmd, cmOutputConverter::SHELL);
cmd += " -E __create_def ";
cmd += this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), name_of_def_file),
cmOutputConverter::SHELL);
cmd += " ";
std::string objlist_file = name_of_def_file;
objlist_file += ".objs";
cmd += this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), objlist_file),
cmOutputConverter::SHELL);
real_link_commands.insert(real_link_commands.begin(), cmd);
@@ -1744,7 +1746,7 @@ void cmMakefileTargetGenerator::GenDefFile(
linkFlags += " ";
linkFlags += this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
linkFlags += this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(
+ this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), name_of_def_file),
cmOutputConverter::SHELL);
linkFlags += " ";
diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx
b/Source/cmMakefileUtilityTargetGenerator.cxx
index f40c8fa..ecb29cb 100644
--- a/Source/cmMakefileUtilityTargetGenerator.cxx
+++ b/Source/cmMakefileUtilityTargetGenerator.cxx
@@ -46,7 +46,7 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
<< this->GlobalGenerator->IncludeDirective << " " << root
<< cmSystemTools::ConvertToOutputPath(
this->LocalGenerator
- ->ConvertToRelativePath(
+ ->MaybeConvertToRelativePath(
this->LocalGenerator->GetBinaryDirectory(),
this->ProgressFileNameFull)
.c_str())
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=41aa789e0b1d498e0a160bc2848c9a16fea9d2b5
commit 41aa789e0b1d498e0a160bc2848c9a16fea9d2b5
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:31 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:31 2016 +0200
Fortran: Inline conversion to relative path
Don't use cmOutputConverter method which relies on directory-specific
state.
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index 4c0f688..aaa9d3a 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -707,5 +707,9 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
std::string cmDependsFortran::MaybeConvertToRelativePath(
std::string const& base, std::string const& path)
{
- return this->LocalGenerator->ConvertToRelativePath(base, path);
+ if (!cmOutputConverter::ContainedInDirectory(
+ base, path, this->LocalGenerator->GetStateSnapshot().GetDirectory())) {
+ return path;
+ }
+ return cmOutputConverter::ForceToRelativePath(base, path);
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=cc7832e9bcfea870de73911f1017bdef6a9ff956
commit cc7832e9bcfea870de73911f1017bdef6a9ff956
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:31 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:31 2016 +0200
Fortran: Wrap path convert in a call with a more-suitable name
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index c1c8880..4c0f688 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -198,16 +198,13 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
stamp += ".mod.stamp";
fcStream << "\n";
fcStream << " \""
- << this->LocalGenerator->ConvertToRelativePath(currentBinDir,
- mod_lower)
+ << this->MaybeConvertToRelativePath(currentBinDir, mod_lower)
<< "\"\n";
fcStream << " \""
- << this->LocalGenerator->ConvertToRelativePath(currentBinDir,
- mod_upper)
+ << this->MaybeConvertToRelativePath(currentBinDir, mod_upper)
<< "\"\n";
fcStream << " \""
- << this->LocalGenerator->ConvertToRelativePath(currentBinDir,
- stamp)
+ << this->MaybeConvertToRelativePath(currentBinDir, stamp)
<< "\"\n";
}
fcStream << " )\n";
@@ -323,17 +320,16 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
// Write the include dependencies to the output stream.
std::string binDir = this->LocalGenerator->GetBinaryDirectory();
- std::string obj_i = this->LocalGenerator->ConvertToRelativePath(binDir, obj);
+ std::string obj_i = this->MaybeConvertToRelativePath(binDir, obj);
std::string obj_m = cmSystemTools::ConvertToOutputPath(obj_i.c_str());
internalDepends << obj_i << std::endl;
internalDepends << " " << src << std::endl;
for (std::set<std::string>::const_iterator i = info.Includes.begin();
i != info.Includes.end(); ++i) {
- makeDepends
- << obj_m << ": "
- << cmSystemTools::ConvertToOutputPath(
- this->LocalGenerator->ConvertToRelativePath(binDir, *i).c_str())
- << std::endl;
+ makeDepends << obj_m << ": "
+ << cmSystemTools::ConvertToOutputPath(
+ this->MaybeConvertToRelativePath(binDir, *i).c_str())
+ << std::endl;
internalDepends << " " << *i << std::endl;
}
makeDepends << std::endl;
@@ -359,7 +355,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
proxy += *i;
proxy += ".mod.proxy";
proxy = cmSystemTools::ConvertToOutputPath(
- this->LocalGenerator->ConvertToRelativePath(binDir, proxy).c_str());
+ this->MaybeConvertToRelativePath(binDir, proxy).c_str());
// since we require some things add them to our list of requirements
makeDepends << obj_m << ".requires: " << proxy << std::endl;
@@ -375,8 +371,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
if (!required->second.empty()) {
// This module is known. Depend on its timestamp file.
std::string stampFile = cmSystemTools::ConvertToOutputPath(
- this->LocalGenerator->ConvertToRelativePath(binDir, required->second)
- .c_str());
+ this->MaybeConvertToRelativePath(binDir, required->second).c_str());
makeDepends << obj_m << ": " << stampFile << "\n";
} else {
// This module is not known to CMake. Try to locate it where
@@ -384,7 +379,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
std::string module;
if (this->FindModule(*i, module)) {
module = cmSystemTools::ConvertToOutputPath(
- this->LocalGenerator->ConvertToRelativePath(binDir, module).c_str());
+ this->MaybeConvertToRelativePath(binDir, module).c_str());
makeDepends << obj_m << ": " << module << "\n";
}
}
@@ -398,7 +393,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
proxy += *i;
proxy += ".mod.proxy";
proxy = cmSystemTools::ConvertToOutputPath(
- this->LocalGenerator->ConvertToRelativePath(binDir, proxy).c_str());
+ this->MaybeConvertToRelativePath(binDir, proxy).c_str());
makeDepends << proxy << ": " << obj_m << ".provides" << std::endl;
}
@@ -420,14 +415,14 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
modFile += "/";
modFile += *i;
modFile = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(binDir, modFile),
+ this->MaybeConvertToRelativePath(binDir, modFile),
cmOutputConverter::SHELL);
std::string stampFile = stamp_dir;
stampFile += "/";
stampFile += m;
stampFile += ".mod.stamp";
stampFile = this->LocalGenerator->ConvertToOutputFormat(
- this->LocalGenerator->ConvertToRelativePath(binDir, stampFile),
+ this->MaybeConvertToRelativePath(binDir, stampFile),
cmOutputConverter::SHELL);
makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " << modFile
<< " " << stampFile;
@@ -448,7 +443,7 @@ bool cmDependsFortran::WriteDependenciesReal(const char*
obj,
std::string driver = this->TargetDirectory;
driver += "/build";
driver = cmSystemTools::ConvertToOutputPath(
- this->LocalGenerator->ConvertToRelativePath(binDir, driver).c_str());
+ this->MaybeConvertToRelativePath(binDir, driver).c_str());
makeDepends << driver << ": " << obj_m << ".provides.build\n";
}
@@ -708,3 +703,9 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
// content.
return cmFortranStreamsDiffer(finModFile, finStampFile);
}
+
+std::string cmDependsFortran::MaybeConvertToRelativePath(
+ std::string const& base, std::string const& path)
+{
+ return this->LocalGenerator->ConvertToRelativePath(base, path);
+}
diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h
index 8d347f4..90b82d4 100644
--- a/Source/cmDependsFortran.h
+++ b/Source/cmDependsFortran.h
@@ -78,6 +78,9 @@ protected:
private:
cmDependsFortran(cmDependsFortran const&); // Purposely not implemented.
void operator=(cmDependsFortran const&); // Purposely not implemented.
+
+ std::string MaybeConvertToRelativePath(std::string const& base,
+ std::string const& path);
};
#endif
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=aa1ab4c0c975ca81ca7005e0359573836e930530
commit aa1ab4c0c975ca81ca7005e0359573836e930530
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:30 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:30 2016 +0200
Makefiles: Hardcode the relative location of the CMakeCache file
In this context, currentBinDir refers to the CMAKE_BINARY_DIR because it
comes from the first local generator. GetHomeOutputDirectory is the
same as CMAKE_BINARY_DIR, so the computation here is unnecessary.
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx
b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 4a5cc77..95f6ea8 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -306,16 +306,12 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
// reset lg to the first makefile
lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);
- // Build the path to the cache file.
- std::string cache = this->GetCMakeInstance()->GetHomeOutputDirectory();
- cache += "/CMakeCache.txt";
-
std::string currentBinDir = lg->GetCurrentBinaryDirectory();
// Save the list to the cmake file.
cmakefileStream
<< "# The top level Makefile was generated from the following files:\n"
<< "set(CMAKE_MAKEFILE_DEPENDS\n"
- << " \"" << lg->ConvertToRelativePath(currentBinDir, cache) << "\"\n";
+ << " \"CMakeCache.txt\"\n";
for (std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i) {
cmakefileStream << " \"" << lg->ConvertToRelativePath(currentBinDir, *i)
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1704cd340e9851e0041d275be54bb7be21b40288
commit 1704cd340e9851e0041d275be54bb7be21b40288
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:30 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:30 2016 +0200
Convert: Extract method to determine if paths are in directory
The conditional early return can be moved to clients, which would have
many benefits, notably making cmOutputConverter independent of
directory-specific state.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index be189a6..ec43c57 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -57,13 +57,14 @@ static bool cmOutputConverterNotAbove(const char* a, const
char* b)
cmSystemTools::IsSubDirectory(a, b));
}
-std::string cmOutputConverter::ConvertToRelativePath(
- std::string const& local_path, std::string const& remote_path) const
+bool cmOutputConverter::ContainedInDirectory(std::string const& local_path,
+ std::string const& remote_path,
+ cmState::Directory directory)
{
const std::string relativePathTopBinary =
- this->StateSnapshot.GetDirectory().GetRelativePathTopBinary();
+ directory.GetRelativePathTopBinary();
const std::string relativePathTopSource =
- this->StateSnapshot.GetDirectory().GetRelativePathTopSource();
+ directory.GetRelativePathTopSource();
const bool bothInBinary =
cmOutputConverterNotAbove(local_path.c_str(),
@@ -77,7 +78,14 @@ std::string cmOutputConverter::ConvertToRelativePath(
cmOutputConverterNotAbove(remote_path.c_str(),
relativePathTopSource.c_str());
- if (!(bothInSource || bothInBinary)) {
+ return bothInSource || bothInBinary;
+}
+
+std::string cmOutputConverter::ConvertToRelativePath(
+ std::string const& local_path, std::string const& remote_path) const
+{
+ if (!ContainedInDirectory(local_path, remote_path,
+ this->StateSnapshot.GetDirectory())) {
return remote_path;
}
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index cb0d29e..aa0e379 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -95,6 +95,10 @@ public:
};
static FortranFormat GetFortranFormat(const char* value);
+ static bool ContainedInDirectory(std::string const& local_path,
+ std::string const& remote_path,
+ cmState::Directory directory);
+
/**
* Convert the given remote path to a relative path with respect to
* the given local path. Both paths must use forward slashes and not
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=8de218ceaf8bd1c6a122f245228aa885c82985a7
commit 8de218ceaf8bd1c6a122f245228aa885c82985a7
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:30 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:30 2016 +0200
Convert: Remove asserts which are duplicated in delegate method
This means that we don't encounter the asserts in the case where we
early-return from here.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index dd52747..be189a6 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -60,13 +60,6 @@ static bool cmOutputConverterNotAbove(const char* a, const
char* b)
std::string cmOutputConverter::ConvertToRelativePath(
std::string const& local_path, std::string const& remote_path) const
{
- // The paths should never be quoted.
- assert(local_path[0] != '\"');
- assert(remote_path[0] != '\"');
-
- // The local path should never have a trailing slash.
- assert(local_path.empty() || local_path[local_path.size() - 1] != '/');
-
const std::string relativePathTopBinary =
this->StateSnapshot.GetDirectory().GetRelativePathTopBinary();
const std::string relativePathTopSource =
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=986d8c78d428c6d7ac5d3a8e4ada86e65901ad99
commit 986d8c78d428c6d7ac5d3a8e4ada86e65901ad99
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:30 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:30 2016 +0200
Convert: Remove early return check
This function delegates to another function which does the same check.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index f8c082e..dd52747 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -67,11 +67,6 @@ std::string cmOutputConverter::ConvertToRelativePath(
// The local path should never have a trailing slash.
assert(local_path.empty() || local_path[local_path.size() - 1] != '/');
- // If the path is already relative then just return the path.
- if (!cmSystemTools::FileIsFullPath(remote_path.c_str())) {
- return remote_path;
- }
-
const std::string relativePathTopBinary =
this->StateSnapshot.GetDirectory().GetRelativePathTopBinary();
const std::string relativePathTopSource =
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=21b23658deecb8a8ae0b0be1c7dbd53adb694fe2
commit 21b23658deecb8a8ae0b0be1c7dbd53adb694fe2
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:30 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:30 2016 +0200
Convert: Extract local variables for readability
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 2e74766..f8c082e 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -72,21 +72,22 @@ std::string cmOutputConverter::ConvertToRelativePath(
return remote_path;
}
+ const std::string relativePathTopBinary =
+ this->StateSnapshot.GetDirectory().GetRelativePathTopBinary();
+ const std::string relativePathTopSource =
+ this->StateSnapshot.GetDirectory().GetRelativePathTopSource();
+
const bool bothInBinary =
- cmOutputConverterNotAbove(
- local_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopBinary()) &&
- cmOutputConverterNotAbove(
- remote_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopBinary());
+ cmOutputConverterNotAbove(local_path.c_str(),
+ relativePathTopBinary.c_str()) &&
+ cmOutputConverterNotAbove(remote_path.c_str(),
+ relativePathTopBinary.c_str());
const bool bothInSource =
- cmOutputConverterNotAbove(
- local_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopSource()) &&
- cmOutputConverterNotAbove(
- remote_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopSource());
+ cmOutputConverterNotAbove(local_path.c_str(),
+ relativePathTopSource.c_str()) &&
+ cmOutputConverterNotAbove(remote_path.c_str(),
+ relativePathTopSource.c_str());
if (!(bothInSource || bothInBinary)) {
return remote_path;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=94af779a19c7ed4227a396fd26f1bc22ee26699a
commit 94af779a19c7ed4227a396fd26f1bc22ee26699a
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:30 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:30 2016 +0200
Convert: Extract local variables
Remove comment made obsolete by them.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 0ef9392..2e74766 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -72,20 +72,23 @@ std::string cmOutputConverter::ConvertToRelativePath(
return remote_path;
}
- // Skip conversion if the path and local are not both in the source
- // or both in the binary tree.
- if (!((cmOutputConverterNotAbove(
- local_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopBinary()) &&
- cmOutputConverterNotAbove(
- remote_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopBinary())) ||
- (cmOutputConverterNotAbove(
- local_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopSource()) &&
- cmOutputConverterNotAbove(
- remote_path.c_str(),
- this->StateSnapshot.GetDirectory().GetRelativePathTopSource())))) {
+ const bool bothInBinary =
+ cmOutputConverterNotAbove(
+ local_path.c_str(),
+ this->StateSnapshot.GetDirectory().GetRelativePathTopBinary()) &&
+ cmOutputConverterNotAbove(
+ remote_path.c_str(),
+ this->StateSnapshot.GetDirectory().GetRelativePathTopBinary());
+
+ const bool bothInSource =
+ cmOutputConverterNotAbove(
+ local_path.c_str(),
+ this->StateSnapshot.GetDirectory().GetRelativePathTopSource()) &&
+ cmOutputConverterNotAbove(
+ remote_path.c_str(),
+ this->StateSnapshot.GetDirectory().GetRelativePathTopSource());
+
+ if (!(bothInSource || bothInBinary)) {
return remote_path;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=06455f35cf076326134621cc44a446681e6c90e4
commit 06455f35cf076326134621cc44a446681e6c90e4
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Tue Oct 4 22:56:29 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 22:56:29 2016 +0200
cmOutputConverter: Remove Convert..ForExisting method (#16138)
According to the bug report, the GetShortName used conditionally in this
method is problematic.
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index f24b717..1f9e4cf 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -731,7 +731,8 @@ std::string cmLocalGenerator::ExpandRuleVariable(
std::string replace = this->Makefile->GetSafeDefinition(variable);
// if the variable is not a FLAG then treat it like a path
if (variable.find("_FLAG") == variable.npos) {
- std::string ret = this->ConvertToOutputForExisting(replace);
+ std::string ret =
+ this->ConvertToOutputFormat(replace, cmOutputConverter::SHELL);
// if there is a required first argument to the compiler add it
// to the compiler string
if (compilerArg1) {
@@ -828,7 +829,7 @@ std::string cmLocalGenerator::ConvertToIncludeReference(
std::string const& path, OutputFormat format, bool forceFullPaths)
{
static_cast<void>(forceFullPaths);
- return this->ConvertToOutputForExisting(path, format);
+ return this->ConvertToOutputFormat(path, format);
}
std::string cmLocalGenerator::GetIncludeFlags(
@@ -1500,8 +1501,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string&
linkLibraries,
std::vector<std::string> const& libDirs = cli.GetDirectories();
for (std::vector<std::string>::const_iterator libDir = libDirs.begin();
libDir != libDirs.end(); ++libDir) {
- std::string libpath =
- this->ConvertToOutputForExisting(*libDir, shellFormat);
+ std::string libpath = this->ConvertToOutputFormat(*libDir, shellFormat);
linkPath += " " + libPathFlag;
linkPath += libpath;
linkPath += libPathTerminator;
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx
b/Source/cmLocalUnixMakefileGenerator3.cxx
index 8825b46..07b40b7 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -2078,18 +2078,19 @@ void cmLocalUnixMakefileGenerator3::CreateCDCommand(
// back because the shell keeps the working directory between
// commands.
std::string cmd = cd_cmd;
- cmd += this->ConvertToOutputForExisting(tgtDir);
+ cmd += this->ConvertToOutputFormat(tgtDir, cmOutputConverter::SHELL);
commands.insert(commands.begin(), cmd);
// Change back to the starting directory.
cmd = cd_cmd;
- cmd += this->ConvertToOutputForExisting(relDir);
+ cmd += this->ConvertToOutputFormat(relDir, cmOutputConverter::SHELL);
commands.push_back(cmd);
} else {
// On UNIX we must construct a single shell command to change
// directory and build because make resets the directory between
// each command.
- std::string outputForExisting = this->ConvertToOutputForExisting(tgtDir);
+ std::string outputForExisting =
+ this->ConvertToOutputFormat(tgtDir, cmOutputConverter::SHELL);
std::string prefix = cd_cmd + outputForExisting + " && ";
std::transform(commands.begin(), commands.end(), commands.begin(),
std::bind1st(std::plus<std::string>(), prefix));
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 0b270aa..0ef9392 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -18,25 +18,6 @@ cmOutputConverter::cmOutputConverter(cmState::Snapshot
snapshot)
assert(this->StateSnapshot.IsValid());
}
-std::string cmOutputConverter::ConvertToOutputForExisting(
- const std::string& remote, OutputFormat format) const
-{
- // If this is a windows shell, the result has a space, and the path
- // already exists, we can use a short-path to reference it without a
- // space.
- if (this->GetState()->UseWindowsShell() &&
- remote.find(' ') != std::string::npos &&
- cmSystemTools::FileExists(remote.c_str())) {
- std::string tmp;
- if (cmSystemTools::GetShortPath(remote, tmp)) {
- return this->ConvertToOutputFormat(tmp, format);
- }
- }
-
- // Otherwise, perform standard conversion.
- return this->ConvertToOutputFormat(remote, format);
-}
-
std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source,
OutputFormat output) const
{
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index fd887ae..cb0d29e 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -26,10 +26,6 @@ public:
std::string ConvertDirectorySeparatorsForShell(
const std::string& source) const;
- ///! for existing files convert to output path and short path if spaces
- std::string ConvertToOutputForExisting(const std::string& remote,
- OutputFormat format = SHELL) const;
-
void SetLinkScriptShell(bool linkScriptShell);
/**
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ca5ef925eb1ae2a1e63ae1b0762ddbbef19e49a2
commit ca5ef925eb1ae2a1e63ae1b0762ddbbef19e49a2
Author: Daniel Pfeifer <dan...@pfeifer-mail.de>
AuthorDate: Thu Jun 16 23:25:43 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 20:11:16 2016 +0200
cmOutputConverter: remove unused code
Remove old ConvertToRelativePath function now that all clients have
migrated to the new signature.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index 2ef603b..0b270aa 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -77,15 +77,6 @@ static bool cmOutputConverterNotAbove(const char* a, const
char* b)
}
std::string cmOutputConverter::ConvertToRelativePath(
- const std::vector<std::string>& local, const std::string& in_remote,
- bool force) const
-{
- std::string local_path = cmSystemTools::JoinPath(local);
- return force ? this->ForceToRelativePath(local_path, in_remote)
- : this->ConvertToRelativePath(local_path, in_remote);
-}
-
-std::string cmOutputConverter::ConvertToRelativePath(
std::string const& local_path, std::string const& remote_path) const
{
// The paths should never be quoted.
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index 5979eaa..fd887ae 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -101,17 +101,6 @@ public:
/**
* Convert the given remote path to a relative path with respect to
- * the given local path. The local path must be given in component
- * form (see SystemTools::SplitPath) without a trailing slash. The
- * remote path must use forward slashes and not already be escaped
- * or quoted.
- */
- std::string ConvertToRelativePath(const std::vector<std::string>& local,
- const std::string& in_remote,
- bool force = false) const;
-
- /**
- * Convert the given remote path to a relative path with respect to
* the given local path. Both paths must use forward slashes and not
* already be escaped or quoted.
* The conversion is skipped if the paths are not both in the source
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=490b2d6ee5146c7f097ba8a2759bf720d528abce
commit 490b2d6ee5146c7f097ba8a2759bf720d528abce
Author: Stephen Kelly <steve...@gmail.com>
AuthorDate: Mon Sep 19 22:54:38 2016 +0200
Commit: Stephen Kelly <steve...@gmail.com>
CommitDate: Tue Oct 4 20:11:16 2016 +0200
Xcode: Inline ConvertToRelativePath calls
Avoid violations of Interface Segregation Principle. These two calls
now simply call different methods.
diff --git a/Source/cmGlobalXCodeGenerator.cxx
b/Source/cmGlobalXCodeGenerator.cxx
index 4ff612d..75fc2e4 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -3325,14 +3325,14 @@ std::string
cmGlobalXCodeGenerator::RelativeToSource(const char* p)
{
// We force conversion because Xcode breakpoints do not work unless
// they are in a file named relative to the source tree.
- return this->CurrentLocalGenerator->ConvertToRelativePath(
- this->ProjectSourceDirectoryComponents, p, true);
+ return cmOutputConverter::ForceToRelativePath(
+ cmSystemTools::JoinPath(this->ProjectSourceDirectoryComponents), p);
}
std::string cmGlobalXCodeGenerator::RelativeToBinary(const char* p)
{
return this->CurrentLocalGenerator->ConvertToRelativePath(
- this->ProjectOutputDirectoryComponents, p);
+ cmSystemTools::JoinPath(this->ProjectOutputDirectoryComponents), p);
}
std::string cmGlobalXCodeGenerator::XCodeEscapePath(const std::string& p)
-----------------------------------------------------------------------
Summary of changes:
Source/CMakeLists.txt | 6 ++
Source/cmCommonTargetGenerator.cxx | 10 +-
Source/cmCommonTargetGenerator.h | 4 +-
Source/cmDependsFortran.cxx | 45 +++++----
Source/cmDependsFortran.h | 3 +
Source/cmGhsMultiTargetGenerator.cxx | 8 +-
Source/cmGlobalGenerator.cxx | 14 +++
Source/cmGlobalGenerator.h | 7 ++
Source/cmGlobalNinjaGenerator.cxx | 39 ++++++--
Source/cmGlobalNinjaGenerator.h | 7 ++
Source/cmGlobalUnixMakefileGenerator3.cxx | 6 +-
Source/cmGlobalXCodeGenerator.cxx | 6 +-
Source/cmLinkLineComputer.cxx | 27 ++++++
Source/cmLinkLineComputer.h | 21 +++++
Source/cmLocalGenerator.cxx | 70 +++++---------
Source/cmLocalGenerator.h | 11 +--
Source/cmLocalNinjaGenerator.cxx | 16 +---
Source/cmLocalNinjaGenerator.h | 4 -
Source/cmLocalUnixMakefileGenerator3.cxx | 40 +++++---
Source/cmLocalUnixMakefileGenerator3.h | 3 +
Source/cmMSVC60LinkLineComputer.cxx | 33 +++++++
Source/cmMSVC60LinkLineComputer.h | 18 ++++
Source/cmMakefileExecutableTargetGenerator.cxx | 38 +++++---
Source/cmMakefileLibraryTargetGenerator.cxx | 54 ++++++++---
Source/cmMakefileTargetGenerator.cxx | 60 +++++++-----
Source/cmMakefileUtilityTargetGenerator.cxx | 2 +-
Source/cmNinjaLinkLineComputer.cxx | 19 ++++
Source/cmNinjaLinkLineComputer.h | 23 +++++
Source/cmNinjaNormalTargetGenerator.cxx | 14 ++-
Source/cmOutputConverter.cxx | 119 ++++++++----------------
Source/cmOutputConverter.h | 40 ++------
Source/cmServerProtocol.cxx | 9 +-
Source/cmake.cxx | 7 +-
bootstrap | 2 +
34 files changed, 490 insertions(+), 295 deletions(-)
create mode 100644 Source/cmLinkLineComputer.cxx
create mode 100644 Source/cmLinkLineComputer.h
create mode 100644 Source/cmMSVC60LinkLineComputer.cxx
create mode 100644 Source/cmMSVC60LinkLineComputer.h
create mode 100644 Source/cmNinjaLinkLineComputer.cxx
create mode 100644 Source/cmNinjaLinkLineComputer.h
hooks/post-receive
--
CMake
_______________________________________________
Cmake-commits mailing list
Cmake-commits@cmake.org
http://public.kitware.com/mailman/listinfo/cmake-commits
