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

Merge topic 'refactor-flags' 

802b36fb cmExtraSublimeTextGenerator: Use GetTargetCompileFlags
3c488ce8 cmLocalGenerator: Adopt target compile flag generation
5467e794 cmLocalGenerator: Add method to get Fortran-specific compiler flags
49f10f0d cmGeneratorTarget: Adopt Fortran module directory generation
0392f72b Refactor Makefile/Ninja tool working directory storage
This commit is contained in:
Brad King 2016-06-20 09:55:56 -04:00 committed by CMake Topic Stage
parent af0f1e4f22 802b36fb62
commit 711caeb3bd
13 changed files with 157 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
Source/cmCommonTargetGenerator.cxx
View File

@ -19,17 +19,14 @@
#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<cmLocalCommonGenerator*>(gt->LocalGenerator))
, GlobalGenerator(static_cast<cmGlobalCommonGenerator*>(
gt->LocalGenerator->GetGlobalGenerator()))
, ConfigName(LocalGenerator->GetConfigName())
, ModuleDefinitionFile(GeneratorTarget->GetModuleDefinitionFile(ConfigName))
, FortranModuleDirectoryComputed(false)
{
}
@ -91,87 +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.
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->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->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<std::string> includes;
const std::string& config = this->ConfigName;
this->LocalGenerator->GetIncludeDirectories(
includes, this->GeneratorTarget, "C", config);
for (std::vector<std::string>::const_iterator idi = includes.begin();
idi != includes.end(); ++idi) {
std::string flg = modpath_flag;
flg +=
this->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL);
this->LocalGenerator->AppendFlags(flags, flg);
}
}
}
void cmCommonTargetGenerator::AppendFortranFormatFlags(
std::string& flags, cmSourceFile const& source)
{
@ -204,36 +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->AddFortranFlags(flags);
}
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;
@ -308,7 +197,8 @@ std::string cmCommonTargetGenerator::GetManifests()
for (std::vector<cmSourceFile const*>::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, " ");

13
Source/cmCommonTargetGenerator.h
View File

@ -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;
@ -55,15 +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);
std::string Convert(
std::string const& source, cmOutputConverter::RelativeRoot relative,
cmOutputConverter::OutputFormat output = cmOutputConverter::UNCHANGED);

27
Source/cmExtraSublimeTextGenerator.cxx
View File

@ -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);
std::string const& config =
lg->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
lg->AddArchitectureFlags(flags, gtgt, language, config);
// 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;
}

35
Source/cmGeneratorTarget.cxx
View File

@ -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);

6
Source/cmGeneratorTarget.h
View File

@ -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
{

52
Source/cmLocalCommonGenerator.cxx
View File

@ -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)
{
}
@ -34,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<std::string> includes;
this->GetIncludeDirectories(includes, target, "C", config);
for (std::vector<std::string>::const_iterator idi = includes.begin();
idi != includes.end(); ++idi) {
std::string flg = modpath_flag;
flg +=
this->Convert(*idi, cmOutputConverter::NONE, cmOutputConverter::SHELL);
this->AppendFlags(flags, flg);
}
}
return flags;
}

13
Source/cmLocalCommonGenerator.h
View File

@ -22,12 +22,23 @@ 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;
}
std::string GetTargetFortranFlags(cmGeneratorTarget const* target,
std::string const& config);
protected:
cmOutputConverter::RelativeRoot WorkingDirectory;
void SetConfigName();
std::string ConfigName;

34
Source/cmLocalGenerator.cxx
View File

@ -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)
@ -1344,6 +1371,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)
{

5
Source/cmLocalGenerator.h
View File

@ -317,10 +317,15 @@ public:
void GetTargetDefines(cmGeneratorTarget const* target,
std::string const& config, std::string const& lang,
std::set<std::string>& 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,
cmGeneratorTarget* target);
virtual std::string GetTargetFortranFlags(cmGeneratorTarget const* target,
std::string const& config);
virtual void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,

2
Source/cmLocalNinjaGenerator.cxx
View File

@ -25,7 +25,7 @@
cmLocalNinjaGenerator::cmLocalNinjaGenerator(cmGlobalGenerator* gg,
cmMakefile* mf)
: cmLocalCommonGenerator(gg, mf)
: cmLocalCommonGenerator(gg, mf, cmOutputConverter::HOME_OUTPUT)
, HomeRelativeOutputPath("")
{
this->TargetImplib = "$TARGET_IMPLIB";

2
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -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;

4
Source/cmMakefileTargetGenerator.cxx
View File

@ -32,7 +32,7 @@
#include <ctype.h>
cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target)
: cmCommonTargetGenerator(cmOutputConverter::START_OUTPUT, target)
: cmCommonTargetGenerator(target)
, OSXBundleGenerator(0)
, MacOSXContentGenerator(0)
{
@ -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

2
Source/cmNinjaTargetGenerator.cxx
View File

@ -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()