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

Merge topic 'factor-out-common-generator' 

fed5eb5b cmNinjaTargetGenerator: Use GetDefines method
eacacacd cmCommonTargetGenerator: Adopt GetDefines method
0837538e cmCommonTargetGenerator: Adopt GetFlags method
f4875bbd cmNinjaTargetGenerator: Add OX X framework flags
7891f5d7 cmMakefileTargetGenerator: Fix comment typo
73bfad72 cmNinjaTargetGenerator: Factor out AddIncludeFlags helper
6a56740e cmNinjaTargetGenerator: Add Fortran flag generation
058074d4 cmCommonTargetGenerator: Adopt GetFrameworkFlags
ab824018 cmCommonTargetGenerator: Adopt AppendFortranFormatFlags
0b22c0b8 cmCommonTargetGenerator: Adopt AddFortranFlags and friends
b2f51aef cmCommonTargetGenerator: Adopt Convert method
cdb5b657 cmCommonTargetGenerator: Adopt ModuleDefinitionFile member
beee7937 cmCommonTargetGenerator: Adopt GetFeature and friends
abfa5f2d cmCommonTargetGenerator: Adopt ConfigName member
9d41f6d8 cmLocalCommonGenerator: Adopt ConfigName member
a4a2518d cmLocalUnixMakefileGenerator3: Provide GetConfigName() accessor
...
This commit is contained in:
Brad King 2015-07-10 08:51:19 -04:00 committed by CMake Topic Stage
parent 4b486ccb1b fed5eb5b0e
commit 42d0420649
20 changed files with 646 additions and 581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/CMakeLists.txt
View File

@ -165,6 +165,8 @@ set(SRCS
cmCommandArgumentLexer.cxx
cmCommandArgumentParser.cxx
cmCommandArgumentParserHelper.cxx
cmCommonTargetGenerator.cxx
cmCommonTargetGenerator.h
cmComputeComponentGraph.cxx
cmComputeComponentGraph.h
cmComputeLinkDepends.cxx
@ -260,6 +262,8 @@ set(SRCS
cmGeneratorExpression.h
cmGeneratorTarget.cxx
cmGeneratorTarget.h
cmGlobalCommonGenerator.cxx
cmGlobalCommonGenerator.h
cmGlobalGenerator.cxx
cmGlobalGenerator.h
cmGlobalGeneratorFactory.h
@ -285,6 +289,8 @@ set(SRCS
cmListFileCache.cxx
cmListFileCache.h
cmListFileLexer.c
cmLocalCommonGenerator.cxx
cmLocalCommonGenerator.h
cmLocalGenerator.cxx
cmLocalGenerator.h
cmLocalUnixMakefileGenerator3.cxx

360
Source/cmCommonTargetGenerator.cxx Normal file
View File

@ -0,0 +1,360 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmCommonTargetGenerator.h"
#include "cmComputeLinkInformation.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalCommonGenerator.h"
#include "cmLocalCommonGenerator.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
cmCommonTargetGenerator::cmCommonTargetGenerator(cmGeneratorTarget* gt)
: GeneratorTarget(gt)
, Target(gt->Target)
, 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)
{
}
cmCommonTargetGenerator::~cmCommonTargetGenerator()
{
}
std::string const& cmCommonTargetGenerator::GetConfigName() const
{
return this->ConfigName;
}
std::string cmCommonTargetGenerator::Convert(
std::string const& source,
cmLocalGenerator::RelativeRoot relative,
cmLocalGenerator::OutputFormat output)
{
return this->LocalGenerator->Convert(source, relative, output);
}
//----------------------------------------------------------------------------
const char* cmCommonTargetGenerator::GetFeature(const std::string& feature)
{
return this->GeneratorTarget->GetFeature(feature, this->ConfigName);
}
//----------------------------------------------------------------------------
bool cmCommonTargetGenerator::GetFeatureAsBool(const std::string& feature)
{
return this->GeneratorTarget->GetFeatureAsBool(feature, this->ConfigName);
}
//----------------------------------------------------------------------------
void cmCommonTargetGenerator::AddFeatureFlags(
std::string& flags, const std::string& lang
)
{
// Add language-specific flags.
this->LocalGenerator->AddLanguageFlags(flags, lang, this->ConfigName);
if(this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION"))
{
this->LocalGenerator->AppendFeatureOptions(flags, lang, "IPO");
}
}
//----------------------------------------------------------------------------
void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
{
if(this->ModuleDefinitionFile.empty())
{
return;
}
// TODO: Create a per-language flag variable.
const char* defFileFlag =
this->Makefile->GetDefinition("CMAKE_LINK_DEF_FILE_FLAG");
if(!defFileFlag)
{
return;
}
// Append the flag and value. Use ConvertToLinkReference to help
// vs6's "cl -link" pass it to the linker.
std::string flag = defFileFlag;
flag += (this->LocalGenerator->ConvertToLinkReference(
this->ModuleDefinitionFile));
this->LocalGenerator->AppendFlags(flags, flag);
}
//----------------------------------------------------------------------------
const char* cmCommonTargetGenerator::GetFortranModuleDirectory()
{
// Compute the module directory.
if(!this->FortranModuleDirectoryComputed)
{
const char* target_mod_dir =
this->Target->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.
this->FortranModuleDirectory = target_mod_dir;
}
else
{
// Interpret relative to the current output directory.
this->FortranModuleDirectory =
this->Makefile->GetCurrentBinaryDirectory();
this->FortranModuleDirectory += "/";
this->FortranModuleDirectory += target_mod_dir;
}
// Make sure the module output directory exists.
cmSystemTools::MakeDirectory(this->FortranModuleDirectory.c_str());
}
this->FortranModuleDirectoryComputed = true;
}
// Return the computed directory.
if(this->FortranModuleDirectory.empty())
{
return 0;
}
else
{
return this->FortranModuleDirectory.c_str();
}
}
//----------------------------------------------------------------------------
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.
const char* mod_dir = this->GetFortranModuleDirectory();
if(!mod_dir)
{
mod_dir = this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_DEFAULT");
}
if(mod_dir)
{
const char* moddir_flag =
this->Makefile->GetRequiredDefinition("CMAKE_Fortran_MODDIR_FLAG");
std::string modflag = moddir_flag;
modflag += this->Convert(mod_dir,
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::SHELL);
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->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
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,
cmLocalGenerator::NONE,
cmLocalGenerator::SHELL);
this->LocalGenerator->AppendFlags(flags, flg);
}
}
}
//----------------------------------------------------------------------------
void
cmCommonTargetGenerator
::AppendFortranFormatFlags(std::string& flags, cmSourceFile const& source)
{
const char* srcfmt = source.GetProperty("Fortran_FORMAT");
cmLocalGenerator::FortranFormat format =
this->LocalGenerator->GetFortranFormat(srcfmt);
if(format == cmLocalGenerator::FortranFormatNone)
{
const char* tgtfmt = this->Target->GetProperty("Fortran_FORMAT");
format = this->LocalGenerator->GetFortranFormat(tgtfmt);
}
const char* var = 0;
switch (format)
{
case cmLocalGenerator::FortranFormatFixed:
var = "CMAKE_Fortran_FORMAT_FIXED_FLAG"; break;
case cmLocalGenerator::FortranFormatFree:
var = "CMAKE_Fortran_FORMAT_FREE_FLAG"; break;
default: break;
}
if(var)
{
this->LocalGenerator->AppendFlags(
flags, this->Makefile->GetDefinition(var));
}
}
//----------------------------------------------------------------------------
std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l)
{
if(!this->Makefile->IsOn("APPLE"))
{
return std::string();
}
std::string fwSearchFlagVar = "CMAKE_" + l + "_FRAMEWORK_SEARCH_FLAG";
const char* fwSearchFlag =
this->Makefile->GetDefinition(fwSearchFlagVar);
if(!(fwSearchFlag && *fwSearchFlag))
{
return std::string();
}
std::set<std::string> emitted;
#ifdef __APPLE__ /* don't insert this when crosscompiling e.g. to iphone */
emitted.insert("/System/Library/Frameworks");
#endif
std::vector<std::string> includes;
const std::string& config =
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
this->LocalGenerator->GetIncludeDirectories(includes,
this->GeneratorTarget,
"C", config);
// check all include directories for frameworks as this
// will already have added a -F for the framework
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
{
if(this->Target->NameResolvesToFramework(*i))
{
std::string frameworkDir = *i;
frameworkDir += "/../";
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
emitted.insert(frameworkDir);
}
}
std::string flags;
const char* cfg = this->LocalGenerator->GetConfigName().c_str();
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(cfg))
{
std::vector<std::string> const& frameworks = cli->GetFrameworkPaths();
for(std::vector<std::string>::const_iterator i = frameworks.begin();
i != frameworks.end(); ++i)
{
if(emitted.insert(*i).second)
{
flags += fwSearchFlag;
flags += this->LocalGenerator
->ConvertToOutputFormat(*i, cmLocalGenerator::SHELL);
flags += " ";
}
}
}
return flags;
}
//----------------------------------------------------------------------------
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->Target,
lang, this->ConfigName);
this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target,
lang);
// Add include directory flags.
this->AddIncludeFlags(flags, lang);
// Append old-style preprocessor definition flags.
this->LocalGenerator->
AppendFlags(flags, this->Makefile->GetDefineFlags());
// Add framework directory flags.
this->LocalGenerator->
AppendFlags(flags,this->GetFrameworkFlags(l));
// Add target-specific flags.
this->LocalGenerator->AddCompileOptions(flags, this->Target,
lang, this->ConfigName);
ByLanguageMap::value_type entry(l, flags);
i = this->FlagsByLanguage.insert(entry).first;
}
return i->second;
}
std::string cmCommonTargetGenerator::GetDefines(const std::string &l)
{
ByLanguageMap::iterator i = this->DefinesByLanguage.find(l);
if (i == this->DefinesByLanguage.end())
{
std::set<std::string> defines;
const char *lang = l.c_str();
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = this->Target->GetExportMacro())
{
this->LocalGenerator->AppendDefines(defines, exportMacro);
}
// Add preprocessor definitions for this target and configuration.
this->LocalGenerator->AddCompileDefinitions(defines, this->Target,
this->LocalGenerator->GetConfigName(), l);
std::string definesString;
this->LocalGenerator->JoinDefines(defines, definesString, lang);
ByLanguageMap::value_type entry(l, definesString);
i = this->DefinesByLanguage.insert(entry).first;
}
return i->second;
}

