From 0392f72bef5f1394c2dba3740f2a701fe1a98f0d Mon Sep 17 00:00:00 2001 From: Brad King Date: Thu, 16 Jun 2016 10:54:20 -0400 Subject: Refactor Makefile/Ninja tool working directory storage Move cmCommonTargetGenerator::WorkingDirectory to cmLocalCommonGenerator and add an access method. --- Source/cmCommonTargetGenerator.cxx | 12 ++++++------ Source/cmCommonTargetGenerator.h | 4 +--- Source/cmLocalCommonGenerator.cxx | 5 +++-- Source/cmLocalCommonGenerator.h | 10 +++++++++- Source/cmLocalNinjaGenerator.cxx | 2 +- Source/cmLocalUnixMakefileGenerator3.cxx | 2 +- Source/cmMakefileTargetGenerator.cxx | 2 +- Source/cmNinjaTargetGenerator.cxx | 2 +- 8 files changed, 23 insertions(+), 16 deletions(-) diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index b893dd3..1cc04ea 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -19,10 +19,8 @@ #include "cmSourceFile.h" #include "cmSystemTools.h" -cmCommonTargetGenerator::cmCommonTargetGenerator( - cmOutputConverter::RelativeRoot wd, cmGeneratorTarget* gt) - : WorkingDirectory(wd) - , GeneratorTarget(gt) +cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt) + : GeneratorTarget(gt) , Makefile(gt->Makefile) , LocalGenerator(static_cast(gt->LocalGenerator)) , GlobalGenerator(static_cast( @@ -140,7 +138,8 @@ void cmCommonTargetGenerator::AddFortranFlags(std::string& flags) std::string mod_dir = this->GetFortranModuleDirectory(); if (!mod_dir.empty()) { mod_dir = - this->Convert(mod_dir, this->WorkingDirectory, cmOutputConverter::SHELL); + this->Convert(mod_dir, this->LocalGenerator->GetWorkingDirectory(), + cmOutputConverter::SHELL); } else { mod_dir = this->Makefile->GetSafeDefinition("CMAKE_Fortran_MODDIR_DEFAULT"); @@ -308,7 +307,8 @@ std::string cmCommonTargetGenerator::GetManifests() for (std::vector::iterator mi = manifest_srcs.begin(); mi != manifest_srcs.end(); ++mi) { manifests.push_back(this->Convert( - (*mi)->GetFullPath(), this->WorkingDirectory, cmOutputConverter::SHELL)); + (*mi)->GetFullPath(), this->LocalGenerator->GetWorkingDirectory(), + cmOutputConverter::SHELL)); } return cmJoin(manifests, " "); diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h index ace5351..c35d22a 100644 --- a/Source/cmCommonTargetGenerator.h +++ b/Source/cmCommonTargetGenerator.h @@ -28,8 +28,7 @@ class cmSourceFile; class cmCommonTargetGenerator { public: - cmCommonTargetGenerator(cmOutputConverter::RelativeRoot wd, - cmGeneratorTarget* gt); + cmCommonTargetGenerator(cmGeneratorTarget* gt); virtual ~cmCommonTargetGenerator(); std::string const& GetConfigName() const; @@ -45,7 +44,6 @@ protected: // Helper to add flag for windows .def file. void AddModuleDefinitionFlag(std::string& flags); - cmOutputConverter::RelativeRoot WorkingDirectory; cmGeneratorTarget* GeneratorTarget; cmMakefile* Makefile; cmLocalCommonGenerator* LocalGenerator; diff --git a/Source/cmLocalCommonGenerator.cxx b/Source/cmLocalCommonGenerator.cxx index 3ebd128..6cfeb10 100644 --- a/Source/cmLocalCommonGenerator.cxx +++ b/Source/cmLocalCommonGenerator.cxx @@ -13,9 +13,10 @@ #include "cmMakefile.h" -cmLocalCommonGenerator::cmLocalCommonGenerator(cmGlobalGenerator* gg, - cmMakefile* mf) +cmLocalCommonGenerator::cmLocalCommonGenerator( + cmGlobalGenerator* gg, cmMakefile* mf, cmOutputConverter::RelativeRoot wd) : cmLocalGenerator(gg, mf) + , WorkingDirectory(wd) { } diff --git a/Source/cmLocalCommonGenerator.h b/Source/cmLocalCommonGenerator.h index d282054..10380db 100644 --- a/Source/cmLocalCommonGenerator.h +++ b/Source/cmLocalCommonGenerator.h @@ -22,12 +22,20 @@ class cmCommonTargetGenerator; class cmLocalCommonGenerator : public cmLocalGenerator { public: - cmLocalCommonGenerator(cmGlobalGenerator* gg, cmMakefile* mf); + cmLocalCommonGenerator(cmGlobalGenerator* gg, cmMakefile* mf, + cmOutputConverter::RelativeRoot wd); ~cmLocalCommonGenerator(); std::string const& GetConfigName() { return this->ConfigName; } + cmOutputConverter::RelativeRoot GetWorkingDirectory() const + { + return this->WorkingDirectory; + } + protected: + cmOutputConverter::RelativeRoot WorkingDirectory; + void SetConfigName(); std::string ConfigName; diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx index 6e676f1..0f488a6 100644 --- a/Source/cmLocalNinjaGenerator.cxx +++ b/Source/cmLocalNinjaGenerator.cxx @@ -25,7 +25,7 @@ cmLocalNinjaGenerator::cmLocalNinjaGenerator(cmGlobalGenerator* gg, cmMakefile* mf) - : cmLocalCommonGenerator(gg, mf) + : cmLocalCommonGenerator(gg, mf, cmOutputConverter::HOME_OUTPUT) , HomeRelativeOutputPath("") { this->TargetImplib = "$TARGET_IMPLIB"; diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index 4b5af8b..460f0e2 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -84,7 +84,7 @@ static std::string cmSplitExtension(std::string const& in, std::string& base) cmLocalUnixMakefileGenerator3::cmLocalUnixMakefileGenerator3( cmGlobalGenerator* gg, cmMakefile* mf) - : cmLocalCommonGenerator(gg, mf) + : cmLocalCommonGenerator(gg, mf, cmOutputConverter::START_OUTPUT) { this->MakefileVariableSize = 0; this->ColorMakefile = false; diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index 3086bb1..daf05d3 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -32,7 +32,7 @@ #include cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target) - : cmCommonTargetGenerator(cmOutputConverter::START_OUTPUT, target) + : cmCommonTargetGenerator(target) , OSXBundleGenerator(0) , MacOSXContentGenerator(0) { diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index 05a0a63..b413c33 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -58,7 +58,7 @@ cmNinjaTargetGenerator* cmNinjaTargetGenerator::New(cmGeneratorTarget* target) } cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target) - : cmCommonTargetGenerator(cmOutputConverter::HOME_OUTPUT, target) + : cmCommonTargetGenerator(target) , MacOSXContentGenerator(0) , OSXBundleGenerator(0) , MacContentFolders() -- cgit v0.12 From 49f10f0d24420f7d96c5153ba64a16b3f43c4736 Mon Sep 17 00:00:00 2001 From: Tobias Hunger Date: Fri, 10 Jun 2016 16:58:36 +0200 Subject: cmGeneratorTarget: Adopt Fortran module directory generation Move code to create/get the fortran module directory from the cmCommonTargetGenerator to cmGeneratorTarget. Rename the ComputeFortranModuleDirectory method to CreateFortranModuleDirectory as this method *creates* the directory if it is missing. --- Source/cmCommonTargetGenerator.cxx | 40 +----------------------------------- Source/cmCommonTargetGenerator.h | 6 ------ Source/cmGeneratorTarget.cxx | 35 +++++++++++++++++++++++++++++++ Source/cmGeneratorTarget.h | 6 ++++++ Source/cmMakefileTargetGenerator.cxx | 2 +- 5 files changed, 43 insertions(+), 46 deletions(-) diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index 1cc04ea..eb1216e 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -27,7 +27,6 @@ cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt) gt->LocalGenerator->GetGlobalGenerator())) , ConfigName(LocalGenerator->GetConfigName()) , ModuleDefinitionFile(GeneratorTarget->GetModuleDefinitionFile(ConfigName)) - , FortranModuleDirectoryComputed(false) { } @@ -89,43 +88,6 @@ void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags) this->LocalGenerator->AppendFlags(flags, flag); } -std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const -{ - std::string mod_dir; - const char* target_mod_dir = - this->GeneratorTarget->GetProperty("Fortran_MODULE_DIRECTORY"); - const char* moddir_flag = - this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG"); - if (target_mod_dir && moddir_flag) { - // Compute the full path to the module directory. - if (cmSystemTools::FileIsFullPath(target_mod_dir)) { - // Already a full path. - mod_dir = target_mod_dir; - } else { - // Interpret relative to the current output directory. - mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory(); - mod_dir += "/"; - mod_dir += target_mod_dir; - } - - // Make sure the module output directory exists. - cmSystemTools::MakeDirectory(mod_dir); - } - return mod_dir; -} - -std::string cmCommonTargetGenerator::GetFortranModuleDirectory() -{ - // Compute the module directory. - if (!this->FortranModuleDirectoryComputed) { - this->FortranModuleDirectoryComputed = true; - this->FortranModuleDirectory = this->ComputeFortranModuleDirectory(); - } - - // Return the computed directory. - return this->FortranModuleDirectory; -} - void cmCommonTargetGenerator::AddFortranFlags(std::string& flags) { // Enable module output if necessary. @@ -135,7 +97,7 @@ void cmCommonTargetGenerator::AddFortranFlags(std::string& flags) } // Add a module output directory flag if necessary. - std::string mod_dir = this->GetFortranModuleDirectory(); + std::string mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(); if (!mod_dir.empty()) { mod_dir = this->Convert(mod_dir, this->LocalGenerator->GetWorkingDirectory(), diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h index c35d22a..dc4974c 100644 --- a/Source/cmCommonTargetGenerator.h +++ b/Source/cmCommonTargetGenerator.h @@ -53,12 +53,6 @@ protected: // The windows module definition source file (.def), if any. cmSourceFile const* ModuleDefinitionFile; - // Target-wide Fortran module output directory. - bool FortranModuleDirectoryComputed; - std::string FortranModuleDirectory; - std::string GetFortranModuleDirectory(); - virtual std::string ComputeFortranModuleDirectory() const; - // Compute target-specific Fortran language flags. void AddFortranFlags(std::string& flags); diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 5f4b074..15b44a6 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -258,6 +258,7 @@ void CreatePropertyGeneratorExpressions( cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg) : Target(t) + , FortranModuleDirectoryCreated(false) , SourceFileFlagsConstructed(false) , PolicyWarnedCMP0022(false) , DebugIncludesDone(false) @@ -3842,6 +3843,40 @@ void cmGeneratorTarget::GetTargetVersion(bool soversion, int& major, } } +std::string cmGeneratorTarget::GetFortranModuleDirectory() const +{ + if (!this->FortranModuleDirectoryCreated) { + this->FortranModuleDirectory = true; + this->FortranModuleDirectory = this->CreateFortranModuleDirectory(); + } + + return this->FortranModuleDirectory; +} + +std::string cmGeneratorTarget::CreateFortranModuleDirectory() const +{ + static std::string mod_dir; + const char* target_mod_dir = this->GetProperty("Fortran_MODULE_DIRECTORY"); + const char* moddir_flag = + this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG"); + if (target_mod_dir && moddir_flag) { + // Compute the full path to the module directory. + if (cmSystemTools::FileIsFullPath(target_mod_dir)) { + // Already a full path. + mod_dir = target_mod_dir; + } else { + // Interpret relative to the current output directory. + mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory(); + mod_dir += "/"; + mod_dir += target_mod_dir; + } + + // Make sure the module output directory exists. + cmSystemTools::MakeDirectory(mod_dir); + } + return mod_dir; +} + std::string cmGeneratorTarget::GetFrameworkVersion() const { assert(this->GetType() != cmState::INTERFACE_LIBRARY); diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h index 63208bc..2ee9bef 100644 --- a/Source/cmGeneratorTarget.h +++ b/Source/cmGeneratorTarget.h @@ -526,7 +526,13 @@ public: void GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const; + std::string GetFortranModuleDirectory() const; + private: + std::string CreateFortranModuleDirectory() const; + mutable bool FortranModuleDirectoryCreated; + mutable std::string FortranModuleDirectory; + friend class cmTargetTraceDependencies; struct SourceEntry { diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index daf05d3..8b341a1 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -962,7 +962,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() << "\n" << "# Fortran module output directory.\n" << "set(CMAKE_Fortran_TARGET_MODULE_DIR \"" - << this->GetFortranModuleDirectory() << "\")\n"; + << this->GeneratorTarget->GetFortranModuleDirectory() << "\")\n"; /* clang-format on */ // and now write the rule to use it -- cgit v0.12 From 5467e7945d46f5f8540a6e11933c9b6b584036a2 Mon Sep 17 00:00:00 2001 From: Brad King Date: Thu, 16 Jun 2016 11:14:18 -0400 Subject: cmLocalGenerator: Add method to get Fortran-specific compiler flags Add a cmLocalGenerator::GetTargetFortranFlags virtual method to get generator-specific generation of Fortran-specific flags. Implement it in cmLocalCommonGenerator by moving the implementation from cmCommonTargetGenerator::AddFortranFlags. This will allow it to be used without having a target generator available. Inspired-by: Tobias Hunger --- Source/cmCommonTargetGenerator.cxx | 49 +++----------------------------------- Source/cmCommonTargetGenerator.h | 3 --- Source/cmLocalCommonGenerator.cxx | 47 ++++++++++++++++++++++++++++++++++++ Source/cmLocalCommonGenerator.h | 3 +++ Source/cmLocalGenerator.cxx | 7 ++++++ Source/cmLocalGenerator.h | 2 ++ 6 files changed, 62 insertions(+), 49 deletions(-) diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index eb1216e..aa7f5c0 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -88,51 +88,6 @@ void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags) this->LocalGenerator->AppendFlags(flags, flag); } -void cmCommonTargetGenerator::AddFortranFlags(std::string& flags) -{ - // Enable module output if necessary. - if (const char* modout_flag = - this->Makefile->GetDefinition("CMAKE_Fortran_MODOUT_FLAG")) { - this->LocalGenerator->AppendFlags(flags, modout_flag); - } - - // Add a module output directory flag if necessary. - std::string mod_dir = this->GeneratorTarget->GetFortranModuleDirectory(); - if (!mod_dir.empty()) { - mod_dir = - this->Convert(mod_dir, this->LocalGenerator->GetWorkingDirectory(), - cmOutputConverter::SHELL); - } else { - mod_dir = - this->Makefile->GetSafeDefinition("CMAKE_Fortran_MODDIR_DEFAULT"); - } - if (!mod_dir.empty()) { - const char* moddir_flag = - this->Makefile->GetRequiredDefinition("CMAKE_Fortran_MODDIR_FLAG"); - std::string modflag = moddir_flag; - modflag += mod_dir; - this->LocalGenerator->AppendFlags(flags, modflag); - } - - // If there is a separate module path flag then duplicate the - // include path with it. This compiler does not search the include - // path for modules. - if (const char* modpath_flag = - this->Makefile->GetDefinition("CMAKE_Fortran_MODPATH_FLAG")) { - std::vector includes; - const std::string& config = this->ConfigName; - this->LocalGenerator->GetIncludeDirectories( - includes, this->GeneratorTarget, "C", config); - for (std::vector::const_iterator idi = includes.begin(); - idi != includes.end(); ++idi) { - std::string flg = modpath_flag; - flg += - this->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL); - this->LocalGenerator->AppendFlags(flags, flg); - } - } -} - void cmCommonTargetGenerator::AppendFortranFormatFlags( std::string& flags, cmSourceFile const& source) { @@ -175,7 +130,9 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string& l) // Fortran-specific flags computed for this target. if (l == "Fortran") { - this->AddFortranFlags(flags); + this->LocalGenerator->AppendFlags( + flags, this->LocalGenerator->GetTargetFortranFlags( + this->GeneratorTarget, this->ConfigName)); } this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, lang, diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h index dc4974c..0bafde9 100644 --- a/Source/cmCommonTargetGenerator.h +++ b/Source/cmCommonTargetGenerator.h @@ -53,9 +53,6 @@ protected: // The windows module definition source file (.def), if any. cmSourceFile const* ModuleDefinitionFile; - // Compute target-specific Fortran language flags. - void AddFortranFlags(std::string& flags); - std::string Convert( std::string const& source, cmOutputConverter::RelativeRoot relative, cmOutputConverter::OutputFormat output = cmOutputConverter::UNCHANGED); diff --git a/Source/cmLocalCommonGenerator.cxx b/Source/cmLocalCommonGenerator.cxx index 6cfeb10..5502296 100644 --- a/Source/cmLocalCommonGenerator.cxx +++ b/Source/cmLocalCommonGenerator.cxx @@ -35,3 +35,50 @@ void cmLocalCommonGenerator::SetConfigName() this->ConfigName = ""; } } + +std::string cmLocalCommonGenerator::GetTargetFortranFlags( + cmGeneratorTarget const* target, std::string const& config) +{ + std::string flags; + + // Enable module output if necessary. + if (const char* modout_flag = + this->Makefile->GetDefinition("CMAKE_Fortran_MODOUT_FLAG")) { + this->AppendFlags(flags, modout_flag); + } + + // Add a module output directory flag if necessary. + std::string mod_dir = target->GetFortranModuleDirectory(); + if (!mod_dir.empty()) { + mod_dir = + this->Convert(mod_dir, this->WorkingDirectory, cmOutputConverter::SHELL); + } else { + mod_dir = + this->Makefile->GetSafeDefinition("CMAKE_Fortran_MODDIR_DEFAULT"); + } + if (!mod_dir.empty()) { + const char* moddir_flag = + this->Makefile->GetRequiredDefinition("CMAKE_Fortran_MODDIR_FLAG"); + std::string modflag = moddir_flag; + modflag += mod_dir; + this->AppendFlags(flags, modflag); + } + + // If there is a separate module path flag then duplicate the + // include path with it. This compiler does not search the include + // path for modules. + if (const char* modpath_flag = + this->Makefile->GetDefinition("CMAKE_Fortran_MODPATH_FLAG")) { + std::vector includes; + this->GetIncludeDirectories(includes, target, "C", config); + for (std::vector::const_iterator idi = includes.begin(); + idi != includes.end(); ++idi) { + std::string flg = modpath_flag; + flg += + this->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL); + this->AppendFlags(flags, flg); + } + } + + return flags; +} diff --git a/Source/cmLocalCommonGenerator.h b/Source/cmLocalCommonGenerator.h index 10380db..fd17ae3 100644 --- a/Source/cmLocalCommonGenerator.h +++ b/Source/cmLocalCommonGenerator.h @@ -33,6 +33,9 @@ public: return this->WorkingDirectory; } + std::string GetTargetFortranFlags(cmGeneratorTarget const* target, + std::string const& config); + protected: cmOutputConverter::RelativeRoot WorkingDirectory; diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 2f50b7f..a0263e4 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1344,6 +1344,13 @@ void cmLocalGenerator::GetTargetDefines(cmGeneratorTarget const* target, this->AddCompileDefinitions(defines, target, config, lang.c_str()); } +std::string cmLocalGenerator::GetTargetFortranFlags(cmGeneratorTarget const*, + std::string const&) +{ + // Implemented by specific generators that override this. + return std::string(); +} + std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib, OutputFormat format) { diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index af561f6..d04a723 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -321,6 +321,8 @@ public: std::string GetFrameworkFlags(std::string const& l, std::string const& config, cmGeneratorTarget* target); + virtual std::string GetTargetFortranFlags(cmGeneratorTarget const* target, + std::string const& config); virtual void ComputeObjectFilenames( std::map& mapping, -- cgit v0.12 From 3c488ce89955d00785bb4637c87b960da6c55ec8 Mon Sep 17 00:00:00 2001 From: Tobias Hunger Date: Fri, 10 Jun 2016 18:04:58 +0200 Subject: cmLocalGenerator: Adopt target compile flag generation Factor the flag generation out of cmCommonTargetGenerator::GetFlags into a new cmLocalGenerator::GetTargetCompileFlags method. This will allow it to be used without a target generator available. --- Source/cmCommonTargetGenerator.cxx | 33 ++------------------------------- Source/cmLocalGenerator.cxx | 27 +++++++++++++++++++++++++++ Source/cmLocalGenerator.h | 3 +++ 3 files changed, 32 insertions(+), 31 deletions(-) diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index aa7f5c0..101093d 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -120,38 +120,9 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string& l) ByLanguageMap::iterator i = this->FlagsByLanguage.find(l); if (i == this->FlagsByLanguage.end()) { std::string flags; - const char* lang = l.c_str(); - // Add language feature flags. - this->AddFeatureFlags(flags, lang); - - this->LocalGenerator->AddArchitectureFlags(flags, this->GeneratorTarget, - lang, this->ConfigName); - - // Fortran-specific flags computed for this target. - if (l == "Fortran") { - this->LocalGenerator->AppendFlags( - flags, this->LocalGenerator->GetTargetFortranFlags( - this->GeneratorTarget, this->ConfigName)); - } - - this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, lang, - this->ConfigName); - - this->LocalGenerator->AddVisibilityPresetFlags( - flags, this->GeneratorTarget, lang); - - // Append old-style preprocessor definition flags. - this->LocalGenerator->AppendFlags(flags, this->Makefile->GetDefineFlags()); - - // Add framework directory flags. - this->LocalGenerator->AppendFlags( - flags, this->LocalGenerator->GetFrameworkFlags(l, this->ConfigName, - this->GeneratorTarget)); - - // Add target-specific flags. - this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, lang, - this->ConfigName); + this->LocalGenerator->GetTargetCompileFlags(this->GeneratorTarget, + this->ConfigName, l, flags); ByLanguageMap::value_type entry(l, flags); i = this->FlagsByLanguage.insert(entry).first; diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index a0263e4..e2e7aa1 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -1272,6 +1272,33 @@ void cmLocalGenerator::GetTargetFlags( } } +void cmLocalGenerator::GetTargetCompileFlags(cmGeneratorTarget* target, + std::string const& config, + std::string const& lang, + std::string& flags) +{ + cmMakefile* mf = this->GetMakefile(); + + // Add language-specific flags. + this->AddLanguageFlags(flags, lang, config); + + if (target->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION", config)) { + this->AppendFeatureOptions(flags, lang, "IPO"); + } + + this->AddArchitectureFlags(flags, target, lang, config); + + if (lang == "Fortran") { + this->AppendFlags(flags, this->GetTargetFortranFlags(target, config)); + } + + this->AddCMP0018Flags(flags, target, lang, config); + this->AddVisibilityPresetFlags(flags, target, lang); + this->AppendFlags(flags, mf->GetDefineFlags()); + this->AppendFlags(flags, this->GetFrameworkFlags(lang, config, target)); + this->AddCompileOptions(flags, target, lang, config); +} + static std::string GetFrameworkFlags(const std::string& lang, const std::string& config, cmGeneratorTarget* target) diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index d04a723..66fbe01 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -317,6 +317,9 @@ public: void GetTargetDefines(cmGeneratorTarget const* target, std::string const& config, std::string const& lang, std::set& defines) const; + void GetTargetCompileFlags(cmGeneratorTarget* target, + std::string const& config, + std::string const& lang, std::string& flags); std::string GetFrameworkFlags(std::string const& l, std::string const& config, -- cgit v0.12 From 802b36fb62c7dc9a471bdb630536c82491e9cd0e Mon Sep 17 00:00:00 2001 From: Tobias Hunger Date: Fri, 10 Jun 2016 18:09:13 +0200 Subject: cmExtraSublimeTextGenerator: Use GetTargetCompileFlags Replace some custom code with equivalent code from the framework. This also fixes some fixmes left in the custom code. --- Source/cmExtraSublimeTextGenerator.cxx | 27 +++------------------------ 1 file changed, 3 insertions(+), 24 deletions(-) diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx index 9b3ea0b..2b9f64f 100644 --- a/Source/cmExtraSublimeTextGenerator.cxx +++ b/Source/cmExtraSublimeTextGenerator.cxx @@ -314,27 +314,14 @@ std::string cmExtraSublimeTextGenerator::ComputeFlagsForObject( cmSourceFile* source, cmLocalGenerator* lg, cmGeneratorTarget* gtgt) { std::string flags; - - cmMakefile* makefile = lg->GetMakefile(); std::string language = source->GetLanguage(); if (language.empty()) { language = "C"; } - const std::string& config = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"); - // Add language-specific flags. - lg->AddLanguageFlags(flags, language, config); - - lg->AddArchitectureFlags(flags, gtgt, language, config); + std::string const& config = + lg->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"); - // TODO: Fortran support. - // // Fortran-specific flags computed for this target. - // if(*l == "Fortran") - // { - // this->AddFortranFlags(flags); - // } - - // Add shared-library flags if needed. - lg->AddCMP0018Flags(flags, gtgt, language, config); + lg->GetTargetCompileFlags(gtgt, config, language, flags); // Add include directory flags. { @@ -345,17 +332,9 @@ std::string cmExtraSublimeTextGenerator::ComputeFlagsForObject( lg->AppendFlags(flags, includeFlags); } - // Append old-style preprocessor definition flags. - lg->AppendFlags(flags, makefile->GetDefineFlags()); - - // Add target-specific flags. - lg->AddCompileOptions(flags, gtgt, language, config); - // Add source file specific flags. lg->AppendFlags(flags, source->GetProperty("COMPILE_FLAGS")); - // TODO: Handle Apple frameworks. - return flags; } -- cgit v0.12