405 lines
14 KiB
C++
405 lines
14 KiB
C++
/*============================================================================
|
|
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"
|
|
|
|
cmCommonTargetGenerator::cmCommonTargetGenerator(
|
|
cmOutputConverter::RelativeRoot wd, cmGeneratorTarget* gt)
|
|
: WorkingDirectory(wd)
|
|
, 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)
|
|
{
|
|
}
|
|
|
|
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) {
|
|
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->GetFullPath()));
|
|
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, cmLocalGenerator::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->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->GeneratorTarget->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->GlobalGenerator->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->GeneratorTarget->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->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->GetFrameworkFlags(l));
|
|
|
|
// Add target-specific flags.
|
|
this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, 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->GeneratorTarget->GetExportMacro()) {
|
|
this->LocalGenerator->AppendDefines(defines, exportMacro);
|
|
}
|
|
|
|
// Add preprocessor definitions for this target and configuration.
|
|
this->LocalGenerator->AddCompileDefinitions(
|
|
defines, this->GeneratorTarget, 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;
|
|
}
|
|
|
|
std::string cmCommonTargetGenerator::GetIncludes(std::string const& l)
|
|
{
|
|
ByLanguageMap::iterator i = this->IncludesByLanguage.find(l);
|
|
if (i == this->IncludesByLanguage.end()) {
|
|
std::string includes;
|
|
this->AddIncludeFlags(includes, l);
|
|
ByLanguageMap::value_type entry(l, includes);
|
|
i = this->IncludesByLanguage.insert(entry).first;
|
|
}
|
|
return i->second;
|
|
}
|
|
|
|
std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories()
|
|
const
|
|
{
|
|
std::vector<std::string> dirs;
|
|
std::set<cmGeneratorTarget const*> emitted;
|
|
if (cmComputeLinkInformation* cli =
|
|
this->GeneratorTarget->GetLinkInformation(this->ConfigName)) {
|
|
cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
|
|
for (cmComputeLinkInformation::ItemVector::const_iterator i =
|
|
items.begin();
|
|
i != items.end(); ++i) {
|
|
cmGeneratorTarget const* linkee = i->Target;
|
|
if (linkee && !linkee->IsImported()
|
|
// We can ignore the INTERFACE_LIBRARY items because
|
|
// Target->GetLinkInformation already processed their
|
|
// link interface and they don't have any output themselves.
|
|
&& linkee->GetType() != cmState::INTERFACE_LIBRARY &&
|
|
emitted.insert(linkee).second) {
|
|
cmLocalGenerator* lg = linkee->GetLocalGenerator();
|
|
std::string di = lg->GetCurrentBinaryDirectory();
|
|
di += "/";
|
|
di += lg->GetTargetDirectory(linkee);
|
|
dirs.push_back(di);
|
|
}
|
|
}
|
|
}
|
|
return dirs;
|
|
}
|
|
|
|
std::string cmCommonTargetGenerator::GetManifests()
|
|
{
|
|
std::vector<cmSourceFile const*> manifest_srcs;
|
|
this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
|
|
|
|
std::vector<std::string> manifests;
|
|
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));
|
|
}
|
|
|
|
return cmJoin(manifests, " ");
|
|
}
|
|
|
|
void cmCommonTargetGenerator::AppendOSXVerFlag(std::string& flags,
|
|
const std::string& lang,
|
|
const char* name, bool so)
|
|
{
|
|
// Lookup the flag to specify the version.
|
|
std::string fvar = "CMAKE_";
|
|
fvar += lang;
|
|
fvar += "_OSX_";
|
|
fvar += name;
|
|
fvar += "_VERSION_FLAG";
|
|
const char* flag = this->Makefile->GetDefinition(fvar);
|
|
|
|
// Skip if no such flag.
|
|
if (!flag) {
|
|
return;
|
|
}
|
|
|
|
// Lookup the target version information.
|
|
int major;
|
|
int minor;
|
|
int patch;
|
|
this->GeneratorTarget->GetTargetVersion(so, major, minor, patch);
|
|
if (major > 0 || minor > 0 || patch > 0) {
|
|
// Append the flag since a non-zero version is specified.
|
|
std::ostringstream vflag;
|
|
vflag << flag << major << "." << minor << "." << patch;
|
|
this->LocalGenerator->AppendFlags(flags, vflag.str());
|
|
}
|
|
}
|