88
Source/cmCommonTargetGenerator.h Normal file
View File

@ -0,0 +1,88 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmCommonTargetGenerator_h
#define cmCommonTargetGenerator_h
#include "cmStandardIncludes.h"
#include "cmLocalGenerator.h"
class cmGeneratorTarget;
class cmGlobalCommonGenerator;
class cmLocalCommonGenerator;
class cmMakefile;
class cmSourceFile;
class cmTarget;
/** \class cmCommonTargetGenerator
* \brief Common infrastructure for Makefile and Ninja per-target generators
*/
class cmCommonTargetGenerator
{
public:
cmCommonTargetGenerator(cmGeneratorTarget* gt);
virtual ~cmCommonTargetGenerator();
std::string const& GetConfigName() const;
protected:
// Add language feature flags.
void AddFeatureFlags(std::string& flags, const std::string& lang);
// Feature query methods.
const char* GetFeature(const std::string& feature);
bool GetFeatureAsBool(const std::string& feature);
// Helper to add flag for windows .def file.
void AddModuleDefinitionFlag(std::string& flags);
cmGeneratorTarget* GeneratorTarget;
cmTarget* Target;
cmMakefile* Makefile;
cmLocalCommonGenerator* LocalGenerator;
cmGlobalCommonGenerator* GlobalGenerator;
std::string ConfigName;
// The windows module definition source file (.def), if any.
std::string ModuleDefinitionFile;
// Target-wide Fortran module output directory.
bool FortranModuleDirectoryComputed;
std::string FortranModuleDirectory;
const char* GetFortranModuleDirectory();
// Compute target-specific Fortran language flags.
void AddFortranFlags(std::string& flags);
std::string Convert(std::string const& source,
cmLocalGenerator::RelativeRoot relative,
cmLocalGenerator::OutputFormat output =
cmLocalGenerator::UNCHANGED);
void AppendFortranFormatFlags(std::string& flags,
cmSourceFile const& source);
// Return the a string with -F flags on apple
std::string GetFrameworkFlags(std::string const& l);
virtual void AddIncludeFlags(std::string& flags,
std::string const& lang) = 0;
typedef std::map<std::string, std::string> ByLanguageMap;
std::string GetFlags(const std::string &l);
ByLanguageMap FlagsByLanguage;
std::string GetDefines(const std::string &l);
ByLanguageMap DefinesByLanguage;
};
#endif

