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 f62d2c869f7ebbb418bde71bff2ecbfc7a3993b2 (commit) via 4134030434ea88024ef46f9f00b19513fc3cec4c (commit) via f03d446e967af91460ff31eb52d840983b3d8cec (commit) via 3444105f9fe4fcee390c8d616e1a211a078a630b (commit) via 77c4202edc242c96087295585a85a20700bdb26f (commit) via 09b6cc66b09b9689ca01faee5e33ef101b46f972 (commit) via 0c978063259fb013856b617d680cebcdee51ab1a (commit) via 0152a01f11fc46f645fd765cc7b1be76cc07b52a (commit) via 011e6870e4a7f19476c162a8c011fd018d9a7e9c (commit) via cbca80f3516d7e5b2def6105a1b26b44bad7b6fe (commit) via d48f69d0f5f265d1c091a614098cae3ff4325fbe (commit) via ff8e321c6ade784b3f1b3b19a7783788872e44a9 (commit) via 80f57e67eefc905a726f2f35bd1672a188ea4c99 (commit) via 7ef834682547df5e0ccdcd503558dcbf1206a638 (commit) via 69295812065a5d07c07347add2fdcf8f36f993ba (commit) via 5b361fdda0f2808f0368b746a880981ebda0ade0 (commit) via 2e5d1990f382aa42e8a0ad34117ee1e5a9187153 (commit) via b3701f9a5213f2ff5b2bc197e9af5d1f2ff68a9c (commit) from dd75faf01aecc93c32cbc5941d29033e33af0521 (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=f62d2c869f7ebbb418bde71bff2ecbfc7a3993b2 commit f62d2c869f7ebbb418bde71bff2ecbfc7a3993b2 Merge: dd75faf 4134030 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Mon Oct 10 14:44:12 2016 -0400 Commit: CMake Topic Stage <kwro...@kitware.com> CommitDate: Mon Oct 10 14:44:12 2016 -0400 Merge topic 'extract-cmLinkLineComputer' into next 41340304 cmLinkLineComputer: Extract link libraries computation from cmLocalGenerator f03d446e cmLinkLineComputer: Move FrameworkPath computation from cmLocalGenerator 3444105f cmLocalGenerator: Inline last use of local variable 77c4202e cmLinkLineComputer: Move RPath computation from cmLocalGenerator 09b6cc66 cmLinkLineComputer: Move LinkPath computation from cmLocalGenerator 0c978063 cmLinkLineComputer: Move ComputeLinkLibs from cmLocalGenerator 0152a01f cmLocalGenerator: Move variable to where it is used 011e6870 cmLocalGenerator: Use a std::string instead of char* cbca80f3 cmLocalGenerator: Move stringstream to where it is used d48f69d0 cmLocalGenerator: Move flag determination up in the function ff8e321c cmLocalGenerator: Separate stdlib content from library stream 80f57e67 cmLocalGenerator: Separate rpath content from library stream 7ef83468 cmLocalGenerator: Pass link library info to OutputLinkLibraries 69295812 Makefiles: Port CreateLinkLibs to cmLinkLineComputer 5b361fdd cmLinkLineComputer: Extract from cmLocalGenerator 2e5d1990 Ninja: Constify ... https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4134030434ea88024ef46f9f00b19513fc3cec4c commit 4134030434ea88024ef46f9f00b19513fc3cec4c Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:39 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:59 2016 +0200 cmLinkLineComputer: Extract link libraries computation from cmLocalGenerator Hide some methods which no longer need to be public. diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx index 41096ef..24f3578 100644 --- a/Source/cmLinkLineComputer.cxx +++ b/Source/cmLinkLineComputer.cxx @@ -152,3 +152,28 @@ std::string cmLinkLineComputer::ComputeFrameworkPath( } return frameworkPath; } + +std::string cmLinkLineComputer::ComputeLinkLibraries( + cmComputeLinkInformation& cli, std::string const& stdLibString) +{ + std::ostringstream fout; + fout << this->ComputeRPath(cli); + + // Write the library flags to the build rule. + fout << this->ComputeLinkLibs(cli); + + // Add the linker runtime search path if any. + std::string rpath_link = cli.GetRPathLinkString(); + if (!cli.GetRPathLinkFlag().empty() && !rpath_link.empty()) { + fout << cli.GetRPathLinkFlag(); + fout << this->OutputConverter->EscapeForShell(rpath_link, + !this->ForResponse); + fout << " "; + } + + if (!stdLibString.empty()) { + fout << stdLibString << " "; + } + + return fout.str(); +} diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h index f72368a..1fb9b24 100644 --- a/Source/cmLinkLineComputer.h +++ b/Source/cmLinkLineComputer.h @@ -22,18 +22,20 @@ public: virtual std::string ConvertToLinkReference(std::string const& input) const; - std::string ComputeLinkLibs(cmComputeLinkInformation& cli); - std::string ComputeLinkPath(cmComputeLinkInformation& cli, std::string const& libPathFlag, std::string const& libPathTerminator); - std::string ComputeRPath(cmComputeLinkInformation& cli); - std::string ComputeFrameworkPath(cmComputeLinkInformation& cli, std::string const& fwSearchFlag); + std::string ComputeLinkLibraries(cmComputeLinkInformation& cli, + std::string const& stdLibString); + private: + std::string ComputeLinkLibs(cmComputeLinkInformation& cli); + std::string ComputeRPath(cmComputeLinkInformation& cli); + std::string ConvertToOutputFormat(std::string const& input); std::string ConvertToOutputForExisting(std::string const& input); diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index ef9e355..3b19694 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1207,7 +1207,7 @@ void cmLocalGenerator::GetTargetFlags( } if (pcli) { this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, false); + frameworkPath, linkPath); } } break; case cmState::EXECUTABLE: { @@ -1229,7 +1229,7 @@ void cmLocalGenerator::GetTargetFlags( this->AddLanguageFlags(flags, linkLanguage, buildType); if (pcli) { this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, false); + frameworkPath, linkPath); } if (cmSystemTools::IsOn( this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) { @@ -1397,7 +1397,7 @@ std::string cmLocalGenerator::GetTargetFortranFlags( void cmLocalGenerator::OutputLinkLibraries( cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, std::string& frameworkPath, - std::string& linkPath, bool forResponseFile) + std::string& linkPath) { cmComputeLinkInformation& cli = *pcli; @@ -1428,29 +1428,7 @@ void cmLocalGenerator::OutputLinkLibraries( linkPath = linkLineComputer->ComputeLinkPath(cli, libPathFlag, libPathTerminator); - std::string linkLibs = linkLineComputer->ComputeLinkLibs(cli); - - std::string rpath = linkLineComputer->ComputeRPath(cli); - - std::ostringstream fout; - fout << rpath; - - // Write the library flags to the build rule. - fout << linkLibs; - - // Add the linker runtime search path if any. - std::string rpath_link = cli.GetRPathLinkString(); - if (!cli.GetRPathLinkFlag().empty() && !rpath_link.empty()) { - fout << cli.GetRPathLinkFlag(); - fout << this->EscapeForShell(rpath_link, !forResponseFile); - fout << " "; - } - - if (!stdLibString.empty()) { - fout << stdLibString << " "; - } - - linkLibraries = fout.str(); + linkLibraries = linkLineComputer->ComputeLinkLibraries(cli, stdLibString); } std::string cmLocalGenerator::GetLinkLibsCMP0065( diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 4729acb..69c4101 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -351,8 +351,7 @@ protected: void OutputLinkLibraries(cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, - std::string& frameworkPath, std::string& linkPath, - bool forResponseFile); + std::string& frameworkPath, std::string& linkPath); // Expand rule variables in CMake of the type found in language rules void ExpandRuleVariables(std::string& string, diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index e93c31d..1483fbb 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -1610,8 +1610,7 @@ void cmMakefileTargetGenerator::CreateLinkLibs( cmComputeLinkInformation* pcli = this->GeneratorTarget->GetLinkInformation(config); this->LocalGenerator->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, - useResponseFile); + frameworkPath, linkPath); linkLibs = frameworkPath + linkPath + linkLibs; if (useResponseFile && linkLibs.find_first_not_of(' ') != linkLibs.npos) { https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=f03d446e967af91460ff31eb52d840983b3d8cec commit f03d446e967af91460ff31eb52d840983b3d8cec Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:39 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:59 2016 +0200 cmLinkLineComputer: Move FrameworkPath computation from cmLocalGenerator Add UseWatcomQuote state, and remove corresponding method parameters. diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx index 04c45e5..5fbaea4 100644 --- a/Source/cmGhsMultiTargetGenerator.cxx +++ b/Source/cmGhsMultiTargetGenerator.cxx @@ -367,10 +367,11 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries( this->GetGlobalGenerator()->CreateLinkLineComputer( this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); + linkLineComputer->SetUseWatcomQuote(useWatcomQuote); this->LocalGenerator->GetTargetFlags( linkLineComputer.get(), config, linkLibraries, flags, linkFlags, - frameworkPath, linkPath, this->GeneratorTarget, useWatcomQuote); + frameworkPath, linkPath, this->GeneratorTarget); linkFlags = cmSystemTools::TrimWhitespace(linkFlags); if (!linkPath.empty()) { diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx index 3675887..41096ef 100644 --- a/Source/cmLinkLineComputer.cxx +++ b/Source/cmLinkLineComputer.cxx @@ -136,3 +136,19 @@ std::string cmLinkLineComputer::ComputeRPath(cmComputeLinkInformation& cli) } return rpath; } + +std::string cmLinkLineComputer::ComputeFrameworkPath( + cmComputeLinkInformation& cli, std::string const& fwSearchFlag) +{ + std::string frameworkPath; + if (!fwSearchFlag.empty()) { + std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths(); + for (std::vector<std::string>::const_iterator fdi = fwDirs.begin(); + fdi != fwDirs.end(); ++fdi) { + frameworkPath += fwSearchFlag; + frameworkPath += this->ConvertToOutputFormat(*fdi); + frameworkPath += " "; + } + } + return frameworkPath; +} diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h index d33e832..f72368a 100644 --- a/Source/cmLinkLineComputer.h +++ b/Source/cmLinkLineComputer.h @@ -30,6 +30,9 @@ public: std::string ComputeRPath(cmComputeLinkInformation& cli); + std::string ComputeFrameworkPath(cmComputeLinkInformation& cli, + std::string const& fwSearchFlag); + private: std::string ConvertToOutputFormat(std::string const& input); std::string ConvertToOutputForExisting(std::string const& input); diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index d41399a..ef9e355 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1151,8 +1151,7 @@ void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags, void cmLocalGenerator::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) + std::string& frameworkPath, std::string& linkPath, cmGeneratorTarget* target) { const std::string buildType = cmSystemTools::UpperCase(config); cmComputeLinkInformation* pcli = target->GetLinkInformation(config); @@ -1208,8 +1207,7 @@ void cmLocalGenerator::GetTargetFlags( } if (pcli) { this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, false, - useWatcomQuote); + frameworkPath, linkPath, false); } } break; case cmState::EXECUTABLE: { @@ -1231,8 +1229,7 @@ void cmLocalGenerator::GetTargetFlags( this->AddLanguageFlags(flags, linkLanguage, buildType); if (pcli) { this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, false, - useWatcomQuote); + frameworkPath, linkPath, false); } if (cmSystemTools::IsOn( this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) { @@ -1400,10 +1397,8 @@ std::string cmLocalGenerator::GetTargetFortranFlags( void cmLocalGenerator::OutputLinkLibraries( cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, std::string& frameworkPath, - std::string& linkPath, bool forResponseFile, bool useWatcomQuote) + std::string& linkPath, bool forResponseFile) { - OutputFormat shellFormat = - (forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL); cmComputeLinkInformation& cli = *pcli; std::string linkLanguage = cli.GetLinkLanguage(); @@ -1428,16 +1423,8 @@ void cmLocalGenerator::OutputLinkLibraries( fwSearchFlagVar += "_FRAMEWORK_SEARCH_FLAG"; std::string fwSearchFlag = this->Makefile->GetSafeDefinition(fwSearchFlagVar); - if (!fwSearchFlag.empty()) { - std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths(); - for (std::vector<std::string>::const_iterator fdi = fwDirs.begin(); - fdi != fwDirs.end(); ++fdi) { - frameworkPath += fwSearchFlag; - frameworkPath += this->ConvertToOutputFormat(*fdi, shellFormat); - frameworkPath += " "; - } - } + frameworkPath = linkLineComputer->ComputeFrameworkPath(cli, fwSearchFlag); linkPath = linkLineComputer->ComputeLinkPath(cli, libPathFlag, libPathTerminator); diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 75e01cb..4729acb 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -318,7 +318,7 @@ public: const std::string& config, std::string& linkLibs, std::string& flags, std::string& linkFlags, std::string& frameworkPath, std::string& linkPath, - cmGeneratorTarget* target, bool useWatcomQuote); + cmGeneratorTarget* target); void GetTargetDefines(cmGeneratorTarget const* target, std::string const& config, std::string const& lang, std::set<std::string>& defines) const; @@ -352,7 +352,7 @@ protected: cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, std::string& frameworkPath, std::string& linkPath, - bool forResponseFile, bool useWatcomQuote); + bool forResponseFile); // Expand rule variables in CMake of the type found in language rules void ExpandRuleVariables(std::string& string, diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index f17e012..bfc4857 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -315,7 +315,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) // Collect up flags to link in needed libraries. std::string linkLibs; this->CreateLinkLibs(linkLineComputer.get(), linkLibs, - useResponseFileForLibs, depends, useWatcomQuote); + useResponseFileForLibs, depends); // Construct object file lists that may be needed to expand the // rule. diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index e0934b5..4488f06 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -514,7 +514,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules( linkLineComputer->SetRelink(relink); this->CreateLinkLibs(linkLineComputer.get(), linkLibs, - useResponseFileForLibs, depends, useWatcomQuote); + useResponseFileForLibs, depends); } // Construct object file lists that may be needed to expand the diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index 2c0c91c..e93c31d 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -1602,8 +1602,7 @@ cmLinkLineComputer* cmMakefileTargetGenerator::CreateLinkLineComputer( void cmMakefileTargetGenerator::CreateLinkLibs( cmLinkLineComputer* linkLineComputer, std::string& linkLibs, - bool useResponseFile, std::vector<std::string>& makefile_depends, - bool useWatcomQuote) + bool useResponseFile, std::vector<std::string>& makefile_depends) { std::string frameworkPath; std::string linkPath; @@ -1612,7 +1611,7 @@ void cmMakefileTargetGenerator::CreateLinkLibs( this->GeneratorTarget->GetLinkInformation(config); this->LocalGenerator->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, frameworkPath, linkPath, - useResponseFile, useWatcomQuote); + useResponseFile); linkLibs = frameworkPath + linkPath + linkLibs; if (useResponseFile && linkLibs.find_first_not_of(' ') != linkLibs.npos) { diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index 846b310..526cbcd 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -155,8 +155,7 @@ protected: /** Create list of flags for link libraries. */ void CreateLinkLibs(cmLinkLineComputer* linkLineComputer, std::string& linkLibs, bool useResponseFile, - std::vector<std::string>& makefile_depends, - bool useWatcomQuote); + std::vector<std::string>& makefile_depends); /** Create lists of object files for linking and cleaning. */ void CreateObjectLists(bool useLinkScript, bool useArchiveRules, diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index a458bbb..ab086eb 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -475,11 +475,11 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() this->GetGlobalGenerator()->CreateLinkLineComputer( this->GetLocalGenerator(), this->GetLocalGenerator()->GetStateSnapshot().GetDirectory())); + linkLineComputer->SetUseWatcomQuote(useWatcomQuote); - localGen.GetTargetFlags(linkLineComputer.get(), this->GetConfigName(), - vars["LINK_LIBRARIES"], vars["FLAGS"], - vars["LINK_FLAGS"], frameworkPath, linkPath, - &genTarget, useWatcomQuote); + localGen.GetTargetFlags( + linkLineComputer.get(), this->GetConfigName(), vars["LINK_LIBRARIES"], + vars["FLAGS"], vars["LINK_FLAGS"], frameworkPath, linkPath, &genTarget); if (this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") && (gt.GetType() == cmState::SHARED_LIBRARY || gt.IsExecutableWithExports())) { diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx index d537cfd..e0fcb75 100644 --- a/Source/cmServerProtocol.cxx +++ b/Source/cmServerProtocol.cxx @@ -732,7 +732,7 @@ static Json::Value DumpTarget(cmGeneratorTarget* target, cmLinkLineComputer linkLineComputer(lg, lg->GetStateSnapshot().GetDirectory()); lg->GetTargetFlags(&linkLineComputer, config, linkLibs, linkLanguageFlags, - linkFlags, frameworkPath, linkPath, target, false); + linkFlags, frameworkPath, linkPath, target); linkLibs = cmSystemTools::TrimWhitespace(linkLibs); linkFlags = cmSystemTools::TrimWhitespace(linkFlags); diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 50f77f4..e0f4000 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -586,7 +586,7 @@ bool cmake::FindPackage(const std::vector<std::string>& args) cmLinkLineComputer linkLineComputer(lg, lg->GetStateSnapshot().GetDirectory()); lg->GetTargetFlags(&linkLineComputer, buildType, linkLibs, flags, - linkFlags, frameworkPath, linkPath, gtgt, false); + linkFlags, frameworkPath, linkPath, gtgt); linkLibs = frameworkPath + linkPath + linkLibs; printf("%s\n", linkLibs.c_str()); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3444105f9fe4fcee390c8d616e1a211a078a630b commit 3444105f9fe4fcee390c8d616e1a211a078a630b Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:38 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:59 2016 +0200 cmLocalGenerator: Inline last use of local variable diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 63c8aef..d41399a 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1404,8 +1404,6 @@ void cmLocalGenerator::OutputLinkLibraries( { OutputFormat shellFormat = (forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL); - bool escapeAllowMakeVars = !forResponseFile; - cmComputeLinkInformation& cli = *pcli; std::string linkLanguage = cli.GetLinkLanguage(); @@ -1457,7 +1455,7 @@ void cmLocalGenerator::OutputLinkLibraries( std::string rpath_link = cli.GetRPathLinkString(); if (!cli.GetRPathLinkFlag().empty() && !rpath_link.empty()) { fout << cli.GetRPathLinkFlag(); - fout << this->EscapeForShell(rpath_link, escapeAllowMakeVars); + fout << this->EscapeForShell(rpath_link, !forResponseFile); fout << " "; } https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=77c4202edc242c96087295585a85a20700bdb26f commit 77c4202edc242c96087295585a85a20700bdb26f Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:38 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:59 2016 +0200 cmLinkLineComputer: Move RPath computation from cmLocalGenerator Add state for Relink and populate it at the point of cmLinkLineComputer initialization. This allows removal of the parameter in go-between methods. diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx index a5e8b72..3675887 100644 --- a/Source/cmLinkLineComputer.cxx +++ b/Source/cmLinkLineComputer.cxx @@ -12,6 +12,7 @@ cmLinkLineComputer::cmLinkLineComputer(cmOutputConverter* outputConverter, , OutputConverter(outputConverter) , ForResponse(false) , UseWatcomQuote(false) + , Relink(false) { } @@ -29,6 +30,11 @@ void cmLinkLineComputer::SetForResponse(bool forResponse) this->ForResponse = forResponse; } +void cmLinkLineComputer::SetRelink(bool relink) +{ + this->Relink = relink; +} + std::string cmLinkLineComputer::ConvertToLinkReference( std::string const& lib) const { @@ -100,3 +106,33 @@ std::string cmLinkLineComputer::ComputeLinkPath( } return linkPath; } + +std::string cmLinkLineComputer::ComputeRPath(cmComputeLinkInformation& cli) +{ + std::string rpath; + // Check what kind of rpath flags to use. + if (cli.GetRuntimeSep().empty()) { + // Each rpath entry gets its own option ("-R a -R b -R c") + std::vector<std::string> runtimeDirs; + cli.GetRPath(runtimeDirs, this->Relink); + + for (std::vector<std::string>::iterator ri = runtimeDirs.begin(); + ri != runtimeDirs.end(); ++ri) { + rpath += cli.GetRuntimeFlag(); + rpath += this->ConvertToOutputFormat(*ri); + rpath += " "; + } + } else { + // All rpath entries are combined ("-Wl,-rpath,a:b:c"). + std::string rpathString = cli.GetRPathString(this->Relink); + + // Store the rpath option in the stream. + if (!rpathString.empty()) { + rpath += cli.GetRuntimeFlag(); + rpath += + this->OutputConverter->EscapeForShell(rpathString, !this->ForResponse); + rpath += " "; + } + } + return rpath; +} diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h index d38213f..d33e832 100644 --- a/Source/cmLinkLineComputer.h +++ b/Source/cmLinkLineComputer.h @@ -18,6 +18,7 @@ public: void SetUseWatcomQuote(bool useWatcomQuote); void SetForResponse(bool forResponse); + void SetRelink(bool relink); virtual std::string ConvertToLinkReference(std::string const& input) const; @@ -27,6 +28,8 @@ public: std::string const& libPathFlag, std::string const& libPathTerminator); + std::string ComputeRPath(cmComputeLinkInformation& cli); + private: std::string ConvertToOutputFormat(std::string const& input); std::string ConvertToOutputForExisting(std::string const& input); @@ -36,6 +39,7 @@ private: bool ForResponse; bool UseWatcomQuote; + bool Relink; }; #endif diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index ab3d3b6..63c8aef 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1208,7 +1208,7 @@ void cmLocalGenerator::GetTargetFlags( } if (pcli) { this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, false, false, + frameworkPath, linkPath, false, useWatcomQuote); } } break; @@ -1231,7 +1231,7 @@ void cmLocalGenerator::GetTargetFlags( this->AddLanguageFlags(flags, linkLanguage, buildType); if (pcli) { this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, false, false, + frameworkPath, linkPath, false, useWatcomQuote); } if (cmSystemTools::IsOn( @@ -1400,8 +1400,7 @@ std::string cmLocalGenerator::GetTargetFortranFlags( void cmLocalGenerator::OutputLinkLibraries( cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, std::string& frameworkPath, - std::string& linkPath, bool relink, bool forResponseFile, - bool useWatcomQuote) + std::string& linkPath, bool forResponseFile, bool useWatcomQuote) { OutputFormat shellFormat = (forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL); @@ -1446,31 +1445,7 @@ void cmLocalGenerator::OutputLinkLibraries( std::string linkLibs = linkLineComputer->ComputeLinkLibs(cli); - std::string rpath; - - // Check what kind of rpath flags to use. - if (cli.GetRuntimeSep().empty()) { - // Each rpath entry gets its own option ("-R a -R b -R c") - std::vector<std::string> runtimeDirs; - cli.GetRPath(runtimeDirs, relink); - - for (std::vector<std::string>::iterator ri = runtimeDirs.begin(); - ri != runtimeDirs.end(); ++ri) { - rpath += cli.GetRuntimeFlag(); - rpath += this->ConvertToOutputFormat(*ri, shellFormat); - rpath += " "; - } - } else { - // All rpath entries are combined ("-Wl,-rpath,a:b:c"). - std::string rpathString = cli.GetRPathString(relink); - - // Store the rpath option in the stream. - if (!rpathString.empty()) { - rpath += cli.GetRuntimeFlag(); - rpath += this->EscapeForShell(rpathString, escapeAllowMakeVars); - rpath += " "; - } - } + std::string rpath = linkLineComputer->ComputeRPath(cli); std::ostringstream fout; fout << rpath; diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 12b2b69..75e01cb 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -352,8 +352,7 @@ protected: cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, std::string& frameworkPath, std::string& linkPath, - bool relink, bool forResponseFile, - bool useWatcomQuote); + bool forResponseFile, bool useWatcomQuote); // Expand rule variables in CMake of the type found in language rules void ExpandRuleVariables(std::string& string, diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index eaa5061..f17e012 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -310,10 +310,11 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->LocalGenerator->GetStateSnapshot().GetDirectory())); linkLineComputer->SetForResponse(useResponseFileForLibs); linkLineComputer->SetUseWatcomQuote(useWatcomQuote); + linkLineComputer->SetRelink(relink); // Collect up flags to link in needed libraries. std::string linkLibs; - this->CreateLinkLibs(linkLineComputer.get(), linkLibs, relink, + this->CreateLinkLibs(linkLineComputer.get(), linkLibs, useResponseFileForLibs, depends, useWatcomQuote); // Construct object file lists that may be needed to expand the diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index ccc6d9f..e0934b5 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -511,8 +511,9 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules( this->LocalGenerator->GetStateSnapshot().GetDirectory())); linkLineComputer->SetForResponse(useResponseFileForLibs); linkLineComputer->SetUseWatcomQuote(useWatcomQuote); + linkLineComputer->SetRelink(relink); - this->CreateLinkLibs(linkLineComputer.get(), linkLibs, relink, + this->CreateLinkLibs(linkLineComputer.get(), linkLibs, useResponseFileForLibs, depends, useWatcomQuote); } diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index d9102a6..2c0c91c 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -1601,7 +1601,7 @@ cmLinkLineComputer* cmMakefileTargetGenerator::CreateLinkLineComputer( } void cmMakefileTargetGenerator::CreateLinkLibs( - cmLinkLineComputer* linkLineComputer, std::string& linkLibs, bool relink, + cmLinkLineComputer* linkLineComputer, std::string& linkLibs, bool useResponseFile, std::vector<std::string>& makefile_depends, bool useWatcomQuote) { @@ -1611,7 +1611,7 @@ void cmMakefileTargetGenerator::CreateLinkLibs( cmComputeLinkInformation* pcli = this->GeneratorTarget->GetLinkInformation(config); this->LocalGenerator->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, - frameworkPath, linkPath, relink, + frameworkPath, linkPath, useResponseFile, useWatcomQuote); linkLibs = frameworkPath + linkPath + linkLibs; diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index 0930d89..846b310 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -154,7 +154,7 @@ protected: /** Create list of flags for link libraries. */ void CreateLinkLibs(cmLinkLineComputer* linkLineComputer, - std::string& linkLibs, bool relink, bool useResponseFile, + std::string& linkLibs, bool useResponseFile, std::vector<std::string>& makefile_depends, bool useWatcomQuote); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=09b6cc66b09b9689ca01faee5e33ef101b46f972 commit 09b6cc66b09b9689ca01faee5e33ef101b46f972 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:38 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:58 2016 +0200 cmLinkLineComputer: Move LinkPath computation from cmLocalGenerator Add a ConvertToOutputForExisting method which can be made virtual later to satisfy different generator needs. Pass additional strings as parameters for now. They can be turned into class state later. diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx index b2b56bf..a5e8b72 100644 --- a/Source/cmLinkLineComputer.cxx +++ b/Source/cmLinkLineComputer.cxx @@ -72,3 +72,31 @@ std::string cmLinkLineComputer::ConvertToOutputFormat(std::string const& input) return this->OutputConverter->ConvertToOutputFormat(input, shellFormat); } + +std::string cmLinkLineComputer::ConvertToOutputForExisting( + std::string const& input) +{ + cmOutputConverter::OutputFormat shellFormat = (this->ForResponse) + ? cmOutputConverter::RESPONSE + : ((this->UseWatcomQuote) ? cmOutputConverter::WATCOMQUOTE + : cmOutputConverter::SHELL); + + return this->OutputConverter->ConvertToOutputForExisting(input, shellFormat); +} + +std::string cmLinkLineComputer::ComputeLinkPath( + cmComputeLinkInformation& cli, std::string const& libPathFlag, + std::string const& libPathTerminator) +{ + std::string linkPath; + 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); + linkPath += " " + libPathFlag; + linkPath += libpath; + linkPath += libPathTerminator; + linkPath += " "; + } + return linkPath; +} diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h index 2317385..d38213f 100644 --- a/Source/cmLinkLineComputer.h +++ b/Source/cmLinkLineComputer.h @@ -23,8 +23,13 @@ public: std::string ComputeLinkLibs(cmComputeLinkInformation& cli); + std::string ComputeLinkPath(cmComputeLinkInformation& cli, + std::string const& libPathFlag, + std::string const& libPathTerminator); + private: std::string ConvertToOutputFormat(std::string const& input); + std::string ConvertToOutputForExisting(std::string const& input); cmState::Directory StateDir; cmOutputConverter* OutputConverter; diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 0d2fe86..ab3d3b6 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1441,17 +1441,8 @@ void cmLocalGenerator::OutputLinkLibraries( } } - // Append the library search path flags. - 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); - linkPath += " " + libPathFlag; - linkPath += libpath; - linkPath += libPathTerminator; - linkPath += " "; - } + linkPath = + linkLineComputer->ComputeLinkPath(cli, libPathFlag, libPathTerminator); std::string linkLibs = linkLineComputer->ComputeLinkLibs(cli); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=0c978063259fb013856b617d680cebcdee51ab1a commit 0c978063259fb013856b617d680cebcdee51ab1a Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:38 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:58 2016 +0200 cmLinkLineComputer: Move ComputeLinkLibs from cmLocalGenerator Add a cmOutputConverter to the cmLinkLineComputer and factory methods to facilitate shell escapes. Add state to the cmLinkLineComputer to record whether outputting for response files or for watcom, to satisfy the cmOutputConverter API. These are constant for the lifetime of the cmLinkLineComputer, even when its functionality is extended in the future. This also keeps the signatures of cmLinkLineComputer relatively simple. Pass the cmComputeLinkInformation as a method parameter so that cmLinkLineComputer is free from target-specific state. An instance should be usable for all targets in a directory. diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx index 959bfc1..04c45e5 100644 --- a/Source/cmGhsMultiTargetGenerator.cxx +++ b/Source/cmGhsMultiTargetGenerator.cxx @@ -365,6 +365,7 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries( this->Makefile->IsOn(createRule + "_USE_WATCOM_QUOTE"); CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->GetGlobalGenerator()->CreateLinkLineComputer( + this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetTargetFlags( diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 2266e44..1aa6af1 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -1415,15 +1415,15 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets() } cmLinkLineComputer* cmGlobalGenerator::CreateLinkLineComputer( - cmState::Directory stateDir) const + cmOutputConverter* outputConverter, cmState::Directory stateDir) const { - return new cmLinkLineComputer(stateDir); + return new cmLinkLineComputer(outputConverter, stateDir); } cmLinkLineComputer* cmGlobalGenerator::CreateMSVC60LinkLineComputer( - cmState::Directory stateDir) const + cmOutputConverter* outputConverter, cmState::Directory stateDir) const { - return new cmMSVC60LinkLineComputer(stateDir); + return new cmMSVC60LinkLineComputer(outputConverter, stateDir); } void cmGlobalGenerator::FinalizeTargetCompileInfo() diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index 126eb6f..38eaa76 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -36,6 +36,7 @@ class cmGeneratorTarget; class cmLocalGenerator; class cmLinkLineComputer; class cmMakefile; +class cmOutputConverter; class cmake; /** \class cmGlobalGenerator @@ -107,10 +108,10 @@ public: virtual void Generate(); virtual cmLinkLineComputer* CreateLinkLineComputer( - cmState::Directory stateDir) const; + cmOutputConverter* outputConverter, cmState::Directory stateDir) const; cmLinkLineComputer* CreateMSVC60LinkLineComputer( - cmState::Directory stateDir) const; + cmOutputConverter* outputConverter, cmState::Directory stateDir) const; /** * Set/Get and Clear the enabled languages. diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index 65a1f25..67df038 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -66,9 +66,10 @@ void cmGlobalNinjaGenerator::WriteComment(std::ostream& os, } cmLinkLineComputer* cmGlobalNinjaGenerator::CreateLinkLineComputer( - cmState::Directory /* stateDir */) const + cmOutputConverter* outputConverter, cmState::Directory /* stateDir */) const { return new cmNinjaLinkLineComputer( + outputConverter, this->LocalGenerators[0]->GetStateSnapshot().GetDirectory(), this); } diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index 87faf45..6b77a2b 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -70,8 +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; + cmLinkLineComputer* CreateLinkLineComputer( + cmOutputConverter* outputConverter, + cmState::Directory stateDir) const CM_OVERRIDE; /** * Write the given @a comment to the output stream @a os. It diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx index 7103a5b..b2b56bf 100644 --- a/Source/cmLinkLineComputer.cxx +++ b/Source/cmLinkLineComputer.cxx @@ -2,10 +2,16 @@ file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmLinkLineComputer.h" +#include "cmComputeLinkInformation.h" +#include "cmGeneratorTarget.h" #include "cmOutputConverter.h" -cmLinkLineComputer::cmLinkLineComputer(cmState::Directory stateDir) +cmLinkLineComputer::cmLinkLineComputer(cmOutputConverter* outputConverter, + cmState::Directory stateDir) : StateDir(stateDir) + , OutputConverter(outputConverter) + , ForResponse(false) + , UseWatcomQuote(false) { } @@ -13,6 +19,16 @@ cmLinkLineComputer::~cmLinkLineComputer() { } +void cmLinkLineComputer::SetUseWatcomQuote(bool useWatcomQuote) +{ + this->UseWatcomQuote = useWatcomQuote; +} + +void cmLinkLineComputer::SetForResponse(bool forResponse) +{ + this->ForResponse = forResponse; +} + std::string cmLinkLineComputer::ConvertToLinkReference( std::string const& lib) const { @@ -25,3 +41,34 @@ std::string cmLinkLineComputer::ConvertToLinkReference( } return relLib; } + +std::string cmLinkLineComputer::ComputeLinkLibs(cmComputeLinkInformation& cli) +{ + std::string linkLibs; + typedef cmComputeLinkInformation::ItemVector ItemVector; + ItemVector const& items = cli.GetItems(); + for (ItemVector::const_iterator li = items.begin(); li != items.end(); + ++li) { + if (li->Target && li->Target->GetType() == cmState::INTERFACE_LIBRARY) { + continue; + } + if (li->IsPath) { + linkLibs += + this->ConvertToOutputFormat(this->ConvertToLinkReference(li->Value)); + } else { + linkLibs += li->Value; + } + linkLibs += " "; + } + return linkLibs; +} + +std::string cmLinkLineComputer::ConvertToOutputFormat(std::string const& input) +{ + cmOutputConverter::OutputFormat shellFormat = (this->ForResponse) + ? cmOutputConverter::RESPONSE + : ((this->UseWatcomQuote) ? cmOutputConverter::WATCOMQUOTE + : cmOutputConverter::SHELL); + + return this->OutputConverter->ConvertToOutputFormat(input, shellFormat); +} diff --git a/Source/cmLinkLineComputer.h b/Source/cmLinkLineComputer.h index bd4c740..2317385 100644 --- a/Source/cmLinkLineComputer.h +++ b/Source/cmLinkLineComputer.h @@ -6,16 +6,31 @@ #include "cmState.h" +class cmComputeLinkInformation; +class cmOutputConverter; + class cmLinkLineComputer { public: - cmLinkLineComputer(cmState::Directory stateDir); + cmLinkLineComputer(cmOutputConverter* outputConverter, + cmState::Directory stateDir); virtual ~cmLinkLineComputer(); + void SetUseWatcomQuote(bool useWatcomQuote); + void SetForResponse(bool forResponse); + virtual std::string ConvertToLinkReference(std::string const& input) const; + std::string ComputeLinkLibs(cmComputeLinkInformation& cli); + private: + std::string ConvertToOutputFormat(std::string const& input); + cmState::Directory StateDir; + cmOutputConverter* OutputConverter; + + bool ForResponse; + bool UseWatcomQuote; }; #endif diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 25755d7..0d2fe86 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1453,24 +1453,7 @@ void cmLocalGenerator::OutputLinkLibraries( linkPath += " "; } - std::string linkLibs; - - // Append the link items. - typedef cmComputeLinkInformation::ItemVector ItemVector; - ItemVector const& items = cli.GetItems(); - for (ItemVector::const_iterator li = items.begin(); li != items.end(); - ++li) { - if (li->Target && li->Target->GetType() == cmState::INTERFACE_LIBRARY) { - continue; - } - if (li->IsPath) { - linkLibs += this->ConvertToOutputFormat( - linkLineComputer->ConvertToLinkReference(li->Value), shellFormat); - } else { - linkLibs += li->Value; - } - linkLibs += " "; - } + std::string linkLibs = linkLineComputer->ComputeLinkLibs(cli); std::string rpath; diff --git a/Source/cmMSVC60LinkLineComputer.cxx b/Source/cmMSVC60LinkLineComputer.cxx index 89432ff..2b6df2a 100644 --- a/Source/cmMSVC60LinkLineComputer.cxx +++ b/Source/cmMSVC60LinkLineComputer.cxx @@ -5,8 +5,9 @@ #include "cmSystemTools.h" -cmMSVC60LinkLineComputer::cmMSVC60LinkLineComputer(cmState::Directory stateDir) - : cmLinkLineComputer(stateDir) +cmMSVC60LinkLineComputer::cmMSVC60LinkLineComputer( + cmOutputConverter* outputConverter, cmState::Directory stateDir) + : cmLinkLineComputer(outputConverter, stateDir) { } diff --git a/Source/cmMSVC60LinkLineComputer.h b/Source/cmMSVC60LinkLineComputer.h index c159b61..ca9da31 100644 --- a/Source/cmMSVC60LinkLineComputer.h +++ b/Source/cmMSVC60LinkLineComputer.h @@ -9,7 +9,8 @@ class cmMSVC60LinkLineComputer : public cmLinkLineComputer { public: - cmMSVC60LinkLineComputer(cmState::Directory stateDir); + cmMSVC60LinkLineComputer(cmOutputConverter* outputConverter, + cmState::Directory stateDir); std::string ConvertToLinkReference(std::string const& input) const CM_OVERRIDE; diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index 09967ff..eaa5061 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -219,6 +219,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) { CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->CreateLinkLineComputer( + this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->AddModuleDefinitionFlag(linkLineComputer.get(), linkFlags); @@ -305,7 +306,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->CreateLinkLineComputer( + this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); + linkLineComputer->SetForResponse(useResponseFileForLibs); + linkLineComputer->SetUseWatcomQuote(useWatcomQuote); // Collect up flags to link in needed libraries. std::string linkLibs; diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index e32f3a7..ccc6d9f 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -163,6 +163,7 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink) CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->CreateLinkLineComputer( + this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags); @@ -193,6 +194,7 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink) CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->CreateLinkLineComputer( + this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags); @@ -505,7 +507,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules( CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->CreateLinkLineComputer( + this->LocalGenerator, this->LocalGenerator->GetStateSnapshot().GetDirectory())); + linkLineComputer->SetForResponse(useResponseFileForLibs); + linkLineComputer->SetUseWatcomQuote(useWatcomQuote); this->CreateLinkLibs(linkLineComputer.get(), linkLibs, relink, useResponseFileForLibs, depends, useWatcomQuote); diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index c74b381..d9102a6 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -1590,12 +1590,14 @@ std::string cmMakefileTargetGenerator::CreateResponseFile( } cmLinkLineComputer* cmMakefileTargetGenerator::CreateLinkLineComputer( - cmState::Directory stateDir) + cmOutputConverter* outputConverter, cmState::Directory stateDir) { if (this->Makefile->IsOn("MSVC60")) { - return this->GlobalGenerator->CreateMSVC60LinkLineComputer(stateDir); + return this->GlobalGenerator->CreateMSVC60LinkLineComputer(outputConverter, + stateDir); } - return this->GlobalGenerator->CreateLinkLineComputer(stateDir); + return this->GlobalGenerator->CreateLinkLineComputer(outputConverter, + stateDir); } void cmMakefileTargetGenerator::CreateLinkLibs( diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index 05de7ff..0930d89 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -140,7 +140,8 @@ protected: std::vector<std::string>& makefile_commands, std::vector<std::string>& makefile_depends); - cmLinkLineComputer* CreateLinkLineComputer(cmState::Directory stateDir); + cmLinkLineComputer* CreateLinkLineComputer( + cmOutputConverter* outputConverter, cmState::Directory stateDir); /** Create a response file with the given set of options. Returns the relative path from the target build working directory to the diff --git a/Source/cmNinjaLinkLineComputer.cxx b/Source/cmNinjaLinkLineComputer.cxx index dd74238..3dcb20b 100644 --- a/Source/cmNinjaLinkLineComputer.cxx +++ b/Source/cmNinjaLinkLineComputer.cxx @@ -5,8 +5,9 @@ #include "cmGlobalNinjaGenerator.h" cmNinjaLinkLineComputer::cmNinjaLinkLineComputer( - cmState::Directory stateDir, cmGlobalNinjaGenerator const* gg) - : cmLinkLineComputer(stateDir) + cmOutputConverter* outputConverter, cmState::Directory stateDir, + cmGlobalNinjaGenerator const* gg) + : cmLinkLineComputer(outputConverter, stateDir) , GG(gg) { } diff --git a/Source/cmNinjaLinkLineComputer.h b/Source/cmNinjaLinkLineComputer.h index d86f214..a108568 100644 --- a/Source/cmNinjaLinkLineComputer.h +++ b/Source/cmNinjaLinkLineComputer.h @@ -12,7 +12,8 @@ class cmGlobalNinjaGenerator; class cmNinjaLinkLineComputer : public cmLinkLineComputer { public: - cmNinjaLinkLineComputer(cmState::Directory stateDir, + cmNinjaLinkLineComputer(cmOutputConverter* outputConverter, + cmState::Directory stateDir, cmGlobalNinjaGenerator const* gg); std::string ConvertToLinkReference(std::string const& input) const diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index 9c22353..a458bbb 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -473,7 +473,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement() CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( this->GetGlobalGenerator()->CreateLinkLineComputer( - localGen.GetStateSnapshot().GetDirectory())); + this->GetLocalGenerator(), + this->GetLocalGenerator()->GetStateSnapshot().GetDirectory())); localGen.GetTargetFlags(linkLineComputer.get(), this->GetConfigName(), vars["LINK_LIBRARIES"], vars["FLAGS"], diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx index a58510e..d537cfd 100644 --- a/Source/cmServerProtocol.cxx +++ b/Source/cmServerProtocol.cxx @@ -729,12 +729,10 @@ static Json::Value DumpTarget(cmGeneratorTarget* target, std::string linkLanguageFlags; std::string frameworkPath; std::string linkPath; - CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( - lg->GetGlobalGenerator()->CreateLinkLineComputer( - lg->GetStateSnapshot().GetDirectory())); - lg->GetTargetFlags(linkLineComputer.get(), config, linkLibs, - linkLanguageFlags, linkFlags, frameworkPath, linkPath, - target, false); + cmLinkLineComputer linkLineComputer(lg, + lg->GetStateSnapshot().GetDirectory()); + lg->GetTargetFlags(&linkLineComputer, 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 046b5f1..50f77f4 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -583,9 +583,9 @@ bool cmake::FindPackage(const std::vector<std::string>& args) gg->CreateGenerationObjects(); cmGeneratorTarget* gtgt = gg->FindGeneratorTarget(tgt->GetName()); cmLocalGenerator* lg = gtgt->GetLocalGenerator(); - CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( - gg->CreateLinkLineComputer(lg->GetStateSnapshot().GetDirectory())); - lg->GetTargetFlags(linkLineComputer.get(), buildType, linkLibs, flags, + cmLinkLineComputer linkLineComputer(lg, + lg->GetStateSnapshot().GetDirectory()); + lg->GetTargetFlags(&linkLineComputer, buildType, linkLibs, flags, linkFlags, frameworkPath, linkPath, gtgt, false); linkLibs = frameworkPath + linkPath + linkLibs; https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=0152a01f11fc46f645fd765cc7b1be76cc07b52a commit 0152a01f11fc46f645fd765cc7b1be76cc07b52a Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:37 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:57 2016 +0200 cmLocalGenerator: Move variable to where it is used diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 3b3eea3..25755d7 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1411,8 +1411,6 @@ void cmLocalGenerator::OutputLinkLibraries( std::string linkLanguage = cli.GetLinkLanguage(); - std::string linkLibs; - std::string libPathFlag = this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG"); std::string libPathTerminator = @@ -1455,6 +1453,8 @@ void cmLocalGenerator::OutputLinkLibraries( linkPath += " "; } + std::string linkLibs; + // Append the link items. typedef cmComputeLinkInformation::ItemVector ItemVector; ItemVector const& items = cli.GetItems(); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=011e6870e4a7f19476c162a8c011fd018d9a7e9c commit 011e6870e4a7f19476c162a8c011fd018d9a7e9c Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:37 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:56 2016 +0200 cmLocalGenerator: Use a std::string instead of char* diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 565c0cd..3b3eea3 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1431,8 +1431,9 @@ void cmLocalGenerator::OutputLinkLibraries( std::string fwSearchFlagVar = "CMAKE_"; fwSearchFlagVar += linkLanguage; fwSearchFlagVar += "_FRAMEWORK_SEARCH_FLAG"; - const char* fwSearchFlag = this->Makefile->GetDefinition(fwSearchFlagVar); - if (fwSearchFlag && *fwSearchFlag) { + std::string fwSearchFlag = + this->Makefile->GetSafeDefinition(fwSearchFlagVar); + if (!fwSearchFlag.empty()) { std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths(); for (std::vector<std::string>::const_iterator fdi = fwDirs.begin(); fdi != fwDirs.end(); ++fdi) { https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=cbca80f3516d7e5b2def6105a1b26b44bad7b6fe commit cbca80f3516d7e5b2def6105a1b26b44bad7b6fe Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:37 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:56 2016 +0200 cmLocalGenerator: Move stringstream to where it is used diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index aec658a..565c0cd 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1406,7 +1406,6 @@ void cmLocalGenerator::OutputLinkLibraries( OutputFormat shellFormat = (forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL); bool escapeAllowMakeVars = !forResponseFile; - std::ostringstream fout; cmComputeLinkInformation& cli = *pcli; @@ -1498,6 +1497,7 @@ void cmLocalGenerator::OutputLinkLibraries( } } + std::ostringstream fout; fout << rpath; // Write the library flags to the build rule. https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=d48f69d0f5f265d1c091a614098cae3ff4325fbe commit d48f69d0f5f265d1c091a614098cae3ff4325fbe Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:37 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:55 2016 +0200 cmLocalGenerator: Move flag determination up in the function This content is independent of any targets. diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 9e32fd3..aec658a 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1419,6 +1419,15 @@ void cmLocalGenerator::OutputLinkLibraries( std::string libPathTerminator = this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR"); + // Add standard libraries for this language. + std::string standardLibsVar = "CMAKE_"; + standardLibsVar += cli.GetLinkLanguage(); + standardLibsVar += "_STANDARD_LIBRARIES"; + std::string stdLibString; + if (const char* stdLibs = this->Makefile->GetDefinition(standardLibsVar)) { + stdLibString = stdLibs; + } + // Append the framework search path flags. std::string fwSearchFlagVar = "CMAKE_"; fwSearchFlagVar += linkLanguage; @@ -1502,14 +1511,6 @@ void cmLocalGenerator::OutputLinkLibraries( fout << " "; } - // Add standard libraries for this language. - std::string standardLibsVar = "CMAKE_"; - standardLibsVar += cli.GetLinkLanguage(); - standardLibsVar += "_STANDARD_LIBRARIES"; - std::string stdLibString; - if (const char* stdLibs = this->Makefile->GetDefinition(standardLibsVar)) { - stdLibString = stdLibs; - } if (!stdLibString.empty()) { fout << stdLibString << " "; } https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ff8e321c6ade784b3f1b3b19a7783788872e44a9 commit ff8e321c6ade784b3f1b3b19a7783788872e44a9 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:37 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:55 2016 +0200 cmLocalGenerator: Separate stdlib content from library stream diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 6de8f9a..9e32fd3 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1506,8 +1506,12 @@ void cmLocalGenerator::OutputLinkLibraries( std::string standardLibsVar = "CMAKE_"; standardLibsVar += cli.GetLinkLanguage(); standardLibsVar += "_STANDARD_LIBRARIES"; + std::string stdLibString; if (const char* stdLibs = this->Makefile->GetDefinition(standardLibsVar)) { - fout << stdLibs << " "; + stdLibString = stdLibs; + } + if (!stdLibString.empty()) { + fout << stdLibString << " "; } linkLibraries = fout.str(); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=80f57e67eefc905a726f2f35bd1672a188ea4c99 commit 80f57e67eefc905a726f2f35bd1672a188ea4c99 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:36 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:55 2016 +0200 cmLocalGenerator: Separate rpath content from library stream diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index ae4a0b2..6de8f9a 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1463,32 +1463,34 @@ void cmLocalGenerator::OutputLinkLibraries( linkLibs += " "; } + std::string rpath; + // Check what kind of rpath flags to use. if (cli.GetRuntimeSep().empty()) { // Each rpath entry gets its own option ("-R a -R b -R c") std::vector<std::string> runtimeDirs; cli.GetRPath(runtimeDirs, relink); - std::string rpath; for (std::vector<std::string>::iterator ri = runtimeDirs.begin(); ri != runtimeDirs.end(); ++ri) { rpath += cli.GetRuntimeFlag(); rpath += this->ConvertToOutputFormat(*ri, shellFormat); rpath += " "; } - fout << rpath; } else { // All rpath entries are combined ("-Wl,-rpath,a:b:c"). - std::string rpath = cli.GetRPathString(relink); + std::string rpathString = cli.GetRPathString(relink); // Store the rpath option in the stream. - if (!rpath.empty()) { - fout << cli.GetRuntimeFlag(); - fout << this->EscapeForShell(rpath, escapeAllowMakeVars); - fout << " "; + if (!rpathString.empty()) { + rpath += cli.GetRuntimeFlag(); + rpath += this->EscapeForShell(rpathString, escapeAllowMakeVars); + rpath += " "; } } + fout << rpath; + // Write the library flags to the build rule. fout << linkLibs; https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=7ef834682547df5e0ccdcd503558dcbf1206a638 commit 7ef834682547df5e0ccdcd503558dcbf1206a638 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:36 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:54 2016 +0200 cmLocalGenerator: Pass link library info to OutputLinkLibraries Remove the cmGeneratorTarget from the interface. This is simplification of the OutputLinkLibraries responsibilities so that it can be broken apart into multiple methods. diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index c152a8b..ae4a0b2 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1155,6 +1155,7 @@ void cmLocalGenerator::GetTargetFlags( bool useWatcomQuote) { const std::string buildType = cmSystemTools::UpperCase(config); + cmComputeLinkInformation* pcli = target->GetLinkInformation(config); const char* libraryLinkVariable = "CMAKE_SHARED_LINKER_FLAGS"; // default to shared library @@ -1205,9 +1206,11 @@ void cmLocalGenerator::GetTargetFlags( linkFlags += " "; } } - this->OutputLinkLibraries(linkLineComputer, linkLibs, frameworkPath, - linkPath, *target, false, false, - useWatcomQuote); + if (pcli) { + this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, + frameworkPath, linkPath, false, false, + useWatcomQuote); + } } break; case cmState::EXECUTABLE: { linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS"); @@ -1226,9 +1229,11 @@ void cmLocalGenerator::GetTargetFlags( return; } this->AddLanguageFlags(flags, linkLanguage, buildType); - this->OutputLinkLibraries(linkLineComputer, linkLibs, frameworkPath, - linkPath, *target, false, false, - useWatcomQuote); + if (pcli) { + this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, + frameworkPath, linkPath, false, false, + useWatcomQuote); + } if (cmSystemTools::IsOn( this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) { std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_") + @@ -1393,19 +1398,16 @@ std::string cmLocalGenerator::GetTargetFortranFlags( * to the name of the library. This will not link a library against itself. */ void cmLocalGenerator::OutputLinkLibraries( - cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, - std::string& frameworkPath, std::string& linkPath, cmGeneratorTarget& tgt, - bool relink, bool forResponseFile, bool useWatcomQuote) + cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer, + std::string& linkLibraries, std::string& frameworkPath, + std::string& linkPath, bool relink, bool forResponseFile, + bool useWatcomQuote) { OutputFormat shellFormat = (forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL); bool escapeAllowMakeVars = !forResponseFile; std::ostringstream fout; - std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - cmComputeLinkInformation* pcli = tgt.GetLinkInformation(config); - if (!pcli) { - return; - } + cmComputeLinkInformation& cli = *pcli; std::string linkLanguage = cli.GetLinkLanguage(); diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index e19cba2..12b2b69 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -19,6 +19,7 @@ #include <string> #include <vector> +class cmComputeLinkInformation; class cmCustomCommandGenerator; class cmGeneratorTarget; class cmGlobalGenerator; @@ -347,11 +348,12 @@ public: protected: ///! put all the libraries for a target on into the given stream - void OutputLinkLibraries(cmLinkLineComputer* linkLineComputer, + void OutputLinkLibraries(cmComputeLinkInformation* pcli, + cmLinkLineComputer* linkLineComputer, std::string& linkLibraries, std::string& frameworkPath, std::string& linkPath, - cmGeneratorTarget&, bool relink, - bool forResponseFile, bool useWatcomQuote); + bool relink, bool forResponseFile, + bool useWatcomQuote); // Expand rule variables in CMake of the type found in language rules void ExpandRuleVariables(std::string& string, diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index d507326..c74b381 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -1605,9 +1605,12 @@ void cmMakefileTargetGenerator::CreateLinkLibs( { std::string frameworkPath; std::string linkPath; - this->LocalGenerator->OutputLinkLibraries( - linkLineComputer, linkLibs, frameworkPath, linkPath, - *this->GeneratorTarget, relink, useResponseFile, useWatcomQuote); + std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); + cmComputeLinkInformation* pcli = + this->GeneratorTarget->GetLinkInformation(config); + this->LocalGenerator->OutputLinkLibraries(pcli, linkLineComputer, linkLibs, + frameworkPath, linkPath, relink, + useResponseFile, useWatcomQuote); linkLibs = frameworkPath + linkPath + linkLibs; if (useResponseFile && linkLibs.find_first_not_of(' ') != linkLibs.npos) { https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=69295812065a5d07c07347add2fdcf8f36f993ba commit 69295812065a5d07c07347add2fdcf8f36f993ba Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:36 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:54 2016 +0200 Makefiles: Port CreateLinkLibs to cmLinkLineComputer diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index 3dc7007..09967ff 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -303,10 +303,14 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) // Set path conversion for link script shells. this->LocalGenerator->SetLinkScriptShell(useLinkScript); + CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( + this->CreateLinkLineComputer( + this->LocalGenerator->GetStateSnapshot().GetDirectory())); + // Collect up flags to link in needed libraries. std::string linkLibs; - this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends, - useWatcomQuote); + this->CreateLinkLibs(linkLineComputer.get(), linkLibs, relink, + useResponseFileForLibs, depends, useWatcomQuote); // Construct object file lists that may be needed to expand the // rule. diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index b12e779..e32f3a7 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -502,8 +502,13 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules( // Collect up flags to link in needed libraries. std::string linkLibs; if (this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) { - this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends, - useWatcomQuote); + + CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( + this->CreateLinkLineComputer( + this->LocalGenerator->GetStateSnapshot().GetDirectory())); + + this->CreateLinkLibs(linkLineComputer.get(), linkLibs, relink, + useResponseFileForLibs, depends, useWatcomQuote); } // Construct object file lists that may be needed to expand the diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index 7232248..d507326 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -1599,18 +1599,14 @@ cmLinkLineComputer* cmMakefileTargetGenerator::CreateLinkLineComputer( } void cmMakefileTargetGenerator::CreateLinkLibs( - std::string& linkLibs, bool relink, bool useResponseFile, - std::vector<std::string>& makefile_depends, bool useWatcomQuote) + cmLinkLineComputer* linkLineComputer, std::string& linkLibs, bool relink, + bool useResponseFile, std::vector<std::string>& makefile_depends, + bool useWatcomQuote) { std::string frameworkPath; std::string linkPath; - - CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( - this->CreateLinkLineComputer( - this->LocalGenerator->GetStateSnapshot().GetDirectory())); - this->LocalGenerator->OutputLinkLibraries( - linkLineComputer.get(), linkLibs, frameworkPath, linkPath, + linkLineComputer, linkLibs, frameworkPath, linkPath, *this->GeneratorTarget, relink, useResponseFile, useWatcomQuote); linkLibs = frameworkPath + linkPath + linkLibs; diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index 733a2f8..05de7ff 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -20,6 +20,7 @@ class cmGeneratedFileStream; class cmGeneratorTarget; class cmGlobalUnixMakefileGenerator3; class cmSourceFile; +class cmLinkLineComputer; /** \class cmMakefileTargetGenerator * \brief Support Routines for writing makefiles @@ -151,7 +152,8 @@ protected: bool CheckUseResponseFileForLibraries(std::string const& l) const; /** Create list of flags for link libraries. */ - void CreateLinkLibs(std::string& linkLibs, bool relink, bool useResponseFile, + void CreateLinkLibs(cmLinkLineComputer* linkLineComputer, + std::string& linkLibs, bool relink, bool useResponseFile, std::vector<std::string>& makefile_depends, bool useWatcomQuote); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=5b361fdda0f2808f0368b746a880981ebda0ade0 commit 5b361fdda0f2808f0368b746a880981ebda0ade0 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:36 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:53 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 e574957..048667a 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 @@ -545,6 +549,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 fac68f5..959bfc1 100644 --- a/Source/cmGhsMultiTargetGenerator.cxx +++ b/Source/cmGhsMultiTargetGenerator.cxx @@ -5,6 +5,7 @@ #include "cmGeneratedFileStream.h" #include "cmGeneratorTarget.h" #include "cmGlobalGhsMultiGenerator.h" +#include "cmLinkLineComputer.h" #include "cmLocalGhsMultiGenerator.h" #include "cmMakefile.h" #include "cmSourceFile.h" @@ -362,9 +363,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 7132ade..2266e44 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" @@ -1412,6 +1414,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 74b4547..126eb6f 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -34,6 +34,7 @@ class cmExportBuildFileGenerator; class cmExternalMakefileProjectGenerator; class cmGeneratorTarget; class cmLocalGenerator; +class cmLinkLineComputer; class cmMakefile; class cmake; @@ -105,6 +106,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 adb5a95..65a1f25 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,13 @@ void cmGlobalNinjaGenerator::WriteComment(std::ostream& os, os << "# " << comment.substr(lpos) << "\n\n"; } +cmLinkLineComputer* cmGlobalNinjaGenerator::CreateLinkLineComputer( + cmState::Directory /* stateDir */) const +{ + return new cmNinjaLinkLineComputer( + this->LocalGenerators[0]->GetStateSnapshot().GetDirectory(), this); +} + 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 5064b21..87faf45 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..bd4c740 --- /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; + +private: + cmState::Directory StateDir; +}; + +#endif diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index f1b7c6a..c152a8b 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" @@ -1148,9 +1149,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_") + @@ -1383,51 +1387,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); @@ -1486,7 +1454,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 e16ddab..e19cba2 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. @@ -312,7 +313,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); @@ -345,7 +347,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); @@ -370,8 +373,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 b04c11d..e25eb0f 100644 --- a/Source/cmLocalNinjaGenerator.cxx +++ b/Source/cmLocalNinjaGenerator.cxx @@ -120,12 +120,6 @@ cmGlobalNinjaGenerator* cmLocalNinjaGenerator::GetGlobalNinjaGenerator() // Virtual protected methods. -std::string cmLocalNinjaGenerator::ConvertToLinkReference( - std::string const& lib) -{ - return this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(lib); -} - 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..89432ff --- /dev/null +++ b/Source/cmMSVC60LinkLineComputer.cxx @@ -0,0 +1,35 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ + +#include "cmMSVC60LinkLineComputer.h" + +#include "cmSystemTools.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 79168d8..3dc7007 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" @@ -215,7 +216,13 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) this->LocalGenerator->AppendFlags( linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig)); - this->AddModuleDefinitionFlag(linkFlags); + { + CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( + this->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..b12e779 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.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" @@ -159,7 +160,12 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink) this->LocalGenerator->AddConfigVariableFlags( extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName); - this->AddModuleDefinitionFlag(extraFlags); + + CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( + this->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 +190,12 @@ 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( + this->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 44ced11..7232248 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" @@ -1588,15 +1589,29 @@ std::string cmMakefileTargetGenerator::CreateResponseFile( return responseFileName; } +cmLinkLineComputer* cmMakefileTargetGenerator::CreateLinkLineComputer( + cmState::Directory stateDir) +{ + if (this->Makefile->IsOn("MSVC60")) { + return this->GlobalGenerator->CreateMSVC60LinkLineComputer(stateDir); + } + return this->GlobalGenerator->CreateLinkLineComputer(stateDir); +} + void cmMakefileTargetGenerator::CreateLinkLibs( std::string& linkLibs, bool relink, bool useResponseFile, std::vector<std::string>& makefile_depends, bool useWatcomQuote) { std::string frameworkPath; std::string linkPath; - this->LocalGenerator->OutputLinkLibraries(linkLibs, frameworkPath, linkPath, - *this->GeneratorTarget, relink, - useResponseFile, useWatcomQuote); + + CM_AUTO_PTR<cmLinkLineComputer> linkLineComputer( + this->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/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index 813af80..733a2f8 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -139,6 +139,8 @@ protected: std::vector<std::string>& makefile_commands, std::vector<std::string>& makefile_depends); + cmLinkLineComputer* CreateLinkLineComputer(cmState::Directory stateDir); + /** Create a response file with the given set of options. Returns the relative path from the target build working directory to the response file name. */ diff --git a/Source/cmNinjaLinkLineComputer.cxx b/Source/cmNinjaLinkLineComputer.cxx new file mode 100644 index 0000000..dd74238 --- /dev/null +++ b/Source/cmNinjaLinkLineComputer.cxx @@ -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. */ + +#include "cmNinjaLinkLineComputer.h" +#include "cmGlobalNinjaGenerator.h" + +cmNinjaLinkLineComputer::cmNinjaLinkLineComputer( + cmState::Directory stateDir, cmGlobalNinjaGenerator const* gg) + : cmLinkLineComputer(stateDir) + , GG(gg) +{ +} + +std::string cmNinjaLinkLineComputer::ConvertToLinkReference( + std::string const& lib) const +{ + return GG->ConvertToNinjaPath(lib); +} diff --git a/Source/cmNinjaLinkLineComputer.h b/Source/cmNinjaLinkLineComputer.h new file mode 100644 index 0000000..d86f214 --- /dev/null +++ b/Source/cmNinjaLinkLineComputer.h @@ -0,0 +1,25 @@ +/* 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 cmGlobalNinjaGenerator; + +class cmNinjaLinkLineComputer : public cmLinkLineComputer +{ +public: + cmNinjaLinkLineComputer(cmState::Directory stateDir, + cmGlobalNinjaGenerator const* gg); + + std::string ConvertToLinkReference(std::string const& input) const + CM_OVERRIDE; + +private: + cmGlobalNinjaGenerator const* GG; +}; + +#endif diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index 095c703..9c22353 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( + localGen.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 dad8717..046b5f1 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=2e5d1990f382aa42e8a0ad34117ee1e5a9187153 commit 2e5d1990f382aa42e8a0ad34117ee1e5a9187153 Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:35 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:53 2016 +0200 Ninja: Constify diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index f5a0e68..adb5a95 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -830,7 +830,8 @@ static void EnsureTrailingSlash(std::string& path) #endif } -std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path) +std::string cmGlobalNinjaGenerator::ConvertToNinjaPath( + const std::string& path) const { cmLocalNinjaGenerator* ng = static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]); @@ -1421,7 +1422,8 @@ void cmGlobalNinjaGenerator::InitOutputPathPrefix() EnsureTrailingSlash(this->OutputPathPrefix); } -std::string cmGlobalNinjaGenerator::NinjaOutputPath(std::string const& path) +std::string cmGlobalNinjaGenerator::NinjaOutputPath( + std::string const& path) const { if (!this->HasOutputPathPrefix() || cmSystemTools::FileIsFullPath(path)) { return path; diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index dcf7406..5064b21 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -233,7 +233,7 @@ public: return this->RulesFileStream; } - std::string ConvertToNinjaPath(const std::string& path); + std::string ConvertToNinjaPath(const std::string& path) const; std::string ConvertToNinjaFolderRule(const std::string& path); struct MapToNinjaPathImpl @@ -333,7 +333,7 @@ public: bool SupportsConsolePool() const; bool SupportsImplicitOuts() const; - std::string NinjaOutputPath(std::string const& path); + std::string NinjaOutputPath(std::string const& path) const; bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); } void StripNinjaOutputPathPrefixAsSuffix(std::string& path); https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=b3701f9a5213f2ff5b2bc197e9af5d1f2ff68a9c commit b3701f9a5213f2ff5b2bc197e9af5d1f2ff68a9c Author: Stephen Kelly <steve...@gmail.com> AuthorDate: Sat Oct 8 12:21:35 2016 +0200 Commit: Stephen Kelly <steve...@gmail.com> CommitDate: Mon Oct 10 20:38:52 2016 +0200 cmLocalGenerator: Inline conversion into link computation Make it possible to invoke this functionality independent of cmLocalGenerator. diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 025b82a..f1b7c6a 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1407,7 +1407,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; } /** ----------------------------------------------------------------------- Summary of changes: Source/CMakeLists.txt | 6 + Source/cmCommonTargetGenerator.cxx | 6 +- Source/cmCommonTargetGenerator.h | 4 +- Source/cmGhsMultiTargetGenerator.cxx | 11 +- Source/cmGlobalGenerator.cxx | 14 ++ Source/cmGlobalGenerator.h | 8 ++ Source/cmGlobalNinjaGenerator.cxx | 15 +- Source/cmGlobalNinjaGenerator.h | 8 +- Source/cmLinkLineComputer.cxx | 179 ++++++++++++++++++++++++ Source/cmLinkLineComputer.h | 50 +++++++ Source/cmLocalGenerator.cxx | 167 +++++----------------- Source/cmLocalGenerator.h | 17 +-- Source/cmLocalNinjaGenerator.cxx | 6 - Source/cmLocalNinjaGenerator.h | 2 - Source/cmMSVC60LinkLineComputer.cxx | 36 +++++ Source/cmMSVC60LinkLineComputer.h | 19 +++ Source/cmMakefileExecutableTargetGenerator.cxx | 22 ++- Source/cmMakefileLibraryTargetGenerator.cxx | 30 +++- Source/cmMakefileTargetGenerator.cxx | 24 +++- Source/cmMakefileTargetGenerator.h | 10 +- Source/cmNinjaLinkLineComputer.cxx | 19 +++ Source/cmNinjaLinkLineComputer.h | 26 ++++ Source/cmNinjaNormalTargetGenerator.cxx | 15 +- Source/cmServerProtocol.cxx | 7 +- Source/cmake.cxx | 7 +- bootstrap | 2 + 26 files changed, 527 insertions(+), 183 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