21
Source/cmGlobalCommonGenerator.cxx Normal file
View File

@ -0,0 +1,21 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmGlobalCommonGenerator.h"
cmGlobalCommonGenerator::cmGlobalCommonGenerator(cmake* cm):
cmGlobalGenerator(cm)
{
}
cmGlobalCommonGenerator::~cmGlobalCommonGenerator()
{
}

27
Source/cmGlobalCommonGenerator.h Normal file
View File

@ -0,0 +1,27 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmGlobalCommonGenerator_h
#define cmGlobalCommonGenerator_h
#include "cmGlobalGenerator.h"
/** \class cmGlobalCommonGenerator
* \brief Common infrastructure for Makefile and Ninja global generators.
*/
class cmGlobalCommonGenerator : public cmGlobalGenerator
{
public:
cmGlobalCommonGenerator(cmake* cm);
~cmGlobalCommonGenerator();
};
#endif

2
Source/cmGlobalNinjaGenerator.cxx
View File

@ -505,7 +505,7 @@ void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os,
cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
: cmGlobalGenerator(cm)
: cmGlobalCommonGenerator(cm)
, BuildFileStream(0)
, RulesFileStream(0)
, CompileCommandsStream(0)

4
Source/cmGlobalNinjaGenerator.h
View File

@ -13,7 +13,7 @@
#ifndef cmGlobalNinjaGenerator_h
# define cmGlobalNinjaGenerator_h
# include "cmGlobalGenerator.h"
# include "cmGlobalCommonGenerator.h"
# include "cmGlobalGeneratorFactory.h"
# include "cmNinjaTypes.h"
@ -42,7 +42,7 @@ class cmGeneratorTarget;
* - We extensively use Ninja variable overloading system to minimize the
* number of generated rules.
*/
class cmGlobalNinjaGenerator : public cmGlobalGenerator
class cmGlobalNinjaGenerator : public cmGlobalCommonGenerator
{
public:
/// The default name of Ninja's build file. Typically: build.ninja.

8
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -21,7 +21,7 @@
#include "cmAlgorithms.h"
cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3(cmake* cm)
: cmGlobalGenerator(cm)
: cmGlobalCommonGenerator(cm)
{
// This type of makefile always requires unix style paths
this->ForceUnixPaths = true;
@ -483,7 +483,7 @@ cmGlobalUnixMakefileGenerator3
if((!check_all || !gtarget->GetPropertyAsBool("EXCLUDE_FROM_ALL")) &&
(!check_relink ||
gtarget->Target
->NeedRelinkBeforeInstall(lg->ConfigurationName)))
->NeedRelinkBeforeInstall(lg->GetConfigName())))
{
std::string tname = lg->GetRelativeTargetDirectory(*gtarget->Target);
tname += "/";
@ -692,7 +692,7 @@ cmGlobalUnixMakefileGenerator3
// Add a local name for the rule to relink the target before
// installation.
if(gtarget->Target
->NeedRelinkBeforeInstall(lg->ConfigurationName))
->NeedRelinkBeforeInstall(lg->GetConfigName()))
{
makeTargetName = lg->GetRelativeTargetDirectory(*gtarget->Target);
makeTargetName += "/preinstall";
@ -865,7 +865,7 @@ cmGlobalUnixMakefileGenerator3
// Add rules to prepare the target for installation.
if(gtarget->Target
->NeedRelinkBeforeInstall(lg->ConfigurationName))
->NeedRelinkBeforeInstall(lg->GetConfigName()))
{
localName = lg->GetRelativeTargetDirectory(*gtarget->Target);
localName += "/preinstall";

4
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -12,7 +12,7 @@
#ifndef cmGlobalUnixMakefileGenerator3_h
#define cmGlobalUnixMakefileGenerator3_h
#include "cmGlobalGenerator.h"
#include "cmGlobalCommonGenerator.h"
#include "cmGlobalGeneratorFactory.h"
class cmGeneratedFileStream;
@ -51,7 +51,7 @@ class cmLocalUnixMakefileGenerator3;
*/
class cmGlobalUnixMakefileGenerator3 : public cmGlobalGenerator
class cmGlobalUnixMakefileGenerator3 : public cmGlobalCommonGenerator
{
public:
cmGlobalUnixMakefileGenerator3(cmake* cm);

40
Source/cmLocalCommonGenerator.cxx Normal file
View File

@ -0,0 +1,40 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmLocalCommonGenerator.h"
#include "cmMakefile.h"
cmLocalCommonGenerator::cmLocalCommonGenerator(cmGlobalGenerator* gg,
cmLocalGenerator* parent,
cmState::Snapshot snapshot):
cmLocalGenerator(gg, parent, snapshot)
{
}
cmLocalCommonGenerator::~cmLocalCommonGenerator()
{
}
void cmLocalCommonGenerator::SetConfigName()
{
// Store the configuration name that will be generated.
if(const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
{
// Use the build type given by the user.
this->ConfigName = config;
}
else
{
// No configuration type given.
this->ConfigName = "";
}
}

39
Source/cmLocalCommonGenerator.h Normal file
View File

@ -0,0 +1,39 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2015 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmLocalCommonGenerator_h
#define cmLocalCommonGenerator_h
#include "cmLocalGenerator.h"
class cmCommonTargetGenerator;
/** \class cmLocalCommonGenerator
* \brief Common infrastructure for Makefile and Ninja local generators.
*/
class cmLocalCommonGenerator: public cmLocalGenerator
{
public:
cmLocalCommonGenerator(cmGlobalGenerator* gg,
cmLocalGenerator* parent,
cmState::Snapshot snapshot);
~cmLocalCommonGenerator();
std::string const& GetConfigName() { return this->ConfigName; }
protected:
void SetConfigName();
std::string ConfigName;
friend class cmCommonTargetGenerator;
};
#endif

19
Source/cmLocalNinjaGenerator.cxx
View File

@ -25,8 +25,7 @@
cmLocalNinjaGenerator::cmLocalNinjaGenerator(cmGlobalGenerator* gg,
cmLocalGenerator* parent,
cmState::Snapshot snapshot)
: cmLocalGenerator(gg, parent, snapshot)
, ConfigName("")
: cmLocalCommonGenerator(gg, parent, snapshot)
, HomeRelativeOutputPath("")
{
this->TargetImplib = "$TARGET_IMPLIB";
@ -261,22 +260,6 @@ void cmLocalNinjaGenerator::WriteNinjaFilesInclusion(std::ostream& os)
os << "\n";
}
void cmLocalNinjaGenerator::SetConfigName()
{
// Store the configuration name that will be generated.
if(const char* config =
this->GetMakefile()->GetDefinition("CMAKE_BUILD_TYPE"))
{
// Use the build type given by the user.
this->ConfigName = config;
}
else
{
// No configuration type given.
this->ConfigName = "";
}
}
//----------------------------------------------------------------------------
void cmLocalNinjaGenerator::ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,

10
Source/cmLocalNinjaGenerator.h
View File

@ -13,7 +13,7 @@
#ifndef cmLocalNinjaGenerator_h
# define cmLocalNinjaGenerator_h
# include "cmLocalGenerator.h"
# include "cmLocalCommonGenerator.h"
# include "cmNinjaTypes.h"
class cmCustomCommandGenerator;
@ -28,7 +28,7 @@ class cmake;
* cmLocalNinjaGenerator produces a local build.ninja file from its
* member Makefile.
*/
class cmLocalNinjaGenerator : public cmLocalGenerator
class cmLocalNinjaGenerator : public cmLocalCommonGenerator
{
public:
cmLocalNinjaGenerator(cmGlobalGenerator* gg, cmLocalGenerator* parent,
@ -46,9 +46,6 @@ public:
const cmake* GetCMakeInstance() const;
cmake* GetCMakeInstance();
std::string const& GetConfigName() const
{ return this->ConfigName; }
/// @returns the relative path between the HomeOutputDirectory and this
/// local generators StartOutputDirectory.
std::string GetHomeRelativeOutputPath() const
@ -110,8 +107,6 @@ private:
void WriteProcessedMakefile(std::ostream& os);
void WritePools(std::ostream& os);
void SetConfigName();
void WriteCustomCommandRule();
void WriteCustomCommandBuildStatement(cmCustomCommand const *cc,
const cmNinjaDeps& orderOnlyDeps);
@ -120,7 +115,6 @@ private:
std::string MakeCustomLauncher(cmCustomCommandGenerator const& ccg);
std::string ConfigName;
std::string HomeRelativeOutputPath;
typedef std::map<cmCustomCommand const*, std::set<cmTarget*> >

24
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -82,7 +82,7 @@ static std::string cmSplitExtension(std::string const& in, std::string& base)
cmLocalUnixMakefileGenerator3::
cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmLocalGenerator* parent,
cmState::Snapshot snapshot)
: cmLocalGenerator(gg, parent, snapshot)
: cmLocalCommonGenerator(gg, parent, snapshot)
{
this->MakefileVariableSize = 0;
this->ColorMakefile = false;
@ -100,17 +100,7 @@ cmLocalUnixMakefileGenerator3::~cmLocalUnixMakefileGenerator3()
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::Generate()
{
// Store the configuration name that will be generated.
if(const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
{
// Use the build type given by the user.
this->ConfigurationName = config;
}
else
{
// No configuration type given.
this->ConfigurationName = "";
}
this->SetConfigName();
// Record whether some options are enabled to avoid checking many
// times later.
@ -497,7 +487,7 @@ void cmLocalUnixMakefileGenerator3
// Add a local name for the rule to relink the target before
// installation.
if(t->second->Target
->NeedRelinkBeforeInstall(this->ConfigurationName))
->NeedRelinkBeforeInstall(this->ConfigName))
{
makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target);
makeTargetName += "/preinstall";
@ -1017,7 +1007,7 @@ cmLocalUnixMakefileGenerator3
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i)
{
cmCustomCommandGenerator ccg(*i, this->ConfigurationName,
cmCustomCommandGenerator ccg(*i, this->ConfigName,
this->Makefile);
this->AppendCustomDepend(depends, ccg);
}
@ -1034,7 +1024,7 @@ cmLocalUnixMakefileGenerator3
{
// Lookup the real name of the dependency in case it is a CMake target.
std::string dep;
if(this->GetRealDependency(*d, this->ConfigurationName,
if(this->GetRealDependency(*d, this->ConfigName,
dep))
{
depends.push_back(dep);
@ -1053,7 +1043,7 @@ cmLocalUnixMakefileGenerator3
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
i != ccs.end(); ++i)
{
cmCustomCommandGenerator ccg(*i, this->ConfigurationName,
cmCustomCommandGenerator ccg(*i, this->ConfigName,
this->Makefile);
this->AppendCustomCommand(commands, ccg, target, true, relative);
}
@ -2043,7 +2033,7 @@ void cmLocalUnixMakefileGenerator3
// Build a list of preprocessor definitions for the target.
std::set<std::string> defines;
this->AddCompileDefinitions(defines, &target,
this->ConfigurationName, l->first);
this->ConfigName, l->first);
if(!defines.empty())
{
cmakefileStream

7
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -12,7 +12,7 @@
#ifndef cmLocalUnixMakefileGenerator3_h
#define cmLocalUnixMakefileGenerator3_h
#include "cmLocalGenerator.h"
#include "cmLocalCommonGenerator.h"
// for cmDepends::DependencyVector
#include "cmDepends.h"
@ -31,7 +31,7 @@ class cmSourceFile;
* cmLocalUnixMakefileGenerator3 produces a LocalUnix makefile from its
* member Makefile.
*/
class cmLocalUnixMakefileGenerator3 : public cmLocalGenerator
class cmLocalUnixMakefileGenerator3 : public cmLocalCommonGenerator
{
public:
cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg,
@ -46,7 +46,6 @@ public:
*/
virtual void Generate();
// this returns the relative path between the HomeOutputDirectory and this
// local generators StartOutputDirectory
const std::string &GetHomeRelativeOutputPath();
@ -253,8 +252,6 @@ private:
ImplicitDependTargetMap ImplicitDepends;
std::string ConfigurationName;
std::string HomeRelativeOutputPath;
struct LocalObjectEntry

330
Source/cmMakefileTargetGenerator.cxx
View File

@ -33,23 +33,19 @@
#include <ctype.h>
cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target)
: OSXBundleGenerator(0)
: cmCommonTargetGenerator(target)
, OSXBundleGenerator(0)
, MacOSXContentGenerator(0)
{
this->BuildFileStream = 0;
this->InfoFileStream = 0;
this->FlagFileStream = 0;
this->CustomCommandDriver = OnBuild;
this->FortranModuleDirectoryComputed = false;
this->Target = target->Target;
this->Makefile = this->Target->GetMakefile();
this->LocalGenerator =
static_cast<cmLocalUnixMakefileGenerator3*>(target->GetLocalGenerator());
this->ConfigName = this->LocalGenerator->ConfigurationName.c_str();
this->GlobalGenerator =
static_cast<cmGlobalUnixMakefileGenerator3*>(
this->LocalGenerator->GetGlobalGenerator());
this->GeneratorTarget = target;
cmake* cm = this->GlobalGenerator->GetCMakeInstance();
this->NoRuleMessages = false;
if(const char* ruleStatus = cm->GetState()
@ -276,80 +272,6 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
<< "\n\n";
}
//----------------------------------------------------------------------------
std::string cmMakefileTargetGenerator::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->Target,
lang, this->ConfigName);
this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target,
lang);
// Add include directory flags.
this->AddIncludeFlags(flags, lang);
// Append old-style preprocessor definition flags.
this->LocalGenerator->
AppendFlags(flags, this->Makefile->GetDefineFlags());
// Add include directory flags.
this->LocalGenerator->
AppendFlags(flags,this->GetFrameworkFlags(l));
// Add target-specific flags.
this->LocalGenerator->AddCompileOptions(flags, this->Target,
lang, this->ConfigName);
ByLanguageMap::value_type entry(l, flags);
i = this->FlagsByLanguage.insert(entry).first;
}
return i->second;
}
std::string cmMakefileTargetGenerator::GetDefines(const std::string &l)
{
ByLanguageMap::iterator i = this->DefinesByLanguage.find(l);
if (i == this->DefinesByLanguage.end())
{
std::set<std::string> defines;
const char *lang = l.c_str();
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = this->Target->GetExportMacro())
{
this->LocalGenerator->AppendDefines(defines, exportMacro);
}
// Add preprocessor definitions for this target and configuration.
this->LocalGenerator->AddCompileDefinitions(defines, this->Target,
this->LocalGenerator->ConfigurationName, l);
std::string definesString;
this->LocalGenerator->JoinDefines(defines, definesString, lang);
ByLanguageMap::value_type entry(l, definesString);
i = this->DefinesByLanguage.insert(entry).first;
}
return i->second;
}
void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
{
// write language flags for target
@ -508,35 +430,6 @@ void cmMakefileTargetGenerator
srcFullPath.c_str());
}
//----------------------------------------------------------------------------
void
cmMakefileTargetGenerator
::AppendFortranFormatFlags(std::string& flags, cmSourceFile const& source)
{
const char* srcfmt = source.GetProperty("Fortran_FORMAT");
cmLocalGenerator::FortranFormat format =
this->LocalGenerator->GetFortranFormat(srcfmt);
if(format == cmLocalGenerator::FortranFormatNone)
{
const char* tgtfmt = this->Target->GetProperty("Fortran_FORMAT");
format = this->LocalGenerator->GetFortranFormat(tgtfmt);
}
const char* var = 0;
switch (format)
{
case cmLocalGenerator::FortranFormatFixed:
var = "CMAKE_Fortran_FORMAT_FIXED_FLAG"; break;
case cmLocalGenerator::FortranFormatFree:
var = "CMAKE_Fortran_FORMAT_FREE_FLAG"; break;
default: break;
}
if(var)
{
this->LocalGenerator->AppendFlags(
flags, this->Makefile->GetDefinition(var));
}
}
//----------------------------------------------------------------------------
void
cmMakefileTargetGenerator
@ -567,7 +460,7 @@ cmMakefileTargetGenerator
this->LocalGenerator->AppendFlags(flags, langFlags);
std::string configUpper =
cmSystemTools::UpperCase(this->LocalGenerator->ConfigurationName);
cmSystemTools::UpperCase(this->LocalGenerator->GetConfigName());
// Add Fortran format flags.
if(lang == "Fortran")
@ -1158,7 +1051,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
<< "# Targets to which this target links.\n"
<< "set(CMAKE_TARGET_LINKED_INFO_FILES\n";
std::set<cmTarget const*> emitted;
const char* cfg = this->LocalGenerator->ConfigurationName.c_str();
const char* cfg = this->LocalGenerator->GetConfigName().c_str();
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(cfg))
{
cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
@ -1557,67 +1450,6 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule(
depends, no_commands, true);
}
//----------------------------------------------------------------------------
std::string cmMakefileTargetGenerator::GetFrameworkFlags(std::string const& l)
{
if(!this->Makefile->IsOn("APPLE"))
{
return std::string();
}
std::string fwSearchFlagVar = "CMAKE_" + l + "_FRAMEWORK_SEARCH_FLAG";
const char* fwSearchFlag =
this->Makefile->GetDefinition(fwSearchFlagVar);
if(!(fwSearchFlag && *fwSearchFlag))
{
return std::string();
}
std::set<std::string> emitted;
#ifdef __APPLE__ /* don't insert this when crosscompiling e.g. to iphone */
emitted.insert("/System/Library/Frameworks");
#endif
std::vector<std::string> includes;
const std::string& config =
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
this->LocalGenerator->GetIncludeDirectories(includes,
this->GeneratorTarget,
"C", config);
// check all include directories for frameworks as this
// will already have added a -F for the framework
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
{
if(this->Target->NameResolvesToFramework(*i))
{
std::string frameworkDir = *i;
frameworkDir += "/../";
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
emitted.insert(frameworkDir);
}
}
std::string flags;
const char* cfg = this->LocalGenerator->ConfigurationName.c_str();
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(cfg))
{
std::vector<std::string> const& frameworks = cli->GetFrameworkPaths();
for(std::vector<std::string>::const_iterator i = frameworks.begin();
i != frameworks.end(); ++i)
{
if(emitted.insert(*i).second)
{
flags += fwSearchFlag;
flags += this->LocalGenerator
->ConvertToOutputFormat(*i, cmLocalGenerator::SHELL);
flags += " ";
}
}
}
return flags;
}
//----------------------------------------------------------------------------
void cmMakefileTargetGenerator
::AppendTargetDepends(std::vector<std::string>& depends)
@ -1629,7 +1461,7 @@ void cmMakefileTargetGenerator
}
// Loop over all library dependencies.
const char* cfg = this->LocalGenerator->ConfigurationName.c_str();
const char* cfg = this->LocalGenerator->GetConfigName().c_str();
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(cfg))
{
std::vector<std::string> const& libDeps = cli->GetDepends();
@ -1671,11 +1503,9 @@ void cmMakefileTargetGenerator
this->AppendTargetDepends(depends);
// Add a dependency on the link definitions file, if any.
std::string def = this->GeneratorTarget->GetModuleDefinitionFile(
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
if(!def.empty())
if(!this->ModuleDefinitionFile.empty())
{
depends.push_back(def);
depends.push_back(this->ModuleDefinitionFile);
}
// Add user-specified dependencies.
@ -1982,149 +1812,3 @@ void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
this->LocalGenerator->AppendFlags(flags, includeFlags);
}
}
//----------------------------------------------------------------------------
const char* cmMakefileTargetGenerator::GetFortranModuleDirectory()
{
// Compute the module directory.
if(!this->FortranModuleDirectoryComputed)
{
const char* target_mod_dir =
this->Target->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.
this->FortranModuleDirectory = target_mod_dir;
}
else
{
// Interpret relative to the current output directory.
this->FortranModuleDirectory =
this->Makefile->GetCurrentBinaryDirectory();
this->FortranModuleDirectory += "/";
this->FortranModuleDirectory += target_mod_dir;
}
// Make sure the module output directory exists.
cmSystemTools::MakeDirectory(this->FortranModuleDirectory.c_str());
}
this->FortranModuleDirectoryComputed = true;
}
// Return the computed directory.
if(this->FortranModuleDirectory.empty())
{
return 0;
}
else
{
return this->FortranModuleDirectory.c_str();
}
}
//----------------------------------------------------------------------------
void cmMakefileTargetGenerator::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.
const char* mod_dir = this->GetFortranModuleDirectory();
if(!mod_dir)
{
mod_dir = this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_DEFAULT");
}
if(mod_dir)
{
const char* moddir_flag =
this->Makefile->GetRequiredDefinition("CMAKE_Fortran_MODDIR_FLAG");
std::string modflag = moddir_flag;
modflag += this->Convert(mod_dir,
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::SHELL);
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->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
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,
cmLocalGenerator::NONE,
cmLocalGenerator::SHELL);
this->LocalGenerator->AppendFlags(flags, flg);
}
}
}
//----------------------------------------------------------------------------
void cmMakefileTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
{
std::string def = this->GeneratorTarget->GetModuleDefinitionFile(
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
if(def.empty())
{
return;
}
// TODO: Create a per-language flag variable.
const char* defFileFlag =
this->Makefile->GetDefinition("CMAKE_LINK_DEF_FILE_FLAG");
if(!defFileFlag)
{
return;
}
// Append the flag and value. Use ConvertToLinkReference to help
// vs6's "cl -link" pass it to the linker.
std::string flag = defFileFlag;
flag += (this->LocalGenerator->ConvertToLinkReference(def));
this->LocalGenerator->AppendFlags(flags, flag);
}
//----------------------------------------------------------------------------
const char* cmMakefileTargetGenerator::GetFeature(const std::string& feature)
{
return this->GeneratorTarget->GetFeature(feature, this->ConfigName);
}
//----------------------------------------------------------------------------
bool cmMakefileTargetGenerator::GetFeatureAsBool(const std::string& feature)
{
return this->GeneratorTarget->GetFeatureAsBool(feature, this->ConfigName);
}
//----------------------------------------------------------------------------
void cmMakefileTargetGenerator::AddFeatureFlags(
std::string& flags, const std::string& lang
)
{
// Add language-specific flags.
this->LocalGenerator->AddLanguageFlags(flags, lang, this->ConfigName);
if(this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION"))
{
this->LocalGenerator->AppendFeatureOptions(flags, lang, "IPO");
}
}

50
Source/cmMakefileTargetGenerator.h
View File

@ -12,6 +12,8 @@
#ifndef cmMakefileTargetGenerator_h
#define cmMakefileTargetGenerator_h
#include "cmCommonTargetGenerator.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmOSXBundleGenerator.h"
@ -30,7 +32,7 @@ class cmSourceFile;
* \brief Support Routines for writing makefiles
*
*/
class cmMakefileTargetGenerator
class cmMakefileTargetGenerator: public cmCommonTargetGenerator
{
public:
// constructor to set the ivars
@ -124,12 +126,6 @@ protected:
void DriveCustomCommands(std::vector<std::string>& depends);
// Return the a string with -F flags on apple
std::string GetFrameworkFlags(std::string const& l);
void AppendFortranFormatFlags(std::string& flags,
cmSourceFile const& source);
// append intertarget dependencies
void AppendTargetDepends(std::vector<std::string>& depends);
@ -173,12 +169,8 @@ protected:
virtual void CloseFileStreams();
void RemoveForbiddenFlags(const char* flagVar, const std::string& linkLang,
std::string& linkFlags);
cmTarget *Target;
cmGeneratorTarget* GeneratorTarget;
cmLocalUnixMakefileGenerator3 *LocalGenerator;
cmGlobalUnixMakefileGenerator3 *GlobalGenerator;
cmMakefile *Makefile;
std::string ConfigName;
enum CustomCommandDriveType { OnBuild, OnDepends, OnUtility };
CustomCommandDriveType CustomCommandDriver;
@ -242,42 +234,6 @@ protected:
std::set<std::string> MacContentFolders;
cmOSXBundleGenerator* OSXBundleGenerator;
MacOSXContentGeneratorType* MacOSXContentGenerator;
typedef std::map<std::string, std::string> ByLanguageMap;
std::string GetFlags(const std::string &l);
ByLanguageMap FlagsByLanguage;
std::string GetDefines(const std::string &l);
ByLanguageMap DefinesByLanguage;
// Target-wide Fortran module output directory.
bool FortranModuleDirectoryComputed;
std::string FortranModuleDirectory;
const char* GetFortranModuleDirectory();
// Compute target-specific Fortran language flags.
void AddFortranFlags(std::string& flags);
// Helper to add flag for windows .def file.
void AddModuleDefinitionFlag(std::string& flags);
// Add language feature flags.
void AddFeatureFlags(std::string& flags, const std::string& lang);
// Feature query methods.
const char* GetFeature(const std::string& feature);
bool GetFeatureAsBool(const std::string& feature);
//==================================================================
// Convenience routines that do nothing more than forward to
// implementaitons
std::string Convert(const std::string& source,
cmLocalGenerator::RelativeRoot relative,
cmLocalGenerator::OutputFormat output =
cmLocalGenerator::UNCHANGED)
{
return this->LocalGenerator->Convert(source, relative, output);
}
};
#endif

161
Source/cmNinjaTargetGenerator.cxx
View File

@ -58,17 +58,14 @@ cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
}
cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
:
: cmCommonTargetGenerator(target),
MacOSXContentGenerator(0),
OSXBundleGenerator(0),
MacContentFolders(),
Target(target->Target),
Makefile(target->Makefile),
LocalGenerator(
static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator())),
Objects()
{
this->GeneratorTarget = target;
MacOSXContentGenerator = new MacOSXContentGeneratorType(this);
}
@ -92,11 +89,6 @@ cmGlobalNinjaGenerator* cmNinjaTargetGenerator::GetGlobalGenerator() const
return this->LocalGenerator->GetGlobalNinjaGenerator();
}
std::string const& cmNinjaTargetGenerator::GetConfigName() const
{
return this->LocalGenerator->GetConfigName();
}
std::string cmNinjaTargetGenerator::LanguageCompilerRule(
const std::string& lang) const
{
@ -104,32 +96,6 @@ std::string cmNinjaTargetGenerator::LanguageCompilerRule(
cmGlobalNinjaGenerator::EncodeRuleName(this->Target->GetName());
}
// TODO: Picked up from cmMakefileTargetGenerator. Refactor it.
const char* cmNinjaTargetGenerator::GetFeature(const std::string& feature)
{
return this->GeneratorTarget->GetFeature(feature, this->GetConfigName());
}
// TODO: Picked up from cmMakefileTargetGenerator. Refactor it.
bool cmNinjaTargetGenerator::GetFeatureAsBool(const std::string& feature)
{
return this->GeneratorTarget->GetFeatureAsBool(feature,
this->GetConfigName());
}
// TODO: Picked up from cmMakefileTargetGenerator. Refactor it.
void cmNinjaTargetGenerator::AddFeatureFlags(std::string& flags,
const std::string& lang)
{
// Add language-specific flags.
this->LocalGenerator->AddLanguageFlags(flags, lang, this->GetConfigName());
if(this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION"))
{
this->LocalGenerator->AppendFeatureOptions(flags, lang, "IPO");
}
}
std::string
cmNinjaTargetGenerator::OrderDependsTargetForTarget()
{
@ -144,71 +110,37 @@ std::string
cmNinjaTargetGenerator::ComputeFlagsForObject(cmSourceFile const* source,
const std::string& language)
{
// TODO: Fortran support.
// // Fortran-specific flags computed for this target.
// if(*l == "Fortran")
// {
// this->AddFortranFlags(flags);
// }
bool hasLangCached = this->LanguageFlags.count(language) != 0;
std::string& languageFlags = this->LanguageFlags[language];
if(!hasLangCached)
{
this->AddFeatureFlags(languageFlags, language);
this->GetLocalGenerator()->AddArchitectureFlags(languageFlags,
this->GeneratorTarget,
language,
this->GetConfigName());
// Add shared-library flags if needed.
this->LocalGenerator->AddCMP0018Flags(languageFlags, this->Target,
language,
this->GetConfigName());
this->LocalGenerator->AddVisibilityPresetFlags(languageFlags, this->Target,
language);
std::vector<std::string> includes;
this->LocalGenerator->GetIncludeDirectories(includes,
this->GeneratorTarget,
language,
this->GetConfigName());
// Add include directory flags.
std::string includeFlags =
this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
language,
language == "RC" ? true : false, // full include paths for RC
// needed by cmcldeps
false,
this->GetConfigName());
if (this->GetGlobalGenerator()->IsGCCOnWindows())
cmSystemTools::ReplaceString(includeFlags, "\\", "/");
this->LocalGenerator->AppendFlags(languageFlags, includeFlags);
// Append old-style preprocessor definition flags.
this->LocalGenerator->AppendFlags(languageFlags,
this->Makefile->GetDefineFlags());
// Add target-specific flags.
this->LocalGenerator->AddCompileOptions(languageFlags, this->Target,
language,
this->GetConfigName());
}
std::string flags = languageFlags;
std::string flags = this->GetFlags(language);
// Add source file specific flags.
this->LocalGenerator->AppendFlags(flags,
source->GetProperty("COMPILE_FLAGS"));
// TODO: Handle Apple frameworks.
return flags;
}
void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
std::string const& language)
{
std::vector<std::string> includes;
this->LocalGenerator->GetIncludeDirectories(includes,
this->GeneratorTarget,
language,
this->GetConfigName());
// Add include directory flags.
std::string includeFlags =
this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
language,
language == "RC" ? true : false, // full include paths for RC
// needed by cmcldeps
false,
this->GetConfigName());
if (this->GetGlobalGenerator()->IsGCCOnWindows())
cmSystemTools::ReplaceString(includeFlags, "\\", "/");
this->LocalGenerator->AppendFlags(languageFlags, includeFlags);
}
bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const
{
if (lang == "C" || lang == "CXX")
@ -231,16 +163,6 @@ cmNinjaTargetGenerator::
ComputeDefines(cmSourceFile const* source, const std::string& language)
{
std::set<std::string> defines;
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = this->Target->GetExportMacro())
{
this->LocalGenerator->AppendDefines(defines, exportMacro);
}
// Add preprocessor definitions for this target and configuration.
this->LocalGenerator->AddCompileDefinitions(defines, this->Target,
this->GetConfigName(), language);
this->LocalGenerator->AppendDefines
(defines,
source->GetProperty("COMPILE_DEFINITIONS"));
@ -252,7 +174,7 @@ ComputeDefines(cmSourceFile const* source, const std::string& language)
source->GetProperty(defPropName));
}
std::string definesString;
std::string definesString = this->GetDefines(language);
this->LocalGenerator->JoinDefines(defines, definesString,
language);
@ -278,7 +200,7 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
// Add a dependency on the link definitions file, if any.
if(!this->ModuleDefinitionFile.empty())
{
result.push_back(this->ModuleDefinitionFile);
result.push_back(this->ConvertToNinjaPath(this->ModuleDefinitionFile));
}
return result;
@ -608,11 +530,6 @@ cmNinjaTargetGenerator
{
this->WriteObjectBuildStatement(*si, !orderOnlyDeps.empty());
}
std::string def = this->GeneratorTarget->GetModuleDefinitionFile(config);
if(!def.empty())
{
this->ModuleDefinitionFile = this->ConvertToNinjaPath(def);
}
this->GetBuildFileStream() << "\n";
}
@ -762,32 +679,6 @@ cmNinjaTargetGenerator
}
}
//----------------------------------------------------------------------------
void
cmNinjaTargetGenerator
::AddModuleDefinitionFlag(std::string& flags)
{
if(this->ModuleDefinitionFile.empty())
{
return;
}
// TODO: Create a per-language flag variable.
const char* defFileFlag =
this->Makefile->GetDefinition("CMAKE_LINK_DEF_FILE_FLAG");
if(!defFileFlag)
{
return;
}
// Append the flag and value. Use ConvertToLinkReference to help
// vs6's "cl -link" pass it to the linker.
std::string flag = defFileFlag;
flag += (this->LocalGenerator->ConvertToLinkReference(
this->ModuleDefinitionFile));
this->LocalGenerator->AppendFlags(flags, flag);
}
void
cmNinjaTargetGenerator
::EnsureDirectoryExists(const std::string& path) const

24
Source/cmNinjaTargetGenerator.h
View File

@ -13,6 +13,8 @@
#ifndef cmNinjaTargetGenerator_h
#define cmNinjaTargetGenerator_h
#include "cmCommonTargetGenerator.h"
#include "cmStandardIncludes.h"
#include "cmNinjaTypes.h"
#include "cmLocalNinjaGenerator.h"
@ -26,7 +28,7 @@ class cmMakefile;
class cmSourceFile;
class cmCustomCommand;
class cmNinjaTargetGenerator
class cmNinjaTargetGenerator: public cmCommonTargetGenerator
{
public:
/// Create a cmNinjaTargetGenerator according to the @a target's type.
@ -65,14 +67,8 @@ protected:
cmMakefile* GetMakefile() const
{ return this->Makefile; }
std::string const& GetConfigName() const;
std::string LanguageCompilerRule(const std::string& lang) const;
const char* GetFeature(const std::string& feature);
bool GetFeatureAsBool(const std::string& feature);
void AddFeatureFlags(std::string& flags, const std::string& lang);
std::string OrderDependsTargetForTarget();
std::string ComputeOrderDependsForTarget();
@ -85,6 +81,8 @@ protected:
std::string ComputeFlagsForObject(cmSourceFile const* source,
const std::string& language);
void AddIncludeFlags(std::string& flags, std::string const& lang);
std::string ComputeDefines(cmSourceFile const* source,
const std::string& language);
@ -119,9 +117,6 @@ protected:
cmNinjaDeps GetObjects() const
{ return this->Objects; }
// Helper to add flag for windows .def file.
void AddModuleDefinitionFlag(std::string& flags);
void EnsureDirectoryExists(const std::string& dir) const;
void EnsureParentDirectoryExists(const std::string& path) const;
@ -150,19 +145,10 @@ protected:
cmNinjaVars& vars);
private:
cmTarget* Target;
cmGeneratorTarget* GeneratorTarget;
cmMakefile* Makefile;
cmLocalNinjaGenerator* LocalGenerator;
/// List of object files for this target.
cmNinjaDeps Objects;
std::vector<cmCustomCommand const*> CustomCommands;
typedef std::map<std::string, std::string> LanguageFlagMap;
LanguageFlagMap LanguageFlags;
// The windows module definition source file (.def), if any.
std::string ModuleDefinitionFile;
};
#endif // ! cmNinjaTargetGenerator_h

3
bootstrap
View File

@ -248,6 +248,7 @@ CMAKE_CXX_SOURCES="\
cmCommandArgumentLexer \
cmCommandArgumentParser \
cmCommandArgumentParserHelper \
cmCommonTargetGenerator \
cmCPackPropertiesGenerator \
cmDefinitions \
cmDepends \
@ -276,8 +277,10 @@ CMAKE_CXX_SOURCES="\
cmGeneratorExpressionNode \
cmGeneratorExpressionParser \
cmGeneratorExpression \
cmGlobalCommonGenerator \
cmGlobalGenerator \
cmInstallDirectoryGenerator \
cmLocalCommonGenerator \
cmLocalGenerator \
cmInstalledFile \
cmInstallGenerator \