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

Merge topic 'use-generator-target' 

d8f8940b cmGeneratorTarget: Move IsCFBundleOnApple from cmTarget.
7550879f cmGeneratorTarget: Move IsXCTestOnApple from cmTarget.
88d10d55 cmGeneratorTarget: Copy IsAppBundleOnApple from cmTarget.
b5f5de70 cmGeneratorTarget: Copy IsFrameworkOnApple from cmTarget.
8e20ea6e cmGeneratorTarget: Move IsLinkable from cmTarget.
a527abf0 Xcode: Port internal API to cmGeneratorTarget.
eb3be7d6 cmGeneratorTarget: Move GetExportName from cmTarget.
d231c31b Export: Port internal API to cmGeneratorTarget.
e6661282 Export: Port internal utility to cmGeneratorTarget.
2b9cc1e2 Export: Port some API to cmGlobalGenerator.
97062ac2 cmInstallTargetGenerator: Port GetInstallFilename to cmGeneratorTarget.
6a72b3c8 Export: Port interface to cmGeneratorTarget.
1293c156 cmExportTryCompileFileGenerator: Port to cmGeneratorTarget.
381e7afd cmExportSet: Store a cmGeneratorTarget.
65911cae cmGlobalGenerator: Compute export() related classes early.
37ab74a6 cmLocalGenerator: Port PList handling to cmGeneratorTarget.
...
This commit is contained in:
Brad King 2015-10-20 11:16:45 -04:00 committed by CMake Topic Stage
parent 5ec8064b76 d8f8940bc6
commit 9afbb733ec
53 changed files with 1233 additions and 1075 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Source/cmCommonTargetGenerator.cxx
View File

@ -109,7 +109,7 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const
{
std::string mod_dir;
const char* target_mod_dir =
this->Target->GetProperty("Fortran_MODULE_DIRECTORY");
this->GeneratorTarget->GetProperty("Fortran_MODULE_DIRECTORY");
const char* moddir_flag =
this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG");
if(target_mod_dir && moddir_flag)
@ -214,7 +214,7 @@ cmCommonTargetGenerator
this->LocalGenerator->GetFortranFormat(srcfmt);
if(format == cmLocalGenerator::FortranFormatNone)
{
const char* tgtfmt = this->Target->GetProperty("Fortran_FORMAT");
const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT");
format = this->LocalGenerator->GetFortranFormat(tgtfmt);
}
const char* var = 0;
@ -316,10 +316,11 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l)
this->AddFortranFlags(flags);
}
this->LocalGenerator->AddCMP0018Flags(flags, this->Target,
this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget,
lang, this->ConfigName);
this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target,
this->LocalGenerator->AddVisibilityPresetFlags(flags,
this->GeneratorTarget,
lang);
// Append old-style preprocessor definition flags.
@ -331,7 +332,7 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l)
AppendFlags(flags,this->GetFrameworkFlags(l));
// Add target-specific flags.
this->LocalGenerator->AddCompileOptions(flags, this->Target,
this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
lang, this->ConfigName);
ByLanguageMap::value_type entry(l, flags);
@ -354,7 +355,7 @@ std::string cmCommonTargetGenerator::GetDefines(const std::string &l)
}
// Add preprocessor definitions for this target and configuration.
this->LocalGenerator->AddCompileDefinitions(defines, this->Target,
this->LocalGenerator->AddCompileDefinitions(defines, this->GeneratorTarget,
this->LocalGenerator->GetConfigName(), l);
std::string definesString;
@ -400,8 +401,7 @@ cmCommonTargetGenerator::GetLinkedTargetDirectories() const
&& emitted.insert(linkee).second)
{
cmLocalGenerator* lg = linkee->GetLocalGenerator();
cmMakefile* mf = linkee->Target->GetMakefile();
std::string di = mf->GetCurrentBinaryDirectory();
std::string di = lg->GetCurrentBinaryDirectory();
di += "/";
di += lg->GetTargetDirectory(linkee);
dirs.push_back(di);

4
Source/cmComputeLinkInformation.cxx
View File

@ -643,7 +643,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
return;
}
if(tgt && tgt->Target->IsLinkable())
if(tgt && tgt->IsLinkable())
{
// This is a CMake target. Ask the target for its real name.
if(impexe && this->LoaderFlag)
@ -1111,7 +1111,7 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item,
// For compatibility with CMake 2.4 include the item's directory in
// the linker search path.
if(this->OldLinkDirMode && !target->Target->IsFrameworkOnApple() &&
if(this->OldLinkDirMode && !target->IsFrameworkOnApple() &&
this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
this->OldLinkDirMask.end())
{

2
Source/cmComputeTargetDepends.cxx
View File

@ -417,7 +417,7 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
const cmGeneratorTarget* dependee,
bool linking)
{
if(dependee->Target->IsImported() ||
if(dependee->IsImported() ||
dependee->GetType() == cmState::INTERFACE_LIBRARY)
{
// Skip IMPORTED and INTERFACE targets but follow their utility

7
Source/cmCoreTryCompile.cxx
View File

@ -34,7 +34,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
std::string outputVariable;
std::string copyFile;
std::string copyFileError;
std::vector<cmTarget const*> targets;
std::vector<std::string> targets;
std::string libsToLink = " ";
bool useOldLinkLibs = true;
char targetNameBuf[64];
@ -112,7 +112,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
}
if (tgt->IsImported())
{
targets.push_back(tgt);
targets.push_back(argv[i]);
}
}
}
@ -375,9 +375,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
if (!targets.empty())
{
std::string fname = "/" + std::string(targetName) + "Targets.cmake";
cmExportTryCompileFileGenerator tcfg(gg);
cmExportTryCompileFileGenerator tcfg(gg, targets, this->Makefile);
tcfg.SetExportFile((this->BinaryDirectory + fname).c_str());
tcfg.SetExports(targets);
tcfg.SetConfig(this->Makefile->GetSafeDefinition(
"CMAKE_TRY_COMPILE_CONFIGURATION"));

2
Source/cmCustomCommandGenerator.cxx
View File

@ -45,7 +45,7 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
cmGeneratorTarget* target =
this->LG->FindGeneratorTargetToUse(argv0);
if(target && target->GetType() == cmState::EXECUTABLE &&
(target->Target->IsImported()
(target->IsImported()
|| !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING")))
{
return target->GetLocation(this->Config);

58
Source/cmExportBuildFileGenerator.cxx
View File

@ -27,6 +27,10 @@ cmExportBuildFileGenerator::cmExportBuildFileGenerator()
void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
{
this->LG = lg;
if (this->ExportSet)
{
this->ExportSet->Compute(lg);
}
}
//----------------------------------------------------------------------------
@ -44,9 +48,9 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
{
cmGeneratorTarget *te = this->LG
->FindGeneratorTargetToUse(*tei);
expectedTargets += sep + this->Namespace + te->Target->GetExportName();
expectedTargets += sep + this->Namespace + te->GetExportName();
sep = " ";
if(this->ExportedTargets.insert(te->Target).second)
if(this->ExportedTargets.insert(te).second)
{
this->Exports.push_back(te);
}
@ -76,45 +80,44 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
tei != this->Exports.end(); ++tei)
{
cmGeneratorTarget* gte = *tei;
cmTarget* te = gte->Target;
this->GenerateImportTargetCode(os, te);
this->GenerateImportTargetCode(os, gte);
te->AppendBuildInterfaceIncludes();
gte->Target->AppendBuildInterfaceIncludes();
ImportPropertyMap properties;
this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", te,
this->PopulateInterfaceProperty("INTERFACE_INCLUDE_DIRECTORIES", gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_SOURCES", te,
this->PopulateInterfaceProperty("INTERFACE_SOURCES", gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", te,
this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", te,
this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", te,
this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", te,
this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
te, properties);
gte, properties);
const bool newCMP0022Behavior =
te->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& te->GetPolicyStatusCMP0022() != cmPolicies::OLD;
gte->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& gte->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
if (newCMP0022Behavior)
{
this->PopulateInterfaceLinkLibrariesProperty(te,
this->PopulateInterfaceLinkLibrariesProperty(gte,
cmGeneratorExpression::BuildInterface,
properties, missingTargets);
}
this->PopulateCompatibleInterfaceProperties(gte, properties);
this->GenerateInterfaceProperties(te, os, properties);
this->GenerateInterfaceProperties(gte, os, properties);
}
// Generate import file content for each configuration.
@ -171,7 +174,7 @@ cmExportBuildFileGenerator
// properties);
// Generate code in the export file.
this->GenerateImportPropertyCode(os, config, target->Target,
this->GenerateImportPropertyCode(os, config, target,
properties);
}
}
@ -199,7 +202,7 @@ cmExportBuildFileGenerator
std::string prop = "IMPORTED_LOCATION";
prop += suffix;
std::string value;
if(target->Target->IsAppBundleOnApple())
if(target->IsAppBundleOnApple())
{
value = target->GetFullPath(config, false);
}
@ -232,14 +235,18 @@ cmExportBuildFileGenerator
//----------------------------------------------------------------------------
void
cmExportBuildFileGenerator::HandleMissingTarget(
std::string& link_libs, std::vector<std::string>& missingTargets,
cmMakefile* mf, cmTarget* depender, cmTarget* dependee)
std::string& link_libs,
std::vector<std::string>& missingTargets,
cmGeneratorTarget* depender,
cmGeneratorTarget* dependee)
{
// The target is not in the export.
if(!this->AppendMode)
{
const std::string name = dependee->GetName();
std::vector<std::string> namespaces = this->FindNamespaces(mf, name);
cmGlobalGenerator* gg =
dependee->GetLocalGenerator()->GetGlobalGenerator();
std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
int targetOccurrences = (int)namespaces.size();
if (targetOccurrences == 1)
@ -274,7 +281,7 @@ void cmExportBuildFileGenerator
tei = this->ExportSet->GetTargetExports()->begin();
tei != this->ExportSet->GetTargetExports()->end(); ++tei)
{
targets.push_back((*tei)->Target->GetName());
targets.push_back((*tei)->TargetName);
}
return;
}
@ -284,10 +291,9 @@ void cmExportBuildFileGenerator
//----------------------------------------------------------------------------
std::vector<std::string>
cmExportBuildFileGenerator
::FindNamespaces(cmMakefile* mf, const std::string& name)
::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
{
std::vector<std::string> namespaces;
cmGlobalGenerator* gg = mf->GetGlobalGenerator();
std::map<std::string, cmExportBuildFileGenerator*>& exportSets
= gg->GetBuildExportSets();
@ -310,8 +316,8 @@ cmExportBuildFileGenerator
//----------------------------------------------------------------------------
void
cmExportBuildFileGenerator
::ComplainAboutMissingTarget(cmTarget* depender,
cmTarget* dependee,
::ComplainAboutMissingTarget(cmGeneratorTarget* depender,
cmGeneratorTarget* dependee,
int occurrences)
{
if(cmSystemTools::GetErrorOccuredFlag())

11
Source/cmExportBuildFileGenerator.h
View File

@ -54,12 +54,11 @@ protected:
std::vector<std::string> &missingTargets);
virtual void HandleMissingTarget(std::string& link_libs,
std::vector<std::string>& missingTargets,
cmMakefile* mf,
cmTarget* depender,
cmTarget* dependee);
cmGeneratorTarget* depender,
cmGeneratorTarget* dependee);
void ComplainAboutMissingTarget(cmTarget* depender,
cmTarget* dependee,
void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
cmGeneratorTarget* dependee,
int occurrences);
/** Fill in properties indicating built file locations. */
@ -72,7 +71,7 @@ protected:
const std::string& config);
std::vector<std::string>
FindNamespaces(cmMakefile* mf, const std::string& name);
FindNamespaces(cmGlobalGenerator* gg, const std::string& name);
std::vector<std::string> Targets;
cmExportSet *ExportSet;

69
Source/cmExportFileGenerator.cxx
View File

@ -18,7 +18,6 @@
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmTargetExport.h"
#include "cmVersion.h"
#include "cmComputeLinkInformation.h"
@ -155,7 +154,7 @@ void cmExportFileGenerator::GenerateImportConfig(std::ostream& os,
//----------------------------------------------------------------------------
void cmExportFileGenerator::PopulateInterfaceProperty(
const std::string& propName,
cmTarget *target,
cmGeneratorTarget *target,
ImportPropertyMap &properties)
{
const char *input = target->GetProperty(propName);
@ -169,7 +168,7 @@ void cmExportFileGenerator::PopulateInterfaceProperty(
void cmExportFileGenerator::PopulateInterfaceProperty(
const std::string& propName,
const std::string& outputName,
cmTarget *target,
cmGeneratorTarget *target,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
@ -206,7 +205,7 @@ void cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream& os,
//----------------------------------------------------------------------------
bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
cmTarget *target,
cmGeneratorTarget *target,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
@ -398,11 +397,11 @@ void cmExportFileGenerator::PopulateSourcesInterface(
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
{
cmTarget *target = tei->Target;
cmGeneratorTarget* gt = tei->Target;
assert(preprocessRule == cmGeneratorExpression::InstallInterface);
const char *propName = "INTERFACE_SOURCES";
const char *input = target->GetProperty(propName);
const char *input = gt->GetProperty(propName);
if (!input)
{
@ -420,11 +419,9 @@ void cmExportFileGenerator::PopulateSourcesInterface(
true);
if (!prepro.empty())
{
this->ResolveTargetsInGeneratorExpressions(prepro, target,
this->ResolveTargetsInGeneratorExpressions(prepro, gt,
missingTargets);
cmGeneratorTarget* gt = target->GetMakefile()
->GetGlobalGenerator()->GetGeneratorTarget(target);
if (!checkInterfaceDirs(prepro, gt, propName))
{
return;
@ -440,9 +437,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
{
cmGeneratorTarget *target = tei->Target->GetMakefile()
->GetGlobalGenerator()
->GetGeneratorTarget(tei->Target);
cmGeneratorTarget *target = tei->Target;
assert(preprocessRule == cmGeneratorExpression::InstallInterface);
const char *propName = "INTERFACE_INCLUDE_DIRECTORIES";
@ -492,7 +487,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
true);
if (!prepro.empty())
{
this->ResolveTargetsInGeneratorExpressions(prepro, target->Target,
this->ResolveTargetsInGeneratorExpressions(prepro, target,
missingTargets);
if (!checkInterfaceDirs(prepro, target, propName))
@ -506,7 +501,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
//----------------------------------------------------------------------------
void cmExportFileGenerator::PopulateInterfaceProperty(
const std::string& propName,
cmTarget *target,
cmGeneratorTarget* target,
cmGeneratorExpression::PreprocessContext preprocessRule,
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
@ -578,15 +573,14 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
cmGeneratorTarget *gtarget,
ImportPropertyMap &properties)
{
cmTarget *target = gtarget->Target;
this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL",
target, properties);
gtarget, properties);
this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING",
target, properties);
gtarget, properties);
this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MIN",
target, properties);
gtarget, properties);
this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MAX",
target, properties);
gtarget, properties);
std::set<std::string> ifaceProperties;
@ -597,12 +591,12 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MAX",
ifaceProperties);
if (target->GetType() != cmState::INTERFACE_LIBRARY)
if (gtarget->GetType() != cmState::INTERFACE_LIBRARY)
{
getCompatibleInterfaceProperties(gtarget, ifaceProperties, "");
std::vector<std::string> configNames;
target->GetMakefile()->GetConfigurations(configNames);
gtarget->Target->GetMakefile()->GetConfigurations(configNames);
for (std::vector<std::string>::const_iterator ci = configNames.begin();
ci != configNames.end(); ++ci)
@ -615,12 +609,13 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
it != ifaceProperties.end(); ++it)
{
this->PopulateInterfaceProperty("INTERFACE_" + *it,
target, properties);
gtarget, properties);
}
}
//----------------------------------------------------------------------------
void cmExportFileGenerator::GenerateInterfaceProperties(cmTarget const* target,
void cmExportFileGenerator::GenerateInterfaceProperties(
const cmGeneratorTarget* target,
std::ostream& os,
const ImportPropertyMap &properties)
{
@ -642,12 +637,12 @@ void cmExportFileGenerator::GenerateInterfaceProperties(cmTarget const* target,
//----------------------------------------------------------------------------
bool
cmExportFileGenerator::AddTargetNamespace(std::string &input,
cmTarget* target,
cmGeneratorTarget* target,
std::vector<std::string> &missingTargets)
{
cmMakefile *mf = target->GetMakefile();
cmLocalGenerator *lg = target->GetLocalGenerator();
cmTarget *tgt = mf->FindTargetToUse(input);
cmGeneratorTarget *tgt = lg->FindGeneratorTargetToUse(input);
if (!tgt)
{
return false;
@ -665,7 +660,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input,
{
std::string namespacedTarget;
this->HandleMissingTarget(namespacedTarget, missingTargets,
mf, target, tgt);
target, tgt);
if (!namespacedTarget.empty())
{
input = namespacedTarget;
@ -678,7 +673,7 @@ cmExportFileGenerator::AddTargetNamespace(std::string &input,
void
cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
std::string &input,
cmTarget* target,
cmGeneratorTarget* target,
std::vector<std::string> &missingTargets,
FreeTargetsReplace replace)
{
@ -715,14 +710,12 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
void
cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
std::string &input,
cmTarget* target,
cmGeneratorTarget* target,
std::vector<std::string> &missingTargets)
{
std::string::size_type pos = 0;
std::string::size_type lastPos = pos;
cmMakefile *mf = target->GetMakefile();
while((pos = input.find("$<TARGET_PROPERTY:", lastPos)) != input.npos)
{
std::string::size_type nameStartPos = pos +
@ -783,7 +776,7 @@ cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
if (!errorString.empty())
{
mf->IssueMessage(cmake::FATAL_ERROR, errorString);
target->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, errorString);
}
}
@ -864,7 +857,7 @@ cmExportFileGenerator
preprocessRule);
if (!prepro.empty())
{
this->ResolveTargetsInGeneratorExpressions(prepro, target->Target,
this->ResolveTargetsInGeneratorExpressions(prepro, target,
missingTargets,
ReplaceFreeTargets);
properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix] = prepro;
@ -966,7 +959,7 @@ cmExportFileGenerator
sep = ";";
std::string temp = *li;
this->AddTargetNamespace(temp, target->Target, missingTargets);
this->AddTargetNamespace(temp, target, missingTargets);
link_entries += temp;
}
@ -1048,7 +1041,7 @@ void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os,
//----------------------------------------------------------------------------
void
cmExportFileGenerator
::GenerateImportTargetCode(std::ostream& os, cmTarget const* target)
::GenerateImportTargetCode(std::ostream& os, const cmGeneratorTarget* target)
{
// Construct the imported target name.
std::string targetName = this->Namespace;
@ -1082,7 +1075,7 @@ cmExportFileGenerator
}
// Mark the imported executable if it has exports.
if(target->IsExecutableWithExports())
if(target->Target->IsExecutableWithExports())
{
os << "set_property(TARGET " << targetName
<< " PROPERTY ENABLE_EXPORTS 1)\n";
@ -1114,7 +1107,7 @@ cmExportFileGenerator
void
cmExportFileGenerator
::GenerateImportPropertyCode(std::ostream& os, const std::string& config,
cmTarget const* target,
cmGeneratorTarget const* target,
ImportPropertyMap const& properties)
{
// Construct the imported target name.
@ -1234,7 +1227,7 @@ cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
//----------------------------------------------------------------------------
void
cmExportFileGenerator
::GenerateImportedFileChecksCode(std::ostream& os, cmTarget* target,
::GenerateImportedFileChecksCode(std::ostream& os, cmGeneratorTarget* target,
ImportPropertyMap const& properties,
const std::set<std::string>& importedLocations)
{

33
Source/cmExportFileGenerator.h
View File

@ -75,11 +75,13 @@ protected:
const std::string& config = "");
void GenerateImportFooterCode(std::ostream& os);
void GenerateImportVersionCode(std::ostream& os);
void GenerateImportTargetCode(std::ostream& os, cmTarget const* target);
void GenerateImportTargetCode(std::ostream& os,
cmGeneratorTarget const* target);
void GenerateImportPropertyCode(std::ostream& os, const std::string& config,
cmTarget const* target,
cmGeneratorTarget const* target,
ImportPropertyMap const& properties);
void GenerateImportedFileChecksCode(std::ostream& os, cmTarget* target,
void GenerateImportedFileChecksCode(std::ostream& os,
cmGeneratorTarget* target,
ImportPropertyMap const& properties,
const std::set<std::string>& importedLocations);
void GenerateImportedFileCheckLoop(std::ostream& os);
@ -118,23 +120,24 @@ protected:
* export set. */
virtual void HandleMissingTarget(std::string& link_libs,
std::vector<std::string>& missingTargets,
cmMakefile* mf,
cmTarget* depender,
cmTarget* dependee) = 0;
cmGeneratorTarget* depender,
cmGeneratorTarget* dependee) = 0;
void PopulateInterfaceProperty(const std::string&,
cmTarget *target,
cmGeneratorTarget *target,
cmGeneratorExpression::PreprocessContext,
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets);
bool PopulateInterfaceLinkLibrariesProperty(cmTarget *target,
bool PopulateInterfaceLinkLibrariesProperty(cmGeneratorTarget* target,
cmGeneratorExpression::PreprocessContext,
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets);
void PopulateInterfaceProperty(const std::string& propName, cmTarget *target,
void PopulateInterfaceProperty(const std::string& propName,
cmGeneratorTarget* target,
ImportPropertyMap &properties);
void PopulateCompatibleInterfaceProperties(cmGeneratorTarget *target,
ImportPropertyMap &properties);
void GenerateInterfaceProperties(cmTarget const* target, std::ostream& os,
void GenerateInterfaceProperties(cmGeneratorTarget const* target,
std::ostream& os,
const ImportPropertyMap &properties);
void PopulateIncludeDirectoriesInterface(
cmTargetExport *target,
@ -159,7 +162,7 @@ protected:
};
void ResolveTargetsInGeneratorExpressions(std::string &input,
cmTarget* target,
cmGeneratorTarget* target,
std::vector<std::string> &missingTargets,
FreeTargetsReplace replace = NoReplaceFreeTargets);
@ -182,20 +185,20 @@ protected:
bool AppendMode;
// The set of targets included in the export.
std::set<cmTarget*> ExportedTargets;
std::set<cmGeneratorTarget*> ExportedTargets;
private:
void PopulateInterfaceProperty(const std::string&, const std::string&,
cmTarget *target,
cmGeneratorTarget* target,
cmGeneratorExpression::PreprocessContext,
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets);
bool AddTargetNamespace(std::string &input, cmTarget* target,
bool AddTargetNamespace(std::string &input, cmGeneratorTarget* target,
std::vector<std::string> &missingTargets);
void ResolveTargetsInGeneratorExpression(std::string &input,
cmTarget* target,
cmGeneratorTarget* target,
std::vector<std::string> &missingTargets);
virtual void ReplaceInstallPrefix(std::string &input);

63
Source/cmExportInstallFileGenerator.cxx
View File

@ -48,7 +48,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
{
expectedTargets += sep + this->Namespace + (*tei)->Target->GetExportName();
expectedTargets +=
sep + this->Namespace + (*tei)->Target->GetExportName();
sep = " ";
cmTargetExport * te = *tei;
if(this->ExportedTargets.insert(te->Target).second)
@ -131,12 +132,12 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
tei = allTargets.begin();
tei != allTargets.end(); ++tei)
{
cmTarget* te = (*tei)->Target;
cmGeneratorTarget* gt = (*tei)->Target;
requiresConfigFiles = requiresConfigFiles
|| te->GetType() != cmState::INTERFACE_LIBRARY;
|| gt->GetType() != cmState::INTERFACE_LIBRARY;
this->GenerateImportTargetCode(os, te);
this->GenerateImportTargetCode(os, gt);
ImportPropertyMap properties;
@ -147,32 +148,32 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
cmGeneratorExpression::InstallInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
te,
gt,
cmGeneratorExpression::InstallInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS",
te,
gt,
cmGeneratorExpression::InstallInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS",
te,
gt,
cmGeneratorExpression::InstallInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS",
te,
gt,
cmGeneratorExpression::InstallInterface,
properties, missingTargets);
this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES",
te,
gt,
cmGeneratorExpression::InstallInterface,
properties, missingTargets);
const bool newCMP0022Behavior =
te->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& te->GetPolicyStatusCMP0022() != cmPolicies::OLD;
gt->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& gt->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
if (newCMP0022Behavior)
{
if (this->PopulateInterfaceLinkLibrariesProperty(te,
if (this->PopulateInterfaceLinkLibrariesProperty(gt,
cmGeneratorExpression::InstallInterface,
properties, missingTargets)
&& !this->ExportOld)
@ -180,11 +181,11 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
require2_8_12 = true;
}
}
if (te->GetType() == cmState::INTERFACE_LIBRARY)
if (gt->GetType() == cmState::INTERFACE_LIBRARY)
{
require3_0_0 = true;
}
if(te->GetProperty("INTERFACE_SOURCES"))
if(gt->GetProperty("INTERFACE_SOURCES"))
{
// We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1
// can consume them.
@ -192,14 +193,11 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
}
this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
te, properties);
cmGeneratorTarget *gtgt = te->GetMakefile()
->GetGlobalGenerator()
->GetGeneratorTarget(te);
gt, properties);
this->PopulateCompatibleInterfaceProperties(gtgt, properties);
this->PopulateCompatibleInterfaceProperties(gt, properties);
this->GenerateInterfaceProperties(te, os, properties);
this->GenerateInterfaceProperties(gt, os, properties);
}
if (require3_1_0)
@ -362,8 +360,7 @@ cmExportInstallFileGenerator
if(!properties.empty())
{
// Get the rest of the target details.
cmGeneratorTarget *gtgt = te->Target->GetMakefile()
->GetGlobalGenerator()->GetGeneratorTarget(te->Target);
cmGeneratorTarget *gtgt = te->Target;
this->SetImportDetailProperties(config, suffix,
gtgt, properties, missingTargets);
@ -378,8 +375,8 @@ cmExportInstallFileGenerator
// properties);
// Generate code in the export file.
this->GenerateImportPropertyCode(os, config, te->Target, properties);
this->GenerateImportedFileChecksCode(os, te->Target, properties,
this->GenerateImportPropertyCode(os, config, gtgt, properties);
this->GenerateImportedFileChecksCode(os, gtgt, properties,
importedLocations);
}
}
@ -402,7 +399,7 @@ cmExportInstallFileGenerator
}
// Get the target to be installed.
cmTarget* target = itgen->GetTarget()->Target;
cmGeneratorTarget* target = itgen->GetTarget();
// Construct the installed location of the target.
std::string dest = itgen->GetDestination(config);
@ -456,12 +453,13 @@ cmExportInstallFileGenerator
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator::HandleMissingTarget(
std::string& link_libs, std::vector<std::string>& missingTargets,
cmMakefile* mf, cmTarget* depender, cmTarget* dependee)
cmExportInstallFileGenerator::HandleMissingTarget(std::string& link_libs,
std::vector<std::string>& missingTargets,
cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
{
const std::string name = dependee->GetName();
std::vector<std::string> namespaces = this->FindNamespaces(mf, name);
cmGlobalGenerator* gg = dependee->GetLocalGenerator()->GetGlobalGenerator();
std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
int targetOccurrences = (int)namespaces.size();
if (targetOccurrences == 1)
{
@ -482,10 +480,9 @@ cmExportInstallFileGenerator::HandleMissingTarget(
//----------------------------------------------------------------------------
std::vector<std::string>
cmExportInstallFileGenerator
::FindNamespaces(cmMakefile* mf, const std::string& name)
::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
{
std::vector<std::string> namespaces;
cmGlobalGenerator* gg = mf->GetGlobalGenerator();
const cmExportSetMap& exportSets = gg->GetExportSets();
for(cmExportSetMap::const_iterator expIt = exportSets.begin();
@ -523,8 +520,8 @@ cmExportInstallFileGenerator
//----------------------------------------------------------------------------
void
cmExportInstallFileGenerator
::ComplainAboutMissingTarget(cmTarget* depender,
cmTarget* dependee,
::ComplainAboutMissingTarget(cmGeneratorTarget* depender,
cmGeneratorTarget* dependee,
int occurrences)
{
std::ostringstream e;

11
Source/cmExportInstallFileGenerator.h
View File

@ -57,17 +57,16 @@ protected:
std::vector<std::string> &missingTargets);
virtual void HandleMissingTarget(std::string& link_libs,
std::vector<std::string>& missingTargets,
cmMakefile* mf,
cmTarget* depender,
cmTarget* dependee);
cmGeneratorTarget* depender,
cmGeneratorTarget* dependee);
virtual void ReplaceInstallPrefix(std::string &input);
void ComplainAboutMissingTarget(cmTarget* depender,
cmTarget* dependee,
void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
cmGeneratorTarget* dependee,
int occurrences);
std::vector<std::string> FindNamespaces(cmMakefile* mf,
std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
const std::string& name);

10
Source/cmExportSet.cxx
View File

@ -13,12 +13,22 @@
#include "cmExportSet.h"
#include "cmTargetExport.h"
#include "cmAlgorithms.h"
#include "cmLocalGenerator.h"
cmExportSet::~cmExportSet()
{
cmDeleteAll(this->TargetExports);
}
void cmExportSet::Compute(cmLocalGenerator* lg)
{
for (std::vector<cmTargetExport*>::iterator it = this->TargetExports.begin();
it != this->TargetExports.end(); ++it)
{
(*it)->Target = lg->FindGeneratorTargetToUse((*it)->TargetName);
}
}
void cmExportSet::AddTargetExport(cmTargetExport* te)
{
this->TargetExports.push_back(te);

3
Source/cmExportSet.h
View File

@ -15,6 +15,7 @@
#include "cmSystemTools.h"
class cmTargetExport;
class cmInstallExportGenerator;
class cmLocalGenerator;
/// A set of targets that were installed with the same EXPORT parameter.
class cmExportSet
@ -25,6 +26,8 @@ public:
/// Destructor
~cmExportSet();
void Compute(cmLocalGenerator* lg);
void AddTargetExport(cmTargetExport* tgt);
void AddInstallation(cmInstallExportGenerator const* installation);

45
Source/cmExportTryCompileFileGenerator.cxx
View File

@ -14,22 +14,25 @@
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmGeneratorExpressionDAGChecker.h"
//----------------------------------------------------------------------------
cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator(
cmGlobalGenerator* gg)
cmGlobalGenerator* gg,
const std::vector<std::string>& targets,
cmMakefile* mf)
{
gg->CreateGenerationObjects(cmGlobalGenerator::ImportedOnly);
gg->CreateImportedGenerationObjects(mf, targets, this->Exports);
}
bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os)
{
std::set<cmTarget const*> emitted;
std::set<cmTarget const*> emittedDeps;
std::set<cmGeneratorTarget const*> emitted;
std::set<cmGeneratorTarget const*> emittedDeps;
while(!this->Exports.empty())
{
cmTarget const* te = this->Exports.back();
cmGeneratorTarget const* te = this->Exports.back();
this->Exports.pop_back();
if (emitted.insert(te).second)
{
@ -54,9 +57,9 @@ bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os)
}
std::string cmExportTryCompileFileGenerator::FindTargets(
const std::string& propName,
cmTarget const* tgt,
std::set<cmTarget const*> &emitted)
const std::string& propName,
cmGeneratorTarget const* tgt,
std::set<cmGeneratorTarget const*> &emitted)
{
const char *prop = tgt->GetProperty(propName);
if(!prop)
@ -74,24 +77,22 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
cmTarget dummyHead;
dummyHead.SetType(cmState::EXECUTABLE, "try_compile_dummy_exe");
dummyHead.SetMakefile(tgt->GetMakefile());
dummyHead.SetMakefile(tgt->Target->GetMakefile());
cmGeneratorTarget* gtgt =
tgt->GetMakefile()->GetGlobalGenerator()->GetGeneratorTarget(tgt);
cmGeneratorTarget gDummyHead(&dummyHead, gtgt->GetLocalGenerator());
cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator());
std::string result = cge->Evaluate(gtgt->GetLocalGenerator(), this->Config,
std::string result = cge->Evaluate(tgt->GetLocalGenerator(), this->Config,
false, &gDummyHead,
gtgt, &dagChecker);
tgt, &dagChecker);
const std::set<cmGeneratorTarget const*> &allTargets =
cge->GetAllTargetsSeen();
for(std::set<cmGeneratorTarget const*>::const_iterator li =
allTargets.begin(); li != allTargets.end(); ++li)
{
if(emitted.insert((*li)->Target).second)
if(emitted.insert(*li).second)
{
this->Exports.push_back((*li)->Target);
this->Exports.push_back(*li);
}
}
return result;
@ -99,11 +100,12 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
//----------------------------------------------------------------------------
void
cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target,
ImportPropertyMap& properties,
std::set<cmTarget const*> &emitted)
cmExportTryCompileFileGenerator::PopulateProperties(
const cmGeneratorTarget* target,
ImportPropertyMap& properties,
std::set<cmGeneratorTarget const*> &emitted)
{
cmPropertyMap props = target->GetProperties();
cmPropertyMap props = target->Target->GetProperties();
for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i)
{
properties[i->first] = i->second.GetValue();
@ -120,7 +122,8 @@ cmExportTryCompileFileGenerator::PopulateProperties(cmTarget const* target,
for(std::vector<std::string>::const_iterator li = depends.begin();
li != depends.end(); ++li)
{
cmTarget *tgt = target->GetMakefile()->FindTargetToUse(*li);
cmGeneratorTarget *tgt =
target->GetLocalGenerator()->FindGeneratorTargetToUse(*li);
if(tgt && emitted.insert(tgt).second)
{
this->Exports.push_back(tgt);

22
Source/cmExportTryCompileFileGenerator.h
View File

@ -20,11 +20,11 @@ class cmInstallTargetGenerator;
class cmExportTryCompileFileGenerator: public cmExportFileGenerator
{
public:
cmExportTryCompileFileGenerator(cmGlobalGenerator* gg);
cmExportTryCompileFileGenerator(cmGlobalGenerator* gg,
std::vector<std::string> const& targets,
cmMakefile* mf);
/** Set the list of targets to export. */
void SetExports(const std::vector<cmTarget const*> &exports)
{ this->Exports = exports; }
void SetConfig(const std::string& config) { this->Config = config; }
protected:
@ -37,22 +37,22 @@ protected:
std::vector<std::string>&) {}
virtual void HandleMissingTarget(std::string&,
std::vector<std::string>&,
cmMakefile*,
cmTarget*,
cmTarget*) {}
cmGeneratorTarget*,
cmGeneratorTarget*) {}
void PopulateProperties(cmTarget const* target,
void PopulateProperties(cmGeneratorTarget const* target,
ImportPropertyMap& properties,
std::set<cmTarget const*> &emitted);
std::set<const cmGeneratorTarget*>& emitted);
std::string InstallNameDir(cmGeneratorTarget* target,
const std::string& config);
private:
std::string FindTargets(const std::string& prop, cmTarget const* tgt,
std::set<cmTarget const*> &emitted);
std::string FindTargets(const std::string& prop,
const cmGeneratorTarget* tgt,
std::set<const cmGeneratorTarget*>& emitted);
std::vector<cmTarget const*> Exports;
std::vector<cmGeneratorTarget const*> Exports;
std::string Config;
};

6
Source/cmExtraSublimeTextGenerator.cxx
View File

@ -388,7 +388,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
// }
// Add shared-library flags if needed.
lg->AddCMP0018Flags(flags, gtgt->Target, language, config);
lg->AddCMP0018Flags(flags, gtgt, language, config);
// Add include directory flags.
{
@ -403,7 +403,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
lg->AppendFlags(flags, makefile->GetDefineFlags());
// Add target-specific flags.
lg->AddCompileOptions(flags, gtgt->Target, language, config);
lg->AddCompileOptions(flags, gtgt, language, config);
// Add source file specific flags.
lg->AppendFlags(flags, source->GetProperty("COMPILE_FLAGS"));
@ -433,7 +433,7 @@ ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg,
}
// Add preprocessor definitions for this target and configuration.
lg->AddCompileDefinitions(defines, target->Target, config, language);
lg->AddCompileDefinitions(defines, target, config, language);
lg->AppendDefines(defines, source->GetProperty("COMPILE_DEFINITIONS"));
{
std::string defPropName = "COMPILE_DEFINITIONS_";

6
Source/cmGeneratorExpressionNode.cxx
View File

@ -1497,11 +1497,11 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode
const char *policy = targetPolicyWhitelist[i];
if (parameters.front() == policy)
{
cmMakefile *mf = context->HeadTarget->Target->GetMakefile();
cmLocalGenerator* lg = context->HeadTarget->GetLocalGenerator();
switch(statusForTarget(context->HeadTarget, policy))
{
case cmPolicies::WARN:
mf->IssueMessage(cmake::AUTHOR_WARNING,
lg->IssueMessage(cmake::AUTHOR_WARNING,
cmPolicies::GetPolicyWarning(policyForString(policy)));
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
@ -1654,7 +1654,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag>
const GeneratorExpressionContent *content)
{
// The file used to link to the target (.so, .lib, .a).
if(!target->Target->IsLinkable())
if(!target->IsLinkable())
{
::reportError(context, content->GetOriginalExpression(),
"TARGET_LINKER_FILE is allowed only for libraries and "

630
Source/cmGeneratorTarget.cxx
View File

File diff suppressed because it is too large Load Diff

69
Source/cmGeneratorTarget.h
View File

@ -43,6 +43,8 @@ public:
cmState::TargetType GetType() const;
std::string GetName() const;
std::string GetExportName() const;
const char *GetProperty(const std::string& prop) const;
bool GetPropertyAsBool(const std::string& prop) const;
void GetSourceFiles(std::vector<cmSourceFile*>& files,
@ -226,6 +228,12 @@ public:
void GetLanguages(std::set<std::string>& languages,
std::string const& config) const;
void
GetObjectLibrariesCMP0026(std::vector<cmGeneratorTarget*>& objlibs) const;
std::string GetFullNameImported(const std::string& config,
bool implib) const;
bool GetConfigCommonSourceFiles(std::vector<cmSourceFile*>& files) const;
bool HaveBuildTreeRPATH(const std::string& config) const;
@ -404,6 +412,22 @@ public:
/** Get a build-tree directory in which to place target support files. */
std::string GetSupportDirectory() const;
/** Return whether this target may be used to link another target. */
bool IsLinkable() const;
/** Return whether this target is a shared library Framework on
Apple. */
bool IsFrameworkOnApple() const;
/** Return whether this target is an executable Bundle on Apple. */
bool IsAppBundleOnApple() const;
/** Return whether this target is a XCTest on Apple. */
bool IsXCTestOnApple() const;
/** Return whether this target is a CFBundle (plugin) on Apple. */
bool IsCFBundleOnApple() const;
struct SourceFileFlags
GetTargetSourceFileFlags(const cmSourceFile* sf) const;
@ -437,6 +461,19 @@ public:
no soname at all. */
bool IsImportedSharedLibWithoutSOName(const std::string& config) const;
const char* ImportedGetLocation(const std::string& config) const;
/** Get the target major and minor version numbers interpreted from
the VERSION property. Version 0 is returned if the property is
not set or cannot be parsed. */
void GetTargetVersion(int& major, int& minor) const;
/** Get the target major, minor, and patch version numbers
interpreted from the VERSION or SOVERSION property. Version 0
is returned if the property is not set or cannot be parsed. */
void
GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const;
private:
friend class cmTargetTraceDependencies;
struct SourceEntry { std::vector<cmSourceFile*> Depends; };
@ -464,6 +501,13 @@ private:
// Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type.
const char* GetOutputTargetType(bool implib) const;
void ComputeVersionedName(std::string& vName,
std::string const& prefix,
std::string const& base,
std::string const& suffix,
std::string const& name,
const char* version) const;
struct CompatibleInterfacesBase
{
std::set<std::string> PropsBool;
@ -508,6 +552,31 @@ private:
cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceUsageRequirementsMap(
std::string const& config) const;
// Cache import information from properties for each configuration.
struct ImportInfo
{
ImportInfo(): NoSOName(false), Multiplicity(0) {}
bool NoSOName;
int Multiplicity;
std::string Location;
std::string SOName;
std::string ImportLibrary;
std::string Languages;
std::string Libraries;
std::string LibrariesProp;
std::string SharedDeps;
};
typedef std::map<std::string, ImportInfo> ImportInfoMapType;
mutable ImportInfoMapType ImportInfoMap;
void ComputeImportInfo(std::string const& desired_config,
ImportInfo& info) const;
ImportInfo const* GetImportInfo(const std::string& config) const;
/** Strip off leading and trailing whitespace from an item named in
the link dependencies of this target. */
std::string CheckCMP0004(std::string const& item) const;
cmLinkInterface const*
GetImportLinkInterface(const std::string& config,
const cmGeneratorTarget* head,

13
Source/cmGhsMultiTargetGenerator.cxx
View File

@ -265,8 +265,11 @@ void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config,
this->LocalGenerator->AddLanguageFlags(
flags, lang + std::string("_GHS_KERNEL"), config);
}
this->LocalGenerator->AddCMP0018Flags(flags, this->Target, lang, config);
this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target, lang);
this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget,
lang, config);
this->LocalGenerator->AddVisibilityPresetFlags(flags,
this->GeneratorTarget,
lang);
// Append old-style preprocessor definition flags.
if (std::string(" ") != std::string(this->Makefile->GetDefineFlags()))
@ -276,7 +279,8 @@ void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config,
}
// Add target-specific flags.
this->LocalGenerator->AddCompileOptions(flags, this->Target, lang, config);
this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
lang, config);
std::map<std::string, std::string>::value_type entry(language, flags);
i = this->FlagsByLanguage.insert(entry).first;
@ -299,7 +303,8 @@ std::string cmGhsMultiTargetGenerator::GetDefines(const std::string &language,
}
// Add preprocessor definitions for this target and configuration.
this->LocalGenerator->AddCompileDefinitions(defines, this->Target, config,
this->LocalGenerator->AddCompileDefinitions(defines,
this->GeneratorTarget, config,
language);
std::string definesString;

26
Source/cmGlobalGenerator.cxx
View File

@ -1199,6 +1199,27 @@ void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes)
cmDeleteAll(this->GeneratorTargets);
this->GeneratorTargets.clear();
this->CreateGeneratorTargets(targetTypes);
this->ComputeBuildFileGenerators();
}
void cmGlobalGenerator::CreateImportedGenerationObjects(cmMakefile* mf,
const std::vector<std::string>& targets,
std::vector<const cmGeneratorTarget*>& exports)
{
this->CreateGenerationObjects(ImportedOnly);
std::vector<cmMakefile*>::iterator mfit =
std::find(this->Makefiles.begin(), this->Makefiles.end(), mf);
cmLocalGenerator* lg =
this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)];
for (std::vector<std::string>::const_iterator it = targets.begin();
it != targets.end(); ++it)
{
cmGeneratorTarget* gt = lg->FindGeneratorTargetToUse(*it);
if (gt)
{
exports.push_back(gt);
}
}
}
cmExportBuildFileGenerator*
@ -1279,8 +1300,6 @@ bool cmGlobalGenerator::Compute()
this->CreateQtAutoGeneratorsTargets();
#endif
this->ComputeBuildFileGenerators();
unsigned int i;
// Add generator specific helper commands
@ -2189,7 +2208,8 @@ cmGlobalGenerator::NameResolvesToFramework(const std::string& libname) const
if(cmTarget* tgt = this->FindTarget(libname))
{
if(tgt->IsFrameworkOnApple())
cmGeneratorTarget* gt = this->GetGeneratorTarget(tgt);
if(gt->IsFrameworkOnApple())
{
return true;
}

7
Source/cmGlobalGenerator.h
View File

@ -91,6 +91,9 @@ public:
ImportedOnly
};
void CreateImportedGenerationObjects(cmMakefile* mf,
std::vector<std::string> const& targets,
std::vector<cmGeneratorTarget const*>& exports);
void CreateGenerationObjects(TargetTypes targetTypes = AllTargets);
/**
@ -365,8 +368,6 @@ public:
bool GetConfigureDoneCMP0026() const
{ return this->ConfigureDoneCMP0026AndCMP0024; }
void ComputeBuildFileGenerators();
std::string MakeSilentFlag;
protected:
typedef std::vector<cmLocalGenerator*> GeneratorVector;
@ -471,6 +472,8 @@ private:
void CheckCompilerIdCompatibility(cmMakefile* mf,
std::string const& lang) const;
void ComputeBuildFileGenerators();
cmExternalMakefileProjectGenerator* ExtraGenerator;
// track files replaced during a Generate

5
Source/cmGlobalNinjaGenerator.cxx
View File

@ -917,11 +917,13 @@ cmGlobalNinjaGenerator
std::string configName =
target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
cmGeneratorTarget *gtgt = this->GetGeneratorTarget(target);
// for frameworks, we want the real name, not smple name
// frameworks always appear versioned, and the build.ninja
// will always attempt to manage symbolic links instead
// of letting cmOSXBundleGenerator do it.
bool realname = target->IsFrameworkOnApple();
bool realname = gtgt->IsFrameworkOnApple();
switch (target->GetType()) {
case cmState::EXECUTABLE:
@ -929,7 +931,6 @@ cmGlobalNinjaGenerator
case cmState::STATIC_LIBRARY:
case cmState::MODULE_LIBRARY:
{
cmGeneratorTarget *gtgt = this->GetGeneratorTarget(target);
outputs.push_back(this->ConvertToNinjaPath(
gtgt->GetFullPath(configName, false, realname)));
break;

6
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -473,7 +473,7 @@ cmGlobalUnixMakefileGenerator3
(type == cmState::OBJECT_LIBRARY) ||
(type == cmState::UTILITY))
{
if(gtarget->Target->IsImported())
if(gtarget->IsImported())
{
continue;
}
@ -632,7 +632,7 @@ cmGlobalUnixMakefileGenerator3
t != targets.end(); ++t)
{
cmGeneratorTarget* gtarget = t->second;
if(gtarget->Target->IsImported())
if(gtarget->IsImported())
{
continue;
}
@ -733,7 +733,7 @@ cmGlobalUnixMakefileGenerator3
t != targets.end(); ++t)
{
cmGeneratorTarget* gtarget = t->second;
if(gtarget->Target->IsImported())
if(gtarget->IsImported())
{
continue;
}

5
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -385,7 +385,7 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends()
}
//----------------------------------------------------------------------------
static bool VSLinkable(cmTarget const* t)
static bool VSLinkable(cmGeneratorTarget const* t)
{
return t->IsLinkable() || t->GetType() == cmState::OBJECT_LIBRARY;
}
@ -475,7 +475,8 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target)
di != utilDepends.end(); ++di)
{
cmTarget const* dep = *di;
if(allowLinkable || !VSLinkable(dep) || linked.count(dep))
cmGeneratorTarget* dgt = this->GetGeneratorTarget(dep);
if(allowLinkable || !VSLinkable(dgt) || linked.count(dep))
{
// Direct dependency allowed.
vsTargetDepend.insert(dep->GetName());

72
Source/cmGlobalXCodeGenerator.cxx
View File

@ -787,14 +787,16 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
// Is this a resource file in this target? Add it to the resources group...
//
cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget);
cmGeneratorTarget::SourceFileFlags tsFlags =
this->GetGeneratorTarget(&cmtarget)->GetTargetSourceFileFlags(sf);
gtgt->GetTargetSourceFileFlags(sf);
bool isResource = tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource;
// Is this a "private" or "public" framework header file?
// Set the ATTRIBUTES attribute appropriately...
//
if(cmtarget.IsFrameworkOnApple())
if(gtgt->IsFrameworkOnApple())
{
if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader)
{
@ -1193,9 +1195,9 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
}
// some build phases only apply to bundles and/or frameworks
bool isFrameworkTarget = cmtarget.IsFrameworkOnApple();
bool isFrameworkTarget = gtgt->IsFrameworkOnApple();
bool isBundleTarget = cmtarget.GetPropertyAsBool("MACOSX_BUNDLE");
bool isCFBundleTarget = cmtarget.IsCFBundleOnApple();
bool isCFBundleTarget = gtgt->IsCFBundleOnApple();
cmXCodeObject* buildFiles = 0;
@ -1289,7 +1291,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
copyFilesBuildPhase->AddAttribute("dstSubfolderSpec",
this->CreateString("6"));
std::ostringstream ostr;
if (cmtarget.IsFrameworkOnApple())
if (gtgt->IsFrameworkOnApple())
{
// dstPath in frameworks is relative to Versions/<version>
ostr << mit->first;
@ -1467,8 +1469,10 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
std::vector<cmCustomCommand> postbuild
= cmtarget.GetPostBuildCommands();
cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget);
if(cmtarget.GetType() == cmState::SHARED_LIBRARY &&
!cmtarget.IsFrameworkOnApple())
!gtgt->IsFrameworkOnApple())
{
cmCustomCommandLines cmd;
cmd.resize(1);
@ -1500,7 +1504,6 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
}
std::vector<cmSourceFile*> classes;
cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget);
if (!gtgt->GetConfigCommonSourceFiles(classes))
{
return;
@ -1814,14 +1817,14 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
// Add shared-library flags if needed.
this->CurrentLocalGenerator->AddCMP0018Flags(flags, &target,
this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt,
lang, configName);
this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, &target,
this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt,
lang);
this->CurrentLocalGenerator->
AddCompileOptions(flags, &target, lang, configName);
AddCompileOptions(flags, gtgt, lang, configName);
}
std::string llang = gtgt->GetLinkerLanguage(configName);
@ -1884,7 +1887,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
this->CurrentLocalGenerator
->GetStaticLibraryFlags(extraLinkOptions,
cmSystemTools::UpperCase(configName),
&target);
gtgt);
}
else
{
@ -1943,7 +1946,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
const char* version = target.GetProperty("VERSION");
const char* soversion = target.GetProperty("SOVERSION");
if(!gtgt->HasSOName(configName) || target.IsFrameworkOnApple())
if(!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple())
{
version = 0;
soversion = 0;
@ -1990,7 +1993,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
pndir = gtgt->GetDirectory(configName);
}
if(target.IsFrameworkOnApple() || target.IsCFBundleOnApple())
if(gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple())
{
pnprefix = "";
}
@ -2043,7 +2046,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
{
buildSettings->AddAttribute("LIBRARY_STYLE",
this->CreateString("BUNDLE"));
if (target.IsCFBundleOnApple())
if (gtgt->IsCFBundleOnApple())
{
// It turns out that a BUNDLE is basically the same
// in many ways as an application bundle, as far as
@ -2062,7 +2065,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
// a per-configuration Info.plist file. The cfbundle plist
// is very similar to the application bundle plist
this->CurrentLocalGenerator
->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)",
plist.c_str());
std::string path =
this->ConvertToRelativeForXCode(plist.c_str());
@ -2111,7 +2114,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
// so let it replace the framework name. This avoids creating
// a per-configuration Info.plist file.
this->CurrentLocalGenerator
->GenerateFrameworkInfoPList(&target, "$(EXECUTABLE_NAME)",
->GenerateFrameworkInfoPList(gtgt, "$(EXECUTABLE_NAME)",
plist.c_str());
std::string path =
this->ConvertToRelativeForXCode(plist.c_str());
@ -2154,7 +2157,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
// so let it replace the executable name. This avoids creating
// a per-configuration Info.plist file.
this->CurrentLocalGenerator
->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)",
plist.c_str());
std::string path =
this->ConvertToRelativeForXCode(plist.c_str());
@ -2422,7 +2425,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
int patch;
// VERSION -> current_version
target.GetTargetVersion(false, major, minor, patch);
gtgt->GetTargetVersion(false, major, minor, patch);
std::ostringstream v;
// Xcode always wants at least 1.0.0 or nothing
@ -2434,7 +2437,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
this->CreateString(v.str().c_str()));
// SOVERSION -> compatibility_version
target.GetTargetVersion(true, major, minor, patch);
gtgt->GetTargetVersion(true, major, minor, patch);
std::ostringstream vso;
// Xcode always wants at least 1.0.0 or nothing
@ -2639,23 +2642,24 @@ cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(cmTarget const& cmtarget) const
}
//----------------------------------------------------------------------------
const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget)
const char* cmGlobalXCodeGenerator::GetTargetFileType(
cmGeneratorTarget* target)
{
switch(cmtarget.GetType())
switch(target->GetType())
{
case cmState::OBJECT_LIBRARY:
case cmState::STATIC_LIBRARY:
return "archive.ar";
case cmState::MODULE_LIBRARY:
if (cmtarget.IsXCTestOnApple())
if (target->IsXCTestOnApple())
return "wrapper.cfbundle";
else if (cmtarget.IsCFBundleOnApple())
else if (target->IsCFBundleOnApple())
return "wrapper.plug-in";
else
return ((this->XcodeVersion >= 22)?
"compiled.mach-o.executable" : "compiled.mach-o.dylib");
case cmState::SHARED_LIBRARY:
return (cmtarget.GetPropertyAsBool("FRAMEWORK")?
return (target->GetPropertyAsBool("FRAMEWORK")?
"wrapper.framework" : "compiled.mach-o.dylib");
case cmState::EXECUTABLE:
return "compiled.mach-o.executable";
@ -2665,28 +2669,29 @@ const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget)
}
//----------------------------------------------------------------------------
const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget)
const char* cmGlobalXCodeGenerator::GetTargetProductType(
cmGeneratorTarget* target)
{
switch(cmtarget.GetType())
switch(target->GetType())
{
case cmState::OBJECT_LIBRARY:
case cmState::STATIC_LIBRARY:
return "com.apple.product-type.library.static";
case cmState::MODULE_LIBRARY:
if (cmtarget.IsXCTestOnApple())
if (target->IsXCTestOnApple())
return "com.apple.product-type.bundle.unit-test";
else if (cmtarget.IsCFBundleOnApple())
else if (target->IsCFBundleOnApple())
return "com.apple.product-type.bundle";
else
return ((this->XcodeVersion >= 22)?
"com.apple.product-type.tool" :
"com.apple.product-type.library.dynamic");
case cmState::SHARED_LIBRARY:
return (cmtarget.GetPropertyAsBool("FRAMEWORK")?
return (target->GetPropertyAsBool("FRAMEWORK")?
"com.apple.product-type.framework" :
"com.apple.product-type.library.dynamic");
case cmState::EXECUTABLE:
return (cmtarget.GetPropertyAsBool("MACOSX_BUNDLE")?
return (target->GetPropertyAsBool("MACOSX_BUNDLE")?
"com.apple.product-type.application" :
"com.apple.product-type.tool");
default: break;
@ -2727,9 +2732,11 @@ cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&cmtarget);
cmXCodeObject* fileRef =
this->CreateObject(cmXCodeObject::PBXFileReference);
if(const char* fileType = this->GetTargetFileType(cmtarget))
if(const char* fileType = this->GetTargetFileType(gtgt))
{
fileRef->AddAttribute("explicitFileType", this->CreateString(fileType));
}
@ -2742,7 +2749,6 @@ cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
}
else
{
cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&cmtarget);
fullName = gtgt->GetFullName(defConfig.c_str());
}
fileRef->AddAttribute("path", this->CreateString(fullName.c_str()));
@ -2752,7 +2758,7 @@ cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
fileRef->SetComment(cmtarget.GetName().c_str());
target->AddAttribute("productReference",
this->CreateObjectReference(fileRef));
if(const char* productType = this->GetTargetProductType(cmtarget))
if(const char* productType = this->GetTargetProductType(gtgt))
{
target->AddAttribute("productType", this->CreateString(productType));
}

4
Source/cmGlobalXCodeGenerator.h
View File

@ -137,8 +137,8 @@ private:
void ForceLinkerLanguages();
void ForceLinkerLanguage(cmTarget& cmtarget);
const char* GetTargetLinkFlagsVar(cmTarget const& cmtarget) const;
const char* GetTargetFileType(cmTarget& cmtarget);
const char* GetTargetProductType(cmTarget& cmtarget);
const char* GetTargetFileType(cmGeneratorTarget* target);
const char* GetTargetProductType(cmGeneratorTarget* target);
std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget);
void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
const char* value);

1
Source/cmIncludeCommand.cxx
View File

@ -126,7 +126,6 @@ bool cmIncludeCommand
}
}
gg->CreateGenerationObjects();
gg->ComputeBuildFileGenerators();
gg->GenerateImportFile(fname_abs);
}

9
Source/cmInstallCommand.cxx
View File

@ -773,7 +773,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
if(!exports.GetString().empty() && !namelinkOnly)
{
cmTargetExport *te = new cmTargetExport;
te->Target = &target;
te->TargetName = target.GetName();
te->ArchiveGenerator = archiveGenerator;
te->BundleGenerator = bundleGenerator;
te->FrameworkGenerator = frameworkGenerator;
@ -1379,16 +1379,17 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
tei != exportSet->GetTargetExports()->end(); ++tei)
{
cmTargetExport const* te = *tei;
cmTarget* tgt = this->Makefile->FindTarget(te->TargetName);
const bool newCMP0022Behavior =
te->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& te->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
tgt->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& tgt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
if(!newCMP0022Behavior)
{
std::ostringstream e;
e << "INSTALL(EXPORT) given keyword \""
<< "EXPORT_LINK_INTERFACE_LIBRARIES" << "\", but target \""
<< te->Target->GetName()
<< te->TargetName
<< "\" does not have policy CMP0022 set to NEW.";
this->SetError(e.str());
return false;

1
Source/cmInstallExportGenerator.cxx
View File

@ -56,6 +56,7 @@ cmInstallExportGenerator::~cmInstallExportGenerator()
void cmInstallExportGenerator::Compute(cmLocalGenerator* lg)
{
this->LocalGenerator = lg;
this->ExportSet->Compute(lg);
}
//----------------------------------------------------------------------------

27
Source/cmInstallTargetGenerator.cxx
View File

@ -150,7 +150,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
std::string to1 = toDir + targetName;
// Handle OSX Bundles.
if(this->Target->Target->IsAppBundleOnApple())
if(this->Target->IsAppBundleOnApple())
{
// Install the whole app bundle directory.
type = cmInstallType_DIRECTORY;
@ -208,7 +208,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
// An import library looks like a static library.
type = cmInstallType_STATIC_LIBRARY;
}
else if(this->Target->Target->IsFrameworkOnApple())
else if(this->Target->IsFrameworkOnApple())
{
// There is a bug in cmInstallCommand if this fails.
assert(this->NamelinkMode == NamelinkModeNone);
@ -226,7 +226,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
filesFrom.push_back(from1);
filesTo.push_back(to1);
}
else if(this->Target->Target->IsCFBundleOnApple())
else if(this->Target->IsCFBundleOnApple())
{
// Install the whole app bundle directory.
type = cmInstallType_DIRECTORY;
@ -359,34 +359,31 @@ cmInstallTargetGenerator::GetInstallFilename(const std::string& config) const
{
NameType nameType = this->ImportLibrary? NameImplib : NameNormal;
return
cmInstallTargetGenerator::GetInstallFilename(this->Target->Target, config,
cmInstallTargetGenerator::GetInstallFilename(this->Target, config,
nameType);
}
//----------------------------------------------------------------------------
std::string
cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target,
cmInstallTargetGenerator::GetInstallFilename(cmGeneratorTarget const* target,
const std::string& config,
NameType nameType)
{
std::string fname;
// Compute the name of the library.
cmGeneratorTarget *gtgt = target->GetMakefile()
->GetGlobalGenerator()
->GetGeneratorTarget(target);
if(target->GetType() == cmState::EXECUTABLE)
{
std::string targetName;
std::string targetNameReal;
std::string targetNameImport;
std::string targetNamePDB;
gtgt->GetExecutableNames(targetName, targetNameReal,
target->GetExecutableNames(targetName, targetNameReal,
targetNameImport, targetNamePDB,
config);
if(nameType == NameImplib)
{
// Use the import library name.
if(!gtgt->GetImplibGNUtoMS(targetNameImport, fname,
if(!target->GetImplibGNUtoMS(targetNameImport, fname,
"${CMAKE_IMPORT_LIBRARY_SUFFIX}"))
{
fname = targetNameImport;
@ -410,12 +407,12 @@ cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target,
std::string targetNameReal;
std::string targetNameImport;
std::string targetNamePDB;
gtgt->GetLibraryNames(targetName, targetNameSO, targetNameReal,
target->GetLibraryNames(targetName, targetNameSO, targetNameReal,
targetNameImport, targetNamePDB, config);
if(nameType == NameImplib)
{
// Use the import library name.
if(!gtgt->GetImplibGNUtoMS(targetNameImport, fname,
if(!target->GetImplibGNUtoMS(targetNameImport, fname,
"${CMAKE_IMPORT_LIBRARY_SUFFIX}"))
{
fname = targetNameImport;
@ -585,7 +582,7 @@ cmInstallTargetGenerator
// The directory portions differ. Append the filename to
// create the mapping.
std::string fname =
this->GetInstallFilename(tgt->Target, config, NameSO);
this->GetInstallFilename(tgt, config, NameSO);
// Map from the build-tree install_name.
for_build += fname;
@ -608,7 +605,7 @@ cmInstallTargetGenerator
std::string for_install =
this->Target->GetInstallNameDirForInstallTree();
if(this->Target->Target->IsFrameworkOnApple() && for_install.empty())
if(this->Target->IsFrameworkOnApple() && for_install.empty())
{
// Frameworks seem to have an id corresponding to their own full
// path.
@ -622,7 +619,7 @@ cmInstallTargetGenerator
{
// Prepare to refer to the install-tree install_name.
new_id = for_install;
new_id += this->GetInstallFilename(this->Target->Target, config, NameSO);
new_id += this->GetInstallFilename(this->Target, config, NameSO);
}
}

3
Source/cmInstallTargetGenerator.h
View File

@ -14,7 +14,6 @@
#include "cmInstallGenerator.h"
class cmTarget;
class cmGeneratorTarget;
/** \class cmInstallTargetGenerator
@ -54,7 +53,7 @@ public:
NameReal
};
static std::string GetInstallFilename(cmTarget const* target,
static std::string GetInstallFilename(const cmGeneratorTarget* target,
const std::string& config,
NameType nameType = NameNormal);

76
Source/cmLocalGenerator.cxx
View File

@ -476,7 +476,7 @@ void cmLocalGenerator::ComputeTargetManifest()
{
continue;
}
if (target.Target->IsImported())
if (target.IsImported())
{
continue;
}
@ -920,7 +920,7 @@ cmLocalGenerator::ExpandRuleVariables(std::string& s,
}
//----------------------------------------------------------------------------
const char* cmLocalGenerator::GetRuleLauncher(cmTarget* target,
const char* cmLocalGenerator::GetRuleLauncher(cmGeneratorTarget* target,
const std::string& prop)
{
if(target)
@ -934,7 +934,8 @@ const char* cmLocalGenerator::GetRuleLauncher(cmTarget* target,
}
//----------------------------------------------------------------------------
void cmLocalGenerator::InsertRuleLauncher(std::string& s, cmTarget* target,
void cmLocalGenerator::InsertRuleLauncher(std::string& s,
cmGeneratorTarget* target,
const std::string& prop)
{
if(const char* val = this->GetRuleLauncher(target, prop))
@ -1087,27 +1088,23 @@ std::string cmLocalGenerator::GetIncludeFlags(
//----------------------------------------------------------------------------
void cmLocalGenerator::AddCompileDefinitions(std::set<std::string>& defines,
cmTarget const* target,
cmGeneratorTarget const* target,
const std::string& config,
const std::string& lang)
{
std::vector<std::string> targetDefines;
cmGeneratorTarget* gtgt = this->GlobalGenerator->GetGeneratorTarget(target);
gtgt->GetCompileDefinitions(targetDefines, config, lang);
target->GetCompileDefinitions(targetDefines, config, lang);
this->AppendDefines(defines, targetDefines);
}
//----------------------------------------------------------------------------
void cmLocalGenerator::AddCompileOptions(
std::string& flags, cmTarget* target,
std::string& flags, cmGeneratorTarget* target,
const std::string& lang, const std::string& config
)
{
std::string langFlagRegexVar = std::string("CMAKE_")+lang+"_FLAG_REGEX";
cmGeneratorTarget* gtgt =
this->GlobalGenerator->GetGeneratorTarget(target);
if(const char* langFlagRegexStr =
this->Makefile->GetDefinition(langFlagRegexVar))
{
@ -1118,7 +1115,7 @@ void cmLocalGenerator::AddCompileOptions(
{
cmSystemTools::ParseWindowsCommandLine(targetFlags, opts);
}
gtgt->GetCompileOptions(opts, config, lang);
target->GetCompileOptions(opts, config, lang);
for(std::vector<std::string>::const_iterator i = opts.begin();
i != opts.end(); ++i)
{
@ -1139,7 +1136,7 @@ void cmLocalGenerator::AddCompileOptions(
this->AppendFlags(flags, targetFlags);
}
std::vector<std::string> opts;
gtgt->GetCompileOptions(opts, config, lang);
target->GetCompileOptions(opts, config, lang);
for(std::vector<std::string>::const_iterator i = opts.begin();
i != opts.end(); ++i)
{
@ -1148,19 +1145,19 @@ void cmLocalGenerator::AddCompileOptions(
}
}
std::vector<std::string> features;
gtgt->GetCompileFeatures(features, config);
target->GetCompileFeatures(features, config);
for(std::vector<std::string>::const_iterator it = features.begin();
it != features.end(); ++it)
{
if (!this->Makefile->AddRequiredTargetFeature(target, *it))
if (!this->Makefile->AddRequiredTargetFeature(target->Target, *it))
{
return;
}
}
for(std::map<std::string, std::string>::const_iterator it
= gtgt->GetMaxLanguageStandards().begin();
it != gtgt->GetMaxLanguageStandards().end(); ++it)
= target->GetMaxLanguageStandards().begin();
it != target->GetMaxLanguageStandards().end(); ++it)
{
const char* standard = target->GetProperty(it->first + "_STANDARD");
if(!standard)
@ -1314,7 +1311,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags,
std::string const& config,
cmTarget* target)
cmGeneratorTarget* target)
{
this->AppendFlags(flags,
this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"));
@ -1348,7 +1345,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
switch(target->GetType())
{
case cmState::STATIC_LIBRARY:
this->GetStaticLibraryFlags(linkFlags, buildType, target->Target);
this->GetStaticLibraryFlags(linkFlags, buildType, target);
break;
case cmState::MODULE_LIBRARY:
libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS";
@ -1421,7 +1418,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
{
cmSystemTools::Error
("CMake can not determine linker language for target: ",
target->Target->GetName().c_str());
target->GetName().c_str());
return;
}
this->AddLanguageFlags(flags, linkLanguage, buildType);
@ -1904,7 +1901,8 @@ void cmLocalGenerator::AddSharedFlags(std::string& flags,
//----------------------------------------------------------------------------
void cmLocalGenerator::
AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
AddCompilerRequirementFlag(std::string &flags,
cmGeneratorTarget const* target,
const std::string& lang)
{
if (lang.empty())
@ -1942,7 +1940,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
"CMAKE_" + lang + standardProp
+ "_" + type + "_COMPILE_OPTION";
const char *opt = target->GetMakefile()->GetDefinition(option_flag);
const char *opt = target->Target->GetMakefile()
->GetDefinition(option_flag);
if (!opt)
{
std::ostringstream e;
@ -1983,7 +1982,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
std::string e =
lang + "_STANDARD is set to invalid value '" + standard + "'";
this->GetGlobalGenerator()->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e, target->GetBacktrace());
->IssueMessage(cmake::FATAL_ERROR, e, target->Target->GetBacktrace());
return;
}
@ -2007,7 +2006,7 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
+ "_" + type + "_COMPILE_OPTION";
const char *opt =
target->GetMakefile()->GetRequiredDefinition(option_flag);
target->Target->GetMakefile()->GetRequiredDefinition(option_flag);
this->AppendFlagEscape(flags, opt);
return;
}
@ -2018,7 +2017,8 @@ AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
"CMAKE_" + lang + *stdIt
+ "_" + type + "_COMPILE_OPTION";
if (const char *opt = target->GetMakefile()->GetDefinition(option_flag))
if (const char *opt = target->Target
->GetMakefile()->GetDefinition(option_flag))
{
this->AppendFlagEscape(flags, opt);
return;
@ -2094,7 +2094,7 @@ static void AddInlineVisibilityCompileOption(std::string &flags,
//----------------------------------------------------------------------------
void cmLocalGenerator
::AddVisibilityPresetFlags(std::string &flags, cmTarget const* target,
::AddVisibilityPresetFlags(std::string &flags, cmGeneratorTarget const* target,
const std::string& lang)
{
if (lang.empty())
@ -2106,9 +2106,9 @@ void cmLocalGenerator
std::string *pWarnCMP0063 = 0;
if (target->GetType() != cmState::SHARED_LIBRARY &&
target->GetType() != cmState::MODULE_LIBRARY &&
!target->IsExecutableWithExports())
!target->Target->IsExecutableWithExports())
{
switch (target->GetPolicyStatusCMP0063())
switch (target->Target->GetPolicyStatusCMP0063())
{
case cmPolicies::OLD:
return;
@ -2120,11 +2120,12 @@ void cmLocalGenerator
}
}
AddVisibilityCompileOption(flags, target, this, lang, pWarnCMP0063);
AddVisibilityCompileOption(flags, target->Target, this, lang, pWarnCMP0063);
if(lang == "CXX")
{
AddInlineVisibilityCompileOption(flags, target, this, pWarnCMP0063);
AddInlineVisibilityCompileOption(flags, target->Target,
this, pWarnCMP0063);
}
if (!warnCMP0063.empty() &&
@ -2138,14 +2139,15 @@ void cmLocalGenerator
"has the following visibility properties set for " << lang << ":\n" <<
warnCMP0063 <<
"For compatibility CMake is not honoring them for this target.";
target->GetMakefile()->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING, w.str(), target->GetBacktrace());
target->Target->GetMakefile()->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
target->Target->GetBacktrace());
}
}
//----------------------------------------------------------------------------
void cmLocalGenerator::AddCMP0018Flags(std::string &flags,
cmTarget const* target,
cmGeneratorTarget const* target,
std::string const& lang,
const std::string& config)
{
@ -2169,9 +2171,7 @@ void cmLocalGenerator::AddCMP0018Flags(std::string &flags,
return;
}
cmGeneratorTarget* gtgt =
this->GlobalGenerator->GetGeneratorTarget(target);
if (gtgt->GetLinkInterfaceDependentBoolProperty(
if (target->GetLinkInterfaceDependentBoolProperty(
"POSITION_INDEPENDENT_CODE",
config))
{
@ -3012,7 +3012,7 @@ bool cmLocalGenerator::CheckDefinition(std::string const& define) const
}
//----------------------------------------------------------------------------
static void cmLGInfoProp(cmMakefile* mf, cmTarget* target,
static void cmLGInfoProp(cmMakefile* mf, cmGeneratorTarget* target,
const std::string& prop)
{
if(const char* val = target->GetProperty(prop))
@ -3022,7 +3022,7 @@ static void cmLGInfoProp(cmMakefile* mf, cmTarget* target,
}
//----------------------------------------------------------------------------
void cmLocalGenerator::GenerateAppleInfoPList(cmTarget* target,
void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target,
const std::string& targetName,
const char* fname)
{
@ -3066,7 +3066,7 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmTarget* target,
}
//----------------------------------------------------------------------------
void cmLocalGenerator::GenerateFrameworkInfoPList(cmTarget* target,
void cmLocalGenerator::GenerateFrameworkInfoPList(cmGeneratorTarget* target,
const std::string& targetName,
const char* fname)
{

29
Source/cmLocalGenerator.h
View File

@ -20,7 +20,6 @@
class cmMakefile;
class cmGlobalGenerator;
class cmGeneratorTarget;
class cmTarget;
class cmTargetManifest;
class cmSourceFile;
class cmCustomCommand;
@ -91,13 +90,15 @@ public:
void AddLanguageFlags(std::string& flags, const std::string& lang,
const std::string& config);
void AddCMP0018Flags(std::string &flags, cmTarget const* target,
void AddCMP0018Flags(std::string &flags, cmGeneratorTarget const* target,
std::string const& lang, const std::string& config);
void AddVisibilityPresetFlags(std::string &flags, cmTarget const* target,
void AddVisibilityPresetFlags(std::string &flags,
cmGeneratorTarget const* target,
const std::string& lang);
void AddConfigVariableFlags(std::string& flags, const std::string& var,
const std::string& config);
void AddCompilerRequirementFlag(std::string &flags, cmTarget const* target,
void AddCompilerRequirementFlag(std::string &flags,
cmGeneratorTarget const* target,
const std::string& lang);
///! Append flags to a string.
virtual void AppendFlags(std::string& flags, const std::string& newFlags);
@ -188,10 +189,10 @@ public:
const std::string& lang = "C",
const std::string& config = "",
bool stripImplicitInclDirs = true) const;
void AddCompileOptions(std::string& flags, cmTarget* target,
void AddCompileOptions(std::string& flags, cmGeneratorTarget* target,
const std::string& lang, const std::string& config);
void AddCompileDefinitions(std::set<std::string>& defines,
cmTarget const* target,
cmGeneratorTarget const* target,
const std::string& config,
const std::string& lang);
@ -212,7 +213,7 @@ public:
{
memset(this, 0, sizeof(*this));
}
cmTarget* CMTarget;
cmGeneratorTarget* CMTarget;
const char* TargetPDB;
const char* TargetCompilePDB;
const char* TargetVersionMajor;
@ -278,13 +279,14 @@ public:
/**
* Generate a Mac OS X application bundle Info.plist file.
*/
void GenerateAppleInfoPList(cmTarget* target, const std::string& targetName,
void GenerateAppleInfoPList(cmGeneratorTarget* target,
const std::string& targetName,
const char* fname);
/**
* Generate a Mac OS X framework Info.plist file.
*/
void GenerateFrameworkInfoPList(cmTarget* target,
void GenerateFrameworkInfoPList(cmGeneratorTarget* target,
const std::string& targetName,
const char* fname);
/** Construct a comment for a custom command. */
@ -298,7 +300,7 @@ public:
/** Fill out the static linker flags for the given target. */
void GetStaticLibraryFlags(std::string& flags,
std::string const& config,
cmTarget* target);
cmGeneratorTarget* target);
/** Fill out these strings for the given target. Libraries to link,
* flags, and linkflags. */
@ -341,8 +343,9 @@ protected:
std::string ExpandRuleVariable(std::string const& variable,
const RuleVariables& replaceValues);
const char* GetRuleLauncher(cmTarget* target, const std::string& prop);
void InsertRuleLauncher(std::string& s, cmTarget* target,
const char* GetRuleLauncher(cmGeneratorTarget* target,
const std::string& prop);
void InsertRuleLauncher(std::string& s, cmGeneratorTarget* target,
const std::string& prop);
// Handle old-style install rules stored in the targets.
@ -367,7 +370,7 @@ protected:
std::string::size_type ObjectPathMax;
std::set<std::string> ObjectMaxPathViolations;
std::set<cmTarget const*> WarnCMP0063;
std::set<cmGeneratorTarget const*> WarnCMP0063;
cmGeneratorTargetsType GeneratorTargets;
bool EmitUniversalBinaryFlags;

2
Source/cmLocalGhsMultiGenerator.cxx
View File

@ -32,7 +32,7 @@ void cmLocalGhsMultiGenerator::Generate()
++l)
{
if (l->second->GetType() == cmState::INTERFACE_LIBRARY
|| l->second->Target->IsImported())
|| l->second->IsImported())
{
continue;
}

26
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -1034,7 +1034,7 @@ void
cmLocalUnixMakefileGenerator3
::AppendCustomCommands(std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs,
cmTarget* target,
cmGeneratorTarget* target,
cmLocalGenerator::RelativeRoot relative)
{
for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
@ -1050,7 +1050,7 @@ void
cmLocalUnixMakefileGenerator3
::AppendCustomCommand(std::vector<std::string>& commands,
cmCustomCommandGenerator const& ccg,
cmTarget* target,
cmGeneratorTarget* target,
bool echo_comment,
cmLocalGenerator::RelativeRoot relative,
std::ostream* content)
@ -1181,7 +1181,7 @@ cmLocalUnixMakefileGenerator3
std::string
cmLocalUnixMakefileGenerator3::MakeLauncher(
cmCustomCommandGenerator const& ccg,
cmTarget* target, RelativeRoot relative)
cmGeneratorTarget* target, RelativeRoot relative)
{
// Short-circuit if there is no launcher.
const char* prop = "RULE_LAUNCH_CUSTOM";
@ -1788,6 +1788,9 @@ void cmLocalUnixMakefileGenerator3
this->AppendEcho(commands, text,
cmLocalUnixMakefileGenerator3::EchoGlobal);
cmGeneratorTarget* gt = this->GlobalGenerator
->GetGeneratorTarget(&glIt->second);
// Global targets store their rules in pre- and post-build commands.
this->AppendCustomDepends(depends,
glIt->second.GetPreBuildCommands());
@ -1795,11 +1798,11 @@ void cmLocalUnixMakefileGenerator3
glIt->second.GetPostBuildCommands());
this->AppendCustomCommands(commands,
glIt->second.GetPreBuildCommands(),
&glIt->second,
gt,
cmLocalGenerator::START_OUTPUT);
this->AppendCustomCommands(commands,
glIt->second.GetPostBuildCommands(),
&glIt->second,
gt,
cmLocalGenerator::START_OUTPUT);
std::string targetName = glIt->second.GetName();
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
@ -1976,10 +1979,11 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
void cmLocalUnixMakefileGenerator3
::WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &target)
::WriteDependLanguageInfo(std::ostream& cmakefileStream,
cmGeneratorTarget* target)
{
ImplicitDependLanguageMap const& implicitLangs =
this->GetImplicitDepends(target);
this->GetImplicitDepends(*target->Target);
// list the languages
cmakefileStream
@ -2030,7 +2034,7 @@ void cmLocalUnixMakefileGenerator3
// Build a list of preprocessor definitions for the target.
std::set<std::string> defines;
this->AddCompileDefinitions(defines, &target,
this->AddCompileDefinitions(defines, target,
this->ConfigName, l->first);
if(!defines.empty())
{
@ -2056,12 +2060,10 @@ void cmLocalUnixMakefileGenerator3
<< "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
std::vector<std::string> includes;
cmGeneratorTarget* gt = this->GetGlobalGenerator()
->GetGeneratorTarget(&target);
const std::string& config =
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
this->GetIncludeDirectories(includes, gt,
this->GetIncludeDirectories(includes, target,
l->first, config);
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
@ -2084,7 +2086,7 @@ void cmLocalUnixMakefileGenerator3
cmSystemTools::ExpandListArgument(xform, transformRules);
}
if(const char* xform =
target.GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
{
cmSystemTools::ExpandListArgument(xform, transformRules);
}

9
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -182,7 +182,8 @@ protected:
// write the depend info
void WriteDependLanguageInfo(std::ostream& cmakefileStream, cmTarget &tgt);
void WriteDependLanguageInfo(std::ostream& cmakefileStream,
cmGeneratorTarget *tgt);
// write the local help rule
void WriteHelpRule(std::ostream& ruleFileStream);
@ -215,12 +216,12 @@ protected:
cmCustomCommandGenerator const& cc);
void AppendCustomCommands(std::vector<std::string>& commands,
const std::vector<cmCustomCommand>& ccs,
cmTarget* target,
cmGeneratorTarget* target,
cmLocalGenerator::RelativeRoot relative =
cmLocalGenerator::HOME_OUTPUT);
void AppendCustomCommand(std::vector<std::string>& commands,
cmCustomCommandGenerator const& ccg,
cmTarget* target,
cmGeneratorTarget* target,
bool echo_comment=false,
cmLocalGenerator::RelativeRoot relative =
cmLocalGenerator::HOME_OUTPUT,
@ -237,7 +238,7 @@ protected:
private:
std::string ConvertShellCommand(std::string const& cmd, RelativeRoot root);
std::string MakeLauncher(cmCustomCommandGenerator const& ccg,
cmTarget* target, RelativeRoot relative);
cmGeneratorTarget* target, RelativeRoot relative);
virtual void ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,

22
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -1319,7 +1319,7 @@ void cmLocalVisualStudio6Generator
{
int major;
int minor;
target.GetTargetVersion(major, minor);
gt->GetTargetVersion(major, minor);
std::ostringstream targetVersionStream;
targetVersionStream << "/version:" << major << "." << minor;
targetVersionFlag = targetVersionStream.str();
@ -1750,12 +1750,12 @@ void cmLocalVisualStudio6Generator
flagsRelWithDebInfo = this->Makefile->GetSafeDefinition(flagVar.c_str());
flagsRelWithDebInfo += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" ";
this->AddCompileOptions(flags, &target, linkLanguage, "");
this->AddCompileOptions(flagsDebug, &target, linkLanguage, "Debug");
this->AddCompileOptions(flagsRelease, &target, linkLanguage, "Release");
this->AddCompileOptions(flagsMinSizeRel, &target, linkLanguage,
this->AddCompileOptions(flags, gt, linkLanguage, "");
this->AddCompileOptions(flagsDebug, gt, linkLanguage, "Debug");
this->AddCompileOptions(flagsRelease, gt, linkLanguage, "Release");
this->AddCompileOptions(flagsMinSizeRel, gt, linkLanguage,
"MinSizeRel");
this->AddCompileOptions(flagsRelWithDebInfo, &target, linkLanguage,
this->AddCompileOptions(flagsRelWithDebInfo, gt, linkLanguage,
"RelWithDebInfo");
// if _UNICODE and _SBCS are not found, then add -D_MBCS
@ -1775,14 +1775,14 @@ void cmLocalVisualStudio6Generator
std::set<std::string> minsizeDefinesSet;
std::set<std::string> debugrelDefinesSet;
this->AddCompileDefinitions(definesSet, &target, "", linkLanguage);
this->AddCompileDefinitions(debugDefinesSet, &target,
this->AddCompileDefinitions(definesSet, gt, "", linkLanguage);
this->AddCompileDefinitions(debugDefinesSet, gt,
"DEBUG", linkLanguage);
this->AddCompileDefinitions(releaseDefinesSet, &target,
this->AddCompileDefinitions(releaseDefinesSet, gt,
"RELEASE", linkLanguage);
this->AddCompileDefinitions(minsizeDefinesSet, &target,
this->AddCompileDefinitions(minsizeDefinesSet, gt,
"MINSIZEREL", linkLanguage);
this->AddCompileDefinitions(debugrelDefinesSet, &target,
this->AddCompileDefinitions(debugrelDefinesSet, gt,
"RELWITHDEBINFO", linkLanguage);
std::string defines = " ";

12
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -733,7 +733,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
}
// Add the target-specific flags.
this->AddCompileOptions(flags, &target, linkLanguage, configName);
this->AddCompileOptions(flags, gt, linkLanguage, configName);
}
if(this->FortranProject)
@ -1152,7 +1152,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
}
}
std::string libflags;
this->GetStaticLibraryFlags(libflags, configTypeUpper, &target);
this->GetStaticLibraryFlags(libflags, configTypeUpper, gt);
if(!libflags.empty())
{
fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n";
@ -1215,7 +1215,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
temp += targetNameFull;
fout << "\t\t\t\tOutputFile=\""
<< this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
this->WriteTargetVersionAttribute(fout, target);
this->WriteTargetVersionAttribute(fout, gt);
linkOptions.OutputFlagMap(fout, "\t\t\t\t");
fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
this->OutputLibraryDirectories(fout, cli.GetDirectories());
@ -1314,7 +1314,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
temp += targetNameFull;
fout << "\t\t\t\tOutputFile=\""
<< this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
this->WriteTargetVersionAttribute(fout, target);
this->WriteTargetVersionAttribute(fout, gt);
linkOptions.OutputFlagMap(fout, "\t\t\t\t");
fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
this->OutputLibraryDirectories(fout, cli.GetDirectories());
@ -1384,11 +1384,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
//----------------------------------------------------------------------------
void
cmLocalVisualStudio7Generator
::WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target)
::WriteTargetVersionAttribute(std::ostream& fout, cmGeneratorTarget* gt)
{
int major;
int minor;
target.GetTargetVersion(major, minor);
gt->GetTargetVersion(major, minor);
fout << "\t\t\t\tVersion=\"" << major << "." << minor << "\"\n";
}

3
Source/cmLocalVisualStudio7Generator.h
View File

@ -106,7 +106,8 @@ private:
const char* source,
const cmCustomCommand& command,
FCInfo& fcinfo);
void WriteTargetVersionAttribute(std::ostream& fout, cmTarget& target);
void WriteTargetVersionAttribute(std::ostream& fout,
cmGeneratorTarget* gt);
bool WriteGroup(const cmSourceGroup *sg,
cmTarget& target, std::ostream &fout,

20
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@ -100,7 +100,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// Construct the full path version of the names.
std::string outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
if(this->Target->IsAppBundleOnApple())
if(this->GeneratorTarget->IsAppBundleOnApple())
{
this->OSXBundleGenerator->CreateAppBundle(targetName, outpath);
}
@ -168,7 +168,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
if(linkLanguage.empty())
{
cmSystemTools::Error("Cannot determine link language for target \"",
this->Target->GetName().c_str(), "\".");
this->GeneratorTarget->GetName().c_str(), "\".");
return;
}
@ -197,7 +197,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
this->ConfigName);
if(this->Target->GetPropertyAsBool("WIN32_EXECUTABLE"))
if(this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE"))
{
this->LocalGenerator->AppendFlags
(linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_WIN32_EXE"));
@ -226,11 +226,11 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// Add target-specific linker flags.
this->LocalGenerator->AppendFlags
(linkFlags, this->Target->GetProperty("LINK_FLAGS"));
(linkFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
std::string linkFlagsConfig = "LINK_FLAGS_";
linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
this->LocalGenerator->AppendFlags
(linkFlags, this->Target->GetProperty(linkFlagsConfig));
(linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
this->AddModuleDefinitionFlag(linkFlags);
@ -280,10 +280,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
{
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(),
this->Target);
this->GeneratorTarget);
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(),
this->Target);
this->GeneratorTarget);
}
// Determine whether a link script will be used.
@ -358,7 +358,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
cmLocalGenerator::RuleVariables vars;
vars.RuleLauncher = "RULE_LAUNCH_LINK";
vars.CMTarget = this->Target;
vars.CMTarget = this->GeneratorTarget;
vars.Language = linkLanguage.c_str();
vars.Objects = buildObjs.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
@ -382,7 +382,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
std::ostringstream minorStream;
int major;
int minor;
this->Target->GetTargetVersion(major, minor);
this->GeneratorTarget->GetTargetVersion(major, minor);
majorStream << major;
minorStream << minor;
targetVersionMajor = majorStream.str();
@ -449,7 +449,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
{
this->LocalGenerator->
AppendCustomCommands(commands, this->Target->GetPostBuildCommands(),
this->Target);
this->GeneratorTarget);
}
// Write the build rule.

49
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -115,18 +115,18 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules()
// Add post-build rules.
this->LocalGenerator->
AppendCustomCommands(commands, this->Target->GetPostBuildCommands(),
this->Target);
this->GeneratorTarget);
// Depend on the object files.
this->AppendObjectDepends(depends);
// Write the rule.
this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
this->Target->GetName(),
this->GeneratorTarget->GetName(),
depends, commands, true);
// Write the main driver rule to build everything in this target.
this->WriteTargetDriverRule(this->Target->GetName(), false);
this->WriteTargetDriverRule(this->GeneratorTarget->GetName(), false);
}
//----------------------------------------------------------------------------
@ -146,14 +146,14 @@ void cmMakefileLibraryTargetGenerator::WriteStaticLibraryRules()
std::string extraFlags;
this->LocalGenerator->GetStaticLibraryFlags(extraFlags,
cmSystemTools::UpperCase(this->ConfigName), this->Target);
cmSystemTools::UpperCase(this->ConfigName), this->GeneratorTarget);
this->WriteLibraryRules(linkRuleVar, extraFlags, false);
}
//----------------------------------------------------------------------------
void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
{
if(this->Target->IsFrameworkOnApple())
if(this->GeneratorTarget->IsFrameworkOnApple())
{
this->WriteFrameworkRules(relink);
return;
@ -166,11 +166,11 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
std::string extraFlags;
this->LocalGenerator->AppendFlags
(extraFlags, this->Target->GetProperty("LINK_FLAGS"));
(extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
std::string linkFlagsConfig = "LINK_FLAGS_";
linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
this->LocalGenerator->AppendFlags
(extraFlags, this->Target->GetProperty(linkFlagsConfig));
(extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
this->LocalGenerator->AddConfigVariableFlags
(extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName);
@ -190,11 +190,11 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink)
std::string extraFlags;
this->LocalGenerator->AppendFlags(extraFlags,
this->Target->GetProperty("LINK_FLAGS"));
this->GeneratorTarget->GetProperty("LINK_FLAGS"));
std::string linkFlagsConfig = "LINK_FLAGS_";
linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
this->LocalGenerator->AppendFlags
(extraFlags, this->Target->GetProperty(linkFlagsConfig));
(extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
this->LocalGenerator->AddConfigVariableFlags
(extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->ConfigName);
this->AddModuleDefinitionFlag(extraFlags);
@ -213,11 +213,11 @@ void cmMakefileLibraryTargetGenerator::WriteFrameworkRules(bool relink)
std::string extraFlags;
this->LocalGenerator->AppendFlags(extraFlags,
this->Target->GetProperty("LINK_FLAGS"));
this->GeneratorTarget->GetProperty("LINK_FLAGS"));
std::string linkFlagsConfig = "LINK_FLAGS_";
linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
this->LocalGenerator->AppendFlags
(extraFlags, this->Target->GetProperty(linkFlagsConfig));
(extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
this->LocalGenerator->AddConfigVariableFlags
(extraFlags, "CMAKE_MACOSX_FRAMEWORK_LINKER_FLAGS", this->ConfigName);
@ -244,7 +244,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
if(linkLanguage.empty())
{
cmSystemTools::Error("Cannot determine link language for target \"",
this->Target->GetName().c_str(), "\".");
this->GeneratorTarget->GetName().c_str(), "\".");
return;
}
@ -273,13 +273,13 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
// Construct the full path version of the names.
std::string outpath;
std::string outpathImp;
if(this->Target->IsFrameworkOnApple())
if(this->GeneratorTarget->IsFrameworkOnApple())
{
outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
this->OSXBundleGenerator->CreateFramework(targetName, outpath);
outpath += "/";
}
else if(this->Target->IsCFBundleOnApple())
else if(this->GeneratorTarget->IsCFBundleOnApple())
{
outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
this->OSXBundleGenerator->CreateCFBundle(targetName, outpath);
@ -360,7 +360,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
buildEcho += " shared library ";
break;
case cmState::MODULE_LIBRARY:
if (this->Target->IsCFBundleOnApple())
if (this->GeneratorTarget->IsCFBundleOnApple())
buildEcho += " CFBundle";
buildEcho += " shared module ";
break;
@ -458,10 +458,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
{
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(),
this->Target);
this->GeneratorTarget);
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(),
this->Target);
this->GeneratorTarget);
}
// Determine whether a link script will be used.
@ -569,12 +569,12 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
{
if(this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if(this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
std::string name_of_def_file =
this->GeneratorTarget->GetSupportDirectory();
name_of_def_file += std::string("/") +
this->Target->GetName();
this->GeneratorTarget->GetName();
name_of_def_file += ".def";
std::string cmd = cmSystemTools::GetCMakeCommand();
cmd = this->Convert(cmd, cmLocalGenerator::NONE,
@ -630,7 +630,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
std::ostringstream minorStream;
int major;
int minor;
this->Target->GetTargetVersion(major, minor);
this->GeneratorTarget->GetTargetVersion(major, minor);
majorStream << major;
minorStream << minor;
targetVersionMajor = majorStream.str();
@ -640,7 +640,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
vars.TargetVersionMinor = targetVersionMinor.c_str();
vars.RuleLauncher = "RULE_LAUNCH_LINK";
vars.CMTarget = this->Target;
vars.CMTarget = this->GeneratorTarget;
vars.Language = linkLanguage.c_str();
vars.Objects = buildObjs.c_str();
std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
@ -791,7 +791,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
// Add a rule to create necessary symlinks for the library.
// Frameworks are handled by cmOSXBundleGenerator.
if(targetOutPath != targetOutPathReal && !this->Target->IsFrameworkOnApple())
if(targetOutPath != targetOutPathReal
&& !this->GeneratorTarget->IsFrameworkOnApple())
{
std::string symlink = "$(CMAKE_COMMAND) -E cmake_symlink_library ";
symlink += targetOutPathReal;
@ -811,7 +812,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
{
this->LocalGenerator->
AppendCustomCommands(commands, this->Target->GetPostBuildCommands(),
this->Target);
this->GeneratorTarget);
}
// Compute the list of outputs.
@ -862,7 +863,7 @@ cmMakefileLibraryTargetGenerator
int major;
int minor;
int patch;
this->Target->GetTargetVersion(so, major, minor, 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.

26
Source/cmMakefileTargetGenerator.cxx
View File

@ -248,7 +248,8 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
// Write an empty dependency file.
cmGeneratedFileStream depFileStream(dependFileNameFull.c_str());
depFileStream
<< "# Empty dependencies file for " << this->Target->GetName() << ".\n"
<< "# Empty dependencies file for "
<< this->GeneratorTarget->GetName() << ".\n"
<< "# This may be replaced when dependencies are built." << std::endl;
}
@ -394,7 +395,7 @@ void cmMakefileTargetGenerator
err << "Warning: Source file \""
<< source.GetFullPath()
<< "\" is listed multiple times for target \""
<< this->Target->GetName()
<< this->GeneratorTarget->GetName()
<< "\".";
cmSystemTools::Message(err.str().c_str(), "Warning");
return;
@ -588,7 +589,7 @@ cmMakefileTargetGenerator
}
cmLocalGenerator::RuleVariables vars;
vars.RuleLauncher = "RULE_LAUNCH_COMPILE";
vars.CMTarget = this->Target;
vars.CMTarget = this->GeneratorTarget;
vars.Language = lang.c_str();
vars.Target = targetOutPathReal.c_str();
vars.TargetPDB = targetOutPathPDB.c_str();
@ -666,7 +667,7 @@ cmMakefileTargetGenerator
if (!compileCommands.empty() && (lang == "C" || lang == "CXX"))
{
std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
const char *iwyu = this->Target->GetProperty(iwyu_prop);
const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
if (iwyu && *iwyu)
{
std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_iwyu --iwyu=";
@ -680,7 +681,7 @@ cmMakefileTargetGenerator
if (!compileCommands.empty() && (lang == "C" || lang == "CXX"))
{
std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
const char *clauncher = this->Target->GetProperty(clauncher_prop);
const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
if (clauncher && *clauncher)
{
std::vector<std::string> launcher_cmd;
@ -1039,7 +1040,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
return;
}
this->LocalGenerator->
WriteDependLanguageInfo(*this->InfoFileStream,*this->Target);
WriteDependLanguageInfo(*this->InfoFileStream, this->GeneratorTarget);
// Store multiple output pairs in the depend info file.
if(!this->MultipleOutputPairs.empty())
@ -1210,7 +1211,8 @@ void cmMakefileTargetGenerator
// Now append the actual user-specified commands.
std::ostringstream content;
this->LocalGenerator->AppendCustomCommand(commands, ccg, this->Target, false,
this->LocalGenerator->AppendCustomCommand(commands, ccg,
this->GeneratorTarget, false,
cmLocalGenerator::HOME_OUTPUT,
&content);
@ -1267,10 +1269,10 @@ cmMakefileTargetGenerator
// Write a make variable assignment that lists all objects for the
// target.
variableName =
this->LocalGenerator->CreateMakeVariable(this->Target->GetName(),
this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(),
"_OBJECTS");
*this->BuildFileStream
<< "# Object files for target " << this->Target->GetName() << "\n"
<< "# Object files for target " << this->GeneratorTarget->GetName() << "\n"
<< variableName << " =";
std::string object;
const char* lineContinue =
@ -1292,12 +1294,12 @@ cmMakefileTargetGenerator
// Write a make variable assignment that lists all external objects
// for the target.
variableNameExternal =
this->LocalGenerator->CreateMakeVariable(this->Target->GetName(),
this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(),
"_EXTERNAL_OBJECTS");
*this->BuildFileStream
<< "\n"
<< "# External object files for target "
<< this->Target->GetName() << "\n"
<< this->GeneratorTarget->GetName() << "\n"
<< variableNameExternal << " =";
for(std::vector<std::string>::const_iterator i =
this->ExternalObjects.begin();
@ -1512,7 +1514,7 @@ void cmMakefileTargetGenerator
// Add user-specified dependencies.
if(const char* linkDepends =
this->Target->GetProperty("LINK_DEPENDS"))
this->GeneratorTarget->GetProperty("LINK_DEPENDS"))
{
cmSystemTools::ExpandListArgument(linkDepends, depends);
}

11
Source/cmMakefileUtilityTargetGenerator.cxx
View File

@ -42,7 +42,8 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
this->CreateRuleFile();
*this->BuildFileStream
<< "# Utility rule file for " << this->Target->GetName() << ".\n\n";
<< "# Utility rule file for "
<< this->GeneratorTarget->GetName() << ".\n\n";
if(!this->NoRuleMessages)
{
@ -73,13 +74,13 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
(depends, this->Target->GetPostBuildCommands());
this->LocalGenerator->AppendCustomCommands
(commands, this->Target->GetPreBuildCommands(), this->Target);
(commands, this->Target->GetPreBuildCommands(), this->GeneratorTarget);
// Depend on all custom command outputs for sources
this->DriveCustomCommands(depends);
this->LocalGenerator->AppendCustomCommands
(commands, this->Target->GetPostBuildCommands(), this->Target);
(commands, this->Target->GetPostBuildCommands(), this->GeneratorTarget);
// Add dependencies on targets that must be built first.
this->AppendTargetDepends(depends);
@ -101,11 +102,11 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
// Write the rule.
this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
this->Target->GetName(),
this->GeneratorTarget->GetName(),
depends, commands, true);
// Write the main driver rule to build everything in this target.
this->WriteTargetDriverRule(this->Target->GetName(), false);
this->WriteTargetDriverRule(this->GeneratorTarget->GetName(), false);
// Write clean target
this->WriteTargetCleanRules();

21
Source/cmNinjaNormalTargetGenerator.cxx
View File

@ -77,7 +77,7 @@ void cmNinjaNormalTargetGenerator::Generate()
if (this->TargetLinkLanguage.empty()) {
cmSystemTools::Error("CMake can not determine linker language for "
"target: ",
this->GetTarget()->GetName().c_str());
this->GetGeneratorTarget()->GetName().c_str());
return;
}
@ -139,7 +139,7 @@ const char *cmNinjaNormalTargetGenerator::GetVisibleTypeName() const
case cmState::SHARED_LIBRARY:
return "shared library";
case cmState::MODULE_LIBRARY:
if (this->GetTarget()->IsCFBundleOnApple())
if (this->GetGeneratorTarget()->IsCFBundleOnApple())
return "CFBundle shared module";
else
return "shared module";
@ -158,7 +158,8 @@ cmNinjaNormalTargetGenerator
+ "_"
+ cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
+ "_LINKER__"
+ cmGlobalNinjaGenerator::EncodeRuleName(this->GetTarget()->GetName())
+ cmGlobalNinjaGenerator::EncodeRuleName(
this->GetGeneratorTarget()->GetName())
;
}
@ -177,7 +178,7 @@ cmNinjaNormalTargetGenerator
if (!this->GetGlobalGenerator()->HasRule(ruleName)) {
cmLocalGenerator::RuleVariables vars;
vars.RuleLauncher = "RULE_LAUNCH_LINK";
vars.CMTarget = this->GetTarget();
vars.CMTarget = this->GetGeneratorTarget();
vars.Language = this->TargetLinkLanguage.c_str();
std::string responseFlag;
@ -227,7 +228,7 @@ cmNinjaNormalTargetGenerator
std::ostringstream minorStream;
int major;
int minor;
this->GetTarget()->GetTargetVersion(major, minor);
this->GetGeneratorTarget()->GetTargetVersion(major, minor);
majorStream << major;
minorStream << minor;
targetVersionMajor = majorStream.str();
@ -280,7 +281,7 @@ cmNinjaNormalTargetGenerator
}
if (this->TargetNameOut != this->TargetNameReal &&
!this->GetTarget()->IsFrameworkOnApple()) {
!this->GetGeneratorTarget()->IsFrameworkOnApple()) {
std::string cmakeCommand =
this->GetLocalGenerator()->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
@ -411,7 +412,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
gt.GetFullPath(cfgName,
/*implib=*/true));
if (target.IsAppBundleOnApple())
if (gt.IsAppBundleOnApple())
{
// Create the app bundle
std::string outpath = gt.GetDirectory(cfgName);
@ -427,13 +428,13 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
targetOutputReal += this->TargetNameReal;
targetOutputReal = this->ConvertToNinjaPath(targetOutputReal);
}
else if (target.IsFrameworkOnApple())
else if (gt.IsFrameworkOnApple())
{
// Create the library framework.
this->OSXBundleGenerator->CreateFramework(this->TargetNameOut,
gt.GetDirectory(cfgName));
}
else if(target.IsCFBundleOnApple())
else if(gt.IsCFBundleOnApple())
{
// Create the core foundation bundle.
this->OSXBundleGenerator->CreateCFBundle(this->TargetNameOut,
@ -731,7 +732,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
&usedResponseFile);
this->WriteLinkRule(usedResponseFile);
if (targetOutput != targetOutputReal && !target.IsFrameworkOnApple())
if (targetOutput != targetOutputReal && !gt.IsFrameworkOnApple())
{
if (targetType == cmState::EXECUTABLE)
{

13
Source/cmNinjaTargetGenerator.cxx
View File

@ -92,7 +92,7 @@ std::string cmNinjaTargetGenerator::LanguageCompilerRule(
const std::string& lang) const
{
return lang + "_COMPILER__" +
cmGlobalNinjaGenerator::EncodeRuleName(this->Target->GetName());
cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName());
}
std::string
@ -218,7 +218,8 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
}
// Add user-specified dependencies.
if (const char* linkDepends = this->Target->GetProperty("LINK_DEPENDS"))
if (const char* linkDepends =
this->GeneratorTarget->GetProperty("LINK_DEPENDS"))
{
std::vector<std::string> linkDeps;
cmSystemTools::ExpandListArgument(linkDepends, linkDeps);
@ -271,7 +272,7 @@ cmNinjaTargetGenerator
std::string cmNinjaTargetGenerator::GetTargetName() const
{
return this->Target->GetName();
return this->GeneratorTarget->GetName();
}
@ -334,7 +335,7 @@ cmNinjaTargetGenerator
{
cmLocalGenerator::RuleVariables vars;
vars.RuleLauncher = "RULE_LAUNCH_COMPILE";
vars.CMTarget = this->GetTarget();
vars.CMTarget = this->GetGeneratorTarget();
vars.Language = lang.c_str();
vars.Source = "$in";
vars.Object = "$out";
@ -410,7 +411,7 @@ cmNinjaTargetGenerator
if (!compileCmds.empty() && (lang == "C" || lang == "CXX"))
{
std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
const char *iwyu = this->Target->GetProperty(iwyu_prop);
const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
if (iwyu && *iwyu)
{
std::string run_iwyu =
@ -427,7 +428,7 @@ cmNinjaTargetGenerator
if (!compileCmds.empty() && (lang == "C" || lang == "CXX"))
{
std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
const char *clauncher = this->Target->GetProperty(clauncher_prop);
const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
if (clauncher && *clauncher)
{
std::vector<std::string> launcher_cmd;

3
Source/cmNinjaUtilityTargetGenerator.cxx
View File

@ -90,7 +90,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
} else {
std::string command =
this->GetLocalGenerator()->BuildCommandLine(commands);
const char *echoStr = this->GetTarget()->GetProperty("EchoString");
const char *echoStr =
this->GetGeneratorTarget()->GetProperty("EchoString");
std::string desc;
if (echoStr)
desc = echoStr;

6
Source/cmOSXBundleGenerator.cxx
View File

@ -59,7 +59,7 @@ void cmOSXBundleGenerator::CreateAppBundle(const std::string& targetName,
plist += "/";
plist += this->GT->GetAppBundleDirectory(this->ConfigName, true);
plist += "/Info.plist";
this->LocalGenerator->GenerateAppleInfoPList(this->GT->Target,
this->LocalGenerator->GenerateAppleInfoPList(this->GT,
targetName,
plist.c_str());
this->Makefile->AddCMakeOutputFile(plist);
@ -90,7 +90,7 @@ void cmOSXBundleGenerator::CreateFramework(
std::string plist = newoutpath;
plist += "/Resources/Info.plist";
std::string name = cmSystemTools::GetFilenameName(targetName);
this->LocalGenerator->GenerateFrameworkInfoPList(this->GT->Target,
this->LocalGenerator->GenerateFrameworkInfoPList(this->GT,
name,
plist.c_str());
@ -182,7 +182,7 @@ void cmOSXBundleGenerator::CreateCFBundle(const std::string& targetName,
this->GT->GetCFBundleDirectory(this->ConfigName, true);
plist += "/Info.plist";
std::string name = cmSystemTools::GetFilenameName(targetName);
this->LocalGenerator->GenerateAppleInfoPList(this->GT->Target,
this->LocalGenerator->GenerateAppleInfoPList(this->GT,
name,
plist.c_str());
this->Makefile->AddCMakeOutputFile(plist);

23
Source/cmQtAutoGeneratorInitializer.cxx
View File

@ -120,7 +120,7 @@ static void GetCompileDefinitionsAndDirectories(
incs = cmJoin(includeDirs, ";");
std::set<std::string> defines;
localGen->AddCompileDefinitions(defines, target->Target, config, "CXX");
localGen->AddCompileDefinitions(defines, target, config, "CXX");
defs += cmJoin(defines, ";");
}
@ -132,6 +132,7 @@ static void SetupAutoMocTarget(cmGeneratorTarget const* target,
std::map<std::string, std::string> &configIncludes,
std::map<std::string, std::string> &configDefines)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile* makefile = target->Target->GetMakefile();
const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
@ -188,7 +189,8 @@ static void SetupAutoMocTarget(cmGeneratorTarget const* target,
const char *qtVersion = makefile->GetDefinition("_target_qt_version");
if (strcmp(qtVersion, "5") == 0)
{
cmTarget *qt5Moc = makefile->FindTargetToUse("Qt5::moc");
cmGeneratorTarget *qt5Moc =
lg->FindGeneratorTargetToUse("Qt5::moc");
if (!qt5Moc)
{
cmSystemTools::Error("Qt5::moc target not found ",
@ -200,7 +202,8 @@ static void SetupAutoMocTarget(cmGeneratorTarget const* target,
}
else if (strcmp(qtVersion, "4") == 0)
{
cmTarget *qt4Moc = makefile->FindTargetToUse("Qt4::moc");
cmGeneratorTarget *qt4Moc =
lg->FindGeneratorTargetToUse("Qt4::moc");
if (!qt4Moc)
{
cmSystemTools::Error("Qt4::moc target not found ",
@ -230,6 +233,7 @@ static void SetupAutoUicTarget(cmGeneratorTarget const* target,
std::vector<std::string> const& skipUic,
std::map<std::string, std::string> &configUicOptions)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile *makefile = target->Target->GetMakefile();
std::set<std::string> skipped;
@ -303,7 +307,8 @@ static void SetupAutoUicTarget(cmGeneratorTarget const* target,
std::string targetName = target->GetName();
if (strcmp(qtVersion, "5") == 0)
{
cmTarget *qt5Uic = makefile->FindTargetToUse("Qt5::uic");
cmGeneratorTarget *qt5Uic =
lg->FindGeneratorTargetToUse("Qt5::uic");
if (!qt5Uic)
{
// Project does not use Qt5Widgets, but has AUTOUIC ON anyway
@ -316,7 +321,8 @@ static void SetupAutoUicTarget(cmGeneratorTarget const* target,
}
else if (strcmp(qtVersion, "4") == 0)
{
cmTarget *qt4Uic = makefile->FindTargetToUse("Qt4::uic");
cmGeneratorTarget *qt4Uic =
lg->FindGeneratorTargetToUse("Qt4::uic");
if (!qt4Uic)
{
cmSystemTools::Error("Qt4::uic target not found ",
@ -335,6 +341,7 @@ static void SetupAutoUicTarget(cmGeneratorTarget const* target,
static std::string GetRccExecutable(cmGeneratorTarget const* target)
{
cmLocalGenerator* lg = target->GetLocalGenerator();
cmMakefile *makefile = target->Target->GetMakefile();
const char *qtVersion = makefile->GetDefinition("_target_qt_version");
if (!qtVersion)
@ -355,7 +362,8 @@ static std::string GetRccExecutable(cmGeneratorTarget const* target)
std::string targetName = target->GetName();
if (strcmp(qtVersion, "5") == 0)
{
cmTarget *qt5Rcc = makefile->FindTargetToUse("Qt5::rcc");
cmGeneratorTarget *qt5Rcc =
lg->FindGeneratorTargetToUse("Qt5::rcc");
if (!qt5Rcc)
{
cmSystemTools::Error("Qt5::rcc target not found ",
@ -366,7 +374,8 @@ static std::string GetRccExecutable(cmGeneratorTarget const* target)
}
else if (strcmp(qtVersion, "4") == 0)
{
cmTarget *qt4Rcc = makefile->FindTargetToUse("Qt4::rcc");
cmGeneratorTarget *qt4Rcc =
lg->FindGeneratorTargetToUse("Qt4::rcc");
if (!qt4Rcc)
{
cmSystemTools::Error("Qt4::rcc target not found ",

511
Source/cmTarget.cxx
View File

@ -344,17 +344,6 @@ bool cmTarget::IsExecutableWithExports() const
this->GetPropertyAsBool("ENABLE_EXPORTS"));
}
//----------------------------------------------------------------------------
bool cmTarget::IsLinkable() const
{
return (this->GetType() == cmState::STATIC_LIBRARY ||
this->GetType() == cmState::SHARED_LIBRARY ||
this->GetType() == cmState::MODULE_LIBRARY ||
this->GetType() == cmState::UNKNOWN_LIBRARY ||
this->GetType() == cmState::INTERFACE_LIBRARY ||
this->IsExecutableWithExports());
}
//----------------------------------------------------------------------------
bool cmTarget::HasImportLibrary() const
{
@ -379,21 +368,6 @@ bool cmTarget::IsAppBundleOnApple() const
this->GetPropertyAsBool("MACOSX_BUNDLE"));
}
//----------------------------------------------------------------------------
bool cmTarget::IsCFBundleOnApple() const
{
return (this->GetType() == cmState::MODULE_LIBRARY &&
this->Makefile->IsOn("APPLE") &&
this->GetPropertyAsBool("BUNDLE"));
}
//----------------------------------------------------------------------------
bool cmTarget::IsXCTestOnApple() const
{
return (this->IsCFBundleOnApple() &&
this->GetPropertyAsBool("XCTEST"));
}
//----------------------------------------------------------------------------
void cmTarget::AddTracedSources(std::vector<std::string> const& srcs)
{
@ -1316,7 +1290,6 @@ void cmTarget::SetProperty(const std::string& prop, const char* value)
else
{
this->Properties.SetProperty(prop, value);
this->MaybeInvalidatePropertyCache(prop);
}
}
@ -1409,30 +1382,9 @@ void cmTarget::AppendProperty(const std::string& prop, const char* value,
else
{
this->Properties.AppendProperty(prop, value, asString);
this->MaybeInvalidatePropertyCache(prop);
}
}
//----------------------------------------------------------------------------
std::string cmTarget::GetExportName() const
{
const char *exportName = this->GetProperty("EXPORT_NAME");
if (exportName && *exportName)
{
if (!cmGeneratorExpression::IsValidTargetName(exportName))
{
std::ostringstream e;
e << "EXPORT_NAME property \"" << exportName << "\" for \""
<< this->GetName() << "\": is not valid.";
cmSystemTools::Error(e.str().c_str());
return "";
}
return exportName;
}
return this->GetName();
}
//----------------------------------------------------------------------------
void cmTarget::AppendBuildInterfaceIncludes()
{
@ -1507,16 +1459,6 @@ void cmTarget::InsertCompileDefinition(std::string const& entry,
this->Internal->CompileDefinitionsBacktraces.push_back(bt);
}
//----------------------------------------------------------------------------
void cmTarget::MaybeInvalidatePropertyCache(const std::string& prop)
{
// Wipe out maps caching information affected by this property.
if(this->IsImported() && cmHasLiteralPrefix(prop, "IMPORTED"))
{
this->ImportInfoMap.clear();
}
}
//----------------------------------------------------------------------------
static void cmTargetCheckLINK_INTERFACE_LIBRARIES(
const std::string& prop, const char* value, cmMakefile* context,
@ -1627,53 +1569,6 @@ bool cmTarget::HaveWellDefinedOutputFiles() const
this->GetType() == cmState::EXECUTABLE;
}
//----------------------------------------------------------------------------
const char* cmTarget::ImportedGetLocation(const std::string& config) const
{
static std::string location;
assert(this->IsImported());
location = this->ImportedGetFullPath(config, false);
return location.c_str();
}
//----------------------------------------------------------------------------
void cmTarget::GetTargetVersion(int& major, int& minor) const
{
int patch;
this->GetTargetVersion(false, major, minor, patch);
}
//----------------------------------------------------------------------------
void cmTarget::GetTargetVersion(bool soversion,
int& major, int& minor, int& patch) const
{
// Set the default values.
major = 0;
minor = 0;
patch = 0;
assert(this->GetType() != cmState::INTERFACE_LIBRARY);
// Look for a VERSION or SOVERSION property.
const char* prop = soversion? "SOVERSION" : "VERSION";
if(const char* version = this->GetProperty(prop))
{
// Try to parse the version number and store the results that were
// successfully parsed.
int parsed_major;
int parsed_minor;
int parsed_patch;
switch(sscanf(version, "%d.%d.%d",
&parsed_major, &parsed_minor, &parsed_patch))
{
case 3: patch = parsed_patch; // no break!
case 2: minor = parsed_minor; // no break!
case 1: major = parsed_major; // no break!
default: break;
}
}
}
//----------------------------------------------------------------------------
bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const
{
@ -2100,21 +1995,75 @@ const char* cmTarget::GetPrefixVariableInternal(bool implib) const
//----------------------------------------------------------------------------
std::string
cmTarget::GetFullNameImported(const std::string& config, bool implib) const
cmTarget::ImportedGetFullPath(const std::string& config, bool pimplib) const
{
return cmSystemTools::GetFilenameName(
this->ImportedGetFullPath(config, implib));
}
assert(this->IsImported());
//----------------------------------------------------------------------------
std::string
cmTarget::ImportedGetFullPath(const std::string& config, bool implib) const
{
std::string result;
if(cmTarget::ImportInfo const* info = this->GetImportInfo(config))
// Lookup/compute/cache the import information for this
// configuration.
std::string config_upper;
if(!config.empty())
{
result = implib? info->ImportLibrary : info->Location;
config_upper = cmSystemTools::UpperCase(config);
}
else
{
config_upper = "NOCONFIG";
}
std::string result;
const char* loc = 0;
const char* imp = 0;
std::string suffix;
if(this->GetType() != cmState::INTERFACE_LIBRARY
&& this->GetMappedConfig(config_upper, &loc, &imp, suffix))
{
if (!pimplib)
{
if(loc)
{
result = loc;
}
else
{
std::string impProp = "IMPORTED_LOCATION";
impProp += suffix;
if(const char* config_location = this->GetProperty(impProp))
{
result = config_location;
}
else if(const char* location =
this->GetProperty("IMPORTED_LOCATION"))
{
result = location;
}
}
}
else
{
if(imp)
{
result = imp;
}
else if(this->GetType() == cmState::SHARED_LIBRARY ||
this->IsExecutableWithExports())
{
std::string impProp = "IMPORTED_IMPLIB";
impProp += suffix;
if(const char* config_implib = this->GetProperty(impProp))
{
result = config_implib;
}
else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB"))
{
result = implib;
}
}
}
}
if(result.empty())
{
result = this->GetName();
@ -2123,23 +2072,6 @@ cmTarget::ImportedGetFullPath(const std::string& config, bool implib) const
return result;
}
//----------------------------------------------------------------------------
void cmTarget::ComputeVersionedName(std::string& vName,
std::string const& prefix,
std::string const& base,
std::string const& suffix,
std::string const& name,
const char* version) const
{
vName = this->IsApple? (prefix+base) : name;
if(version)
{
vName += ".";
vName += version;
}
vName += this->IsApple? suffix : std::string();
}
//----------------------------------------------------------------------------
void cmTarget::SetPropertyDefault(const std::string& property,
const char* default_value)
@ -2203,92 +2135,6 @@ const char* cmTarget::GetExportMacro() const
}
}
//----------------------------------------------------------------------------
void
cmTarget::GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const
{
// At configure-time, this method can be called as part of getting the
// LOCATION property or to export() a file to be include()d. However
// there is no cmGeneratorTarget at configure-time, so search the SOURCES
// for TARGET_OBJECTS instead for backwards compatibility with OLD
// behavior of CMP0024 and CMP0026 only.
for(std::vector<std::string>::const_iterator
i = this->Internal->SourceEntries.begin();
i != this->Internal->SourceEntries.end(); ++i)
{
std::string const& entry = *i;
std::vector<std::string> files;
cmSystemTools::ExpandListArgument(entry, files);
for (std::vector<std::string>::const_iterator
li = files.begin(); li != files.end(); ++li)
{
if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
(*li)[li->size() - 1] == '>')
{
std::string objLibName = li->substr(17, li->size()-18);
if (cmGeneratorExpression::Find(objLibName) != std::string::npos)
{
continue;
}
cmTarget *objLib = this->Makefile->FindTargetToUse(objLibName);
if(objLib)
{
objlibs.push_back(objLib);
}
}
}
}
}
//----------------------------------------------------------------------------
cmTarget::ImportInfo const*
cmTarget::GetImportInfo(const std::string& config) const
{
// There is no imported information for non-imported targets.
if(!this->IsImported())
{
return 0;
}
// Lookup/compute/cache the import information for this
// configuration.
std::string config_upper;
if(!config.empty())
{
config_upper = cmSystemTools::UpperCase(config);
}
else
{
config_upper = "NOCONFIG";
}
ImportInfoMapType::const_iterator i =
this->ImportInfoMap.find(config_upper);
if(i == this->ImportInfoMap.end())
{
ImportInfo info;
this->ComputeImportInfo(config_upper, info);
ImportInfoMapType::value_type entry(config_upper, info);
i = this->ImportInfoMap.insert(entry).first;
}
if(this->GetType() == cmState::INTERFACE_LIBRARY)
{
return &i->second;
}
// If the location is empty then the target is not available for
// this configuration.
if(i->second.Location.empty() && i->second.ImportLibrary.empty())
{
return 0;
}
// Return the import information.
return &i->second;
}
bool cmTarget::GetMappedConfig(std::string const& desired_config,
const char** loc,
const char** imp,
@ -2420,233 +2266,6 @@ bool cmTarget::GetMappedConfig(std::string const& desired_config,
return true;
}
//----------------------------------------------------------------------------
void cmTarget::ComputeImportInfo(std::string const& desired_config,
ImportInfo& info) const
{
// This method finds information about an imported target from its
// properties. The "IMPORTED_" namespace is reserved for properties
// defined by the project exporting the target.
// Initialize members.
info.NoSOName = false;
const char* loc = 0;
const char* imp = 0;
std::string suffix;
if (!this->GetMappedConfig(desired_config, &loc, &imp, suffix))
{
return;
}
// Get the link interface.
{
std::string linkProp = "INTERFACE_LINK_LIBRARIES";
const char *propertyLibs = this->GetProperty(linkProp);
if (this->GetType() != cmState::INTERFACE_LIBRARY)
{
if(!propertyLibs)
{
linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES";
linkProp += suffix;
propertyLibs = this->GetProperty(linkProp);
}
if(!propertyLibs)
{
linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES";
propertyLibs = this->GetProperty(linkProp);
}
}
if(propertyLibs)
{
info.LibrariesProp = linkProp;
info.Libraries = propertyLibs;
}
}
if(this->GetType() == cmState::INTERFACE_LIBRARY)
{
return;
}
// A provided configuration has been chosen. Load the
// configuration's properties.
// Get the location.
if(loc)
{
info.Location = loc;
}
else
{
std::string impProp = "IMPORTED_LOCATION";
impProp += suffix;
if(const char* config_location = this->GetProperty(impProp))
{
info.Location = config_location;
}
else if(const char* location = this->GetProperty("IMPORTED_LOCATION"))
{
info.Location = location;
}
}
// Get the soname.
if(this->GetType() == cmState::SHARED_LIBRARY)
{
std::string soProp = "IMPORTED_SONAME";
soProp += suffix;
if(const char* config_soname = this->GetProperty(soProp))
{
info.SOName = config_soname;
}
else if(const char* soname = this->GetProperty("IMPORTED_SONAME"))
{
info.SOName = soname;
}
}
// Get the "no-soname" mark.
if(this->GetType() == cmState::SHARED_LIBRARY)
{
std::string soProp = "IMPORTED_NO_SONAME";
soProp += suffix;
if(const char* config_no_soname = this->GetProperty(soProp))
{
info.NoSOName = cmSystemTools::IsOn(config_no_soname);
}
else if(const char* no_soname = this->GetProperty("IMPORTED_NO_SONAME"))
{
info.NoSOName = cmSystemTools::IsOn(no_soname);
}
}
// Get the import library.
if(imp)
{
info.ImportLibrary = imp;
}
else if(this->GetType() == cmState::SHARED_LIBRARY ||
this->IsExecutableWithExports())
{
std::string impProp = "IMPORTED_IMPLIB";
impProp += suffix;
if(const char* config_implib = this->GetProperty(impProp))
{
info.ImportLibrary = config_implib;
}
else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB"))
{
info.ImportLibrary = implib;
}
}
// Get the link dependencies.
{
std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES";
linkProp += suffix;
if(const char* config_libs = this->GetProperty(linkProp))
{
info.SharedDeps = config_libs;
}
else if(const char* libs =
this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES"))
{
info.SharedDeps = libs;
}
}
// Get the link languages.
if(this->LinkLanguagePropagatesToDependents())
{
std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES";
linkProp += suffix;
if(const char* config_libs = this->GetProperty(linkProp))
{
info.Languages = config_libs;
}
else if(const char* libs =
this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES"))
{
info.Languages = libs;
}
}
// Get the cyclic repetition count.
if(this->GetType() == cmState::STATIC_LIBRARY)
{
std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY";
linkProp += suffix;
if(const char* config_reps = this->GetProperty(linkProp))
{
sscanf(config_reps, "%u", &info.Multiplicity);
}
else if(const char* reps =
this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY"))
{
sscanf(reps, "%u", &info.Multiplicity);
}
}
}
//----------------------------------------------------------------------------
std::string cmTarget::CheckCMP0004(std::string const& item) const
{
// Strip whitespace off the library names because we used to do this
// in case variables were expanded at generate time. We no longer
// do the expansion but users link to libraries like " ${VAR} ".
std::string lib = item;
std::string::size_type pos = lib.find_first_not_of(" \t\r\n");
if(pos != lib.npos)
{
lib = lib.substr(pos, lib.npos);
}
pos = lib.find_last_not_of(" \t\r\n");
if(pos != lib.npos)
{
lib = lib.substr(0, pos+1);
}
if(lib != item)
{
cmake* cm = this->Makefile->GetCMakeInstance();
switch(this->GetPolicyStatusCMP0004())
{
case cmPolicies::WARN:
{
std::ostringstream w;
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n"
<< "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace.";
cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
this->GetBacktrace());
}
case cmPolicies::OLD:
break;
case cmPolicies::NEW:
{
std::ostringstream e;
e << "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace. "
<< "This is now an error according to policy CMP0004.";
cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());
}
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
{
std::ostringstream e;
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n"
<< "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace.";
cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());
}
break;
}
}
return lib;
}
//----------------------------------------------------------------------------
cmTargetInternalPointer::cmTargetInternalPointer()
{

63
Source/cmTarget.h
View File

@ -96,7 +96,6 @@ public:
///! Set/Get the name of the target
const std::string& GetName() const {return this->Name;}
std::string GetExportName() const;
///! Set the cmMakefile that owns this target
void SetMakefile(cmMakefile *mf);
@ -213,25 +212,6 @@ public:
bool IsImported() const {return this->IsImportedTarget;}
void GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const;
/** Strip off leading and trailing whitespace from an item named in
the link dependencies of this target. */
std::string CheckCMP0004(std::string const& item) const;
const char* ImportedGetLocation(const std::string& config) const;
/** Get the target major and minor version numbers interpreted from
the VERSION property. Version 0 is returned if the property is
not set or cannot be parsed. */
void GetTargetVersion(int& major, int& minor) const;
/** Get the target major, minor, and patch version numbers
interpreted from the VERSION or SOVERSION property. Version 0
is returned if the property is not set or cannot be parsed. */
void
GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const;
// Get the properties
cmPropertyMap &GetProperties() const { return this->Properties; }
@ -248,9 +228,6 @@ public:
enabled. */
bool IsExecutableWithExports() const;
/** Return whether this target may be used to link another target. */
bool IsLinkable() const;
/** Return whether or not the target is for a DLL platform. */
bool IsDLLPlatform() const { return this->DLLPlatform; }
@ -258,12 +235,6 @@ public:
Apple. */
bool IsFrameworkOnApple() const;
/** Return whether this target is a CFBundle (plugin) on Apple. */
bool IsCFBundleOnApple() const;
/** Return whether this target is a XCTest on Apple. */
bool IsXCTestOnApple() const;
/** Return whether this target is an executable Bundle on Apple. */
bool IsAppBundleOnApple() const;
@ -385,9 +356,6 @@ private:
void SetPropertyDefault(const std::string& property,
const char* default_value);
std::string GetFullNameImported(const std::string& config,
bool implib) const;
std::string ImportedGetFullPath(const std::string& config,
bool implib) const;
@ -426,32 +394,8 @@ private:
bool LinkLibrariesForVS6Analyzed;
#endif
// Cache import information from properties for each configuration.
struct ImportInfo
{
ImportInfo(): NoSOName(false), Multiplicity(0) {}
bool NoSOName;
int Multiplicity;
std::string Location;
std::string SOName;
std::string ImportLibrary;
std::string Languages;
std::string Libraries;
std::string LibrariesProp;
std::string SharedDeps;
};
typedef std::map<std::string, ImportInfo> ImportInfoMapType;
mutable ImportInfoMapType ImportInfoMap;
ImportInfo const* GetImportInfo(const std::string& config) const;
void ComputeImportInfo(std::string const& desired_config,
ImportInfo& info) const;
std::string ProcessSourceItemCMP0049(const std::string& s);
void MaybeInvalidatePropertyCache(const std::string& prop);
/** Return whether or not the target has a DLL import library. */
bool HasImportLibrary() const;
@ -460,13 +404,6 @@ private:
friend class cmGeneratorTarget;
friend class cmTargetTraceDependencies;
void ComputeVersionedName(std::string& vName,
std::string const& prefix,
std::string const& base,
std::string const& suffix,
std::string const& name,
const char* version) const;
cmListFileBacktrace Backtrace;
};

5
Source/cmTargetExport.h
View File

@ -14,7 +14,7 @@
#include "cmStandardIncludes.h"
class cmTarget;
class cmGeneratorTarget;
class cmInstallTargetGenerator;
class cmInstallFilesGenerator;
@ -25,7 +25,8 @@ class cmInstallFilesGenerator;
class cmTargetExport
{
public:
cmTarget* Target; ///< The target
std::string TargetName;
cmGeneratorTarget* Target;
///@name Generators
///@{

132
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -178,7 +178,7 @@ cmVisualStudio10TargetGenerator(cmTarget* target,
this->LocalGenerator =
(cmLocalVisualStudio7Generator*)
this->GeneratorTarget->GetLocalGenerator();
this->Name = this->Target->GetName();
this->Name = this->GeneratorTarget->GetName();
this->GUID = this->GlobalGenerator->GetGUID(this->Name.c_str());
this->Platform = gg->GetPlatformName();
this->NsightTegra = gg->IsNsightTegra();
@ -270,7 +270,7 @@ void cmVisualStudio10TargetGenerator::Generate()
{
// do not generate external ms projects
if(this->GeneratorTarget->GetType() == cmState::INTERFACE_LIBRARY
|| this->Target->GetProperty("EXTERNAL_MSPROJECT"))
|| this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT"))
{
return;
}
@ -368,7 +368,7 @@ void cmVisualStudio10TargetGenerator::Generate()
}
const char* vsProjectTypes =
this->Target->GetProperty("VS_GLOBAL_PROJECT_TYPES");
this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES");
if(vsProjectTypes)
{
this->WriteString("<ProjectTypes>", 2);
@ -376,9 +376,12 @@ void cmVisualStudio10TargetGenerator::Generate()
"</ProjectTypes>\n";
}
const char* vsProjectName = this->Target->GetProperty("VS_SCC_PROJECTNAME");
const char* vsLocalPath = this->Target->GetProperty("VS_SCC_LOCALPATH");
const char* vsProvider = this->Target->GetProperty("VS_SCC_PROVIDER");
const char* vsProjectName =
this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME");
const char* vsLocalPath =
this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH");
const char* vsProvider =
this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER");
if( vsProjectName && vsLocalPath && vsProvider )
{
@ -392,7 +395,8 @@ void cmVisualStudio10TargetGenerator::Generate()
(*this->BuildFileStream) << cmVS10EscapeXML(vsProvider) <<
"</SccProvider>\n";
const char* vsAuxPath = this->Target->GetProperty("VS_SCC_AUXPATH");
const char* vsAuxPath =
this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH");
if( vsAuxPath )
{
this->WriteString("<SccAuxPath>", 2);
@ -401,13 +405,13 @@ void cmVisualStudio10TargetGenerator::Generate()
}
}
if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT"))
if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT"))
{
this->WriteString("<WinMDAssembly>true</WinMDAssembly>\n", 2);
}
const char* vsGlobalKeyword =
this->Target->GetProperty("VS_GLOBAL_KEYWORD");
this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD");
if(!vsGlobalKeyword)
{
this->WriteString("<Keyword>Win32Proj</Keyword>\n", 2);
@ -420,7 +424,7 @@ void cmVisualStudio10TargetGenerator::Generate()
}
const char* vsGlobalRootNamespace =
this->Target->GetProperty("VS_GLOBAL_ROOTNAMESPACE");
this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE");
if(vsGlobalRootNamespace)
{
this->WriteString("<RootNamespace>", 2);
@ -431,14 +435,14 @@ void cmVisualStudio10TargetGenerator::Generate()
this->WriteString("<Platform>", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(this->Platform)
<< "</Platform>\n";
const char* projLabel = this->Target->GetProperty("PROJECT_LABEL");
const char* projLabel = this->GeneratorTarget->GetProperty("PROJECT_LABEL");
if(!projLabel)
{
projLabel = this->Name.c_str();
}
this->WriteString("<ProjectName>", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(projLabel) << "</ProjectName>\n";
if(const char* targetFrameworkVersion = this->Target->GetProperty(
if(const char* targetFrameworkVersion = this->GeneratorTarget->GetProperty(
"VS_DOTNET_TARGET_FRAMEWORK_VERSION"))
{
this->WriteString("<TargetFrameworkVersion>", 2);
@ -497,7 +501,7 @@ void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
{
std::vector<std::string> references;
if(const char* vsDotNetReferences =
this->Target->GetProperty("VS_DOTNET_REFERENCES"))
this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES"))
{
cmSystemTools::ExpandListArgument(vsDotNetReferences, references);
}
@ -543,7 +547,7 @@ void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
i != this->Configurations.end(); ++i)
{
this->WritePlatformConfigTag("LogicalName", i->c_str(), 3);
if(this->Target->GetProperty("VS_GLOBAL_ROOTNAMESPACE"))
if(this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE"))
{
(*this->BuildFileStream ) << "$(RootNamespace).";
}
@ -610,7 +614,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTReferences()
{
std::vector<std::string> references;
if(const char* vsWinRTReferences =
this->Target->GetProperty("VS_WINRT_REFERENCES"))
this->GeneratorTarget->GetProperty("VS_WINRT_REFERENCES"))
{
cmSystemTools::ExpandListArgument(vsWinRTReferences, references);
}
@ -679,7 +683,7 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
break;
case cmState::EXECUTABLE:
if(this->NsightTegra &&
!this->Target->GetPropertyAsBool("ANDROID_GUI"))
!this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI"))
{
// Android executables are .so too.
configType += "DynamicLibrary";
@ -746,10 +750,10 @@ void cmVisualStudio10TargetGenerator
if((this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY &&
this->ClOptions[config]->UsingUnicode()) ||
this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
this->GlobalGenerator->TargetsWindowsPhone() ||
this->GlobalGenerator->TargetsWindowsStore() ||
this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
{
this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2);
}
@ -769,8 +773,8 @@ void cmVisualStudio10TargetGenerator
pts += "</PlatformToolset>\n";
this->WriteString(pts.c_str(), 2);
}
if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
this->Target->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
{
this->WriteString("<WindowsAppContainer>true"
"</WindowsAppContainer>\n", 2);
@ -788,27 +792,29 @@ void cmVisualStudio10TargetGenerator
ntv += toolset? toolset : "Default";
ntv += "</NdkToolchainVersion>\n";
this->WriteString(ntv.c_str(), 2);
if(const char* minApi = this->Target->GetProperty("ANDROID_API_MIN"))
if(const char* minApi =
this->GeneratorTarget->GetProperty("ANDROID_API_MIN"))
{
this->WriteString("<AndroidMinAPI>", 2);
(*this->BuildFileStream ) <<
"android-" << cmVS10EscapeXML(minApi) << "</AndroidMinAPI>\n";
}
if(const char* api = this->Target->GetProperty("ANDROID_API"))
if(const char* api = this->GeneratorTarget->GetProperty("ANDROID_API"))
{
this->WriteString("<AndroidTargetAPI>", 2);
(*this->BuildFileStream ) <<
"android-" << cmVS10EscapeXML(api) << "</AndroidTargetAPI>\n";
}
if(const char* cpuArch = this->Target->GetProperty("ANDROID_ARCH"))
if(const char* cpuArch = this->GeneratorTarget->GetProperty("ANDROID_ARCH"))
{
this->WriteString("<AndroidArch>", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) <<
"</AndroidArch>\n";
}
if(const char* stlType = this->Target->GetProperty("ANDROID_STL_TYPE"))
if(const char* stlType =
this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE"))
{
this->WriteString("<AndroidStlType>", 2);
(*this->BuildFileStream) << cmVS10EscapeXML(stlType) <<
@ -1775,7 +1781,7 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
if(ttype == cmState::OBJECT_LIBRARY)
{
outDir = intermediateDir;
targetNameFull = this->Target->GetName();
targetNameFull = this->GeneratorTarget->GetName();
targetNameFull += ".lib";
}
else
@ -1926,7 +1932,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
{
clOptions.AddFlag("CompileAs", "CompileAsCpp");
}
this->LocalGenerator->AddCompileOptions(flags, this->Target,
this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
linkLanguage, configName.c_str());
// Get preprocessor definitions for this directory.
@ -1963,7 +1969,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
if (this->MSTools)
{
// If we have the VS_WINRT_COMPONENT set then force Compile as WinRT.
if (this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT"))
if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT"))
{
clOptions.AddFlag("CompileAsWinRT", "true");
// For WinRT components, add the _WINRT_DLL define to produce a lib
@ -2012,7 +2018,7 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
if(this->NsightTegra)
{
if(const char* processMax =
this->Target->GetProperty("ANDROID_PROCESS_MAX"))
this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX"))
{
this->WriteString("<ProcessMax>", 3);
*this->BuildFileStream << cmVS10EscapeXML(processMax) <<
@ -2183,7 +2189,7 @@ cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config)
}
std::string libflags;
this->LocalGenerator->GetStaticLibraryFlags(libflags,
cmSystemTools::UpperCase(config), this->Target);
cmSystemTools::UpperCase(config), this->GeneratorTarget);
if(!libflags.empty())
{
this->WriteString("<Lib>\n", 2);
@ -2270,18 +2276,18 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
cmVS10EscapeXML(antBuildPath) << "</AntBuildPath>\n";
}
if (this->Target->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP"))
if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP"))
{
this->WriteString("<SkipAntStep>true</SkipAntStep>\n", 3);
}
if (this->Target->GetPropertyAsBool("ANDROID_PROGUARD"))
if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD"))
{
this->WriteString("<EnableProGuard>true</EnableProGuard>\n", 3);
}
if (const char* proGuardConfigLocation =
this->Target->GetProperty("ANDROID_PROGUARD_CONFIG_PATH"))
this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH"))
{
this->WriteString("<ProGuardConfigLocation>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation) <<
@ -2289,7 +2295,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* securePropertiesLocation =
this->Target->GetProperty("ANDROID_SECURE_PROPS_PATH"))
this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH"))
{
this->WriteString("<SecurePropertiesLocation>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation) <<
@ -2297,7 +2303,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* nativeLibDirectoriesExpression =
this->Target->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES"))
this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES"))
{
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
@ -2310,7 +2316,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* nativeLibDependenciesExpression =
this->Target->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES"))
this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES"))
{
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
@ -2323,7 +2329,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* javaSourceDir =
this->Target->GetProperty("ANDROID_JAVA_SOURCE_DIR"))
this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR"))
{
this->WriteString("<JavaSourceDir>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir) <<
@ -2331,7 +2337,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* jarDirectoriesExpression =
this->Target->GetProperty("ANDROID_JAR_DIRECTORIES"))
this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES"))
{
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
@ -2344,7 +2350,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* jarDeps =
this->Target->GetProperty("ANDROID_JAR_DEPENDENCIES"))
this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES"))
{
this->WriteString("<JarDependencies>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(jarDeps) <<
@ -2352,7 +2358,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* assetsDirectories =
this->Target->GetProperty("ANDROID_ASSETS_DIRECTORIES"))
this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES"))
{
this->WriteString("<AssetsDirectories>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories) <<
@ -2368,7 +2374,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
}
if (const char* antAdditionalOptions =
this->Target->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS"))
this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS"))
{
this->WriteString("<AdditionalOptions>", 3);
(*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions) <<
@ -2439,7 +2445,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
flags += " ";
flags += this->
Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str());
const char* targetLinkFlags = this->Target->GetProperty("LINK_FLAGS");
const char* targetLinkFlags =
this->GeneratorTarget->GetProperty("LINK_FLAGS");
if(targetLinkFlags)
{
flags += " ";
@ -2447,7 +2454,8 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
}
std::string flagsProp = "LINK_FLAGS_";
flagsProp += CONFIG;
if(const char* flagsConfig = this->Target->GetProperty(flagsProp.c_str()))
if(const char* flagsConfig =
this->GeneratorTarget->GetProperty(flagsProp.c_str()))
{
flags += " ";
flags += flagsConfig;
@ -2525,7 +2533,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
{
linkOptions.AddFlag("Version", "");
if ( this->Target->GetPropertyAsBool("WIN32_EXECUTABLE") )
if ( this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE") )
{
if (this->GlobalGenerator->TargetsWindowsCE())
{
@ -2597,7 +2605,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
// A Windows Runtime component uses internal .NET metadata,
// so does not have an import library.
if(this->Target->GetPropertyAsBool("VS_WINRT_COMPONENT") &&
if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") &&
this->GeneratorTarget->GetType() != cmState::EXECUTABLE)
{
linkOptions.AddFlag("GenerateWindowsMetadata", "true");
@ -2639,7 +2647,7 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
{
if (this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)exportall.def");
}
@ -2783,7 +2791,7 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
this->WriteManifestOptions(*i);
if(this->NsightTegra &&
this->GeneratorTarget->GetType() == cmState::EXECUTABLE &&
this->Target->GetPropertyAsBool("ANDROID_GUI"))
this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI"))
{
this->WriteAntBuildOptions(*i);
}
@ -2798,7 +2806,7 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName)
if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
{
if (this->Target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
addedPrelink = true;
std::vector<cmCustomCommand> commands =
@ -2911,14 +2919,14 @@ void cmVisualStudio10TargetGenerator::WritePlatformExtensions()
cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0"))
{
const char* desktopExtensionsVersion =
this->Target->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
if (desktopExtensionsVersion)
{
this->WriteSinglePlatformExtension("WindowsDesktop",
desktopExtensionsVersion);
}
const char* mobileExtensionsVersion =
this->Target->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
if (mobileExtensionsVersion)
{
this->WriteSinglePlatformExtension("WindowsMobile",
@ -2958,11 +2966,11 @@ void cmVisualStudio10TargetGenerator::WriteSDKReferences()
cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0"))
{
const char* desktopExtensionsVersion =
this->Target->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
const char* mobileExtensionsVersion =
this->Target->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
const char* iotExtensionsVersion =
this->Target->GetProperty("VS_IOT_EXTENSIONS_VERSION");
this->GeneratorTarget->GetProperty("VS_IOT_EXTENSIONS_VERSION");
if(desktopExtensionsVersion || mobileExtensionsVersion ||
iotExtensionsVersion)
@ -3194,7 +3202,8 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
"</WindowsTargetPlatformVersion>\n";
}
const char* targetPlatformMinVersion =
this->Target->GetProperty("VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION");
this->GeneratorTarget
->GetProperty("VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION");
if(targetPlatformMinVersion)
{
this->WriteString("<WindowsTargetPlatformMinVersion>", 2);
@ -3213,7 +3222,7 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
}
// Added IoT Startup Task support
if(this->Target->GetPropertyAsBool("VS_IOT_STARTUP_TASK"))
if(this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK"))
{
this->WriteString("<ContainsStartupTask>true</ContainsStartupTask>\n", 2);
}
@ -3325,7 +3334,8 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
@ -3408,7 +3418,8 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81()
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
@ -3468,7 +3479,8 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80()
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
@ -3520,7 +3532,8 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81()
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);
@ -3577,7 +3590,8 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
std::string targetNameXML =
cmVS10EscapeXML(this->GeneratorTarget->GetName());
cmGeneratedFileStream fout(manifestFile.c_str());
fout.SetCopyIfDifferent(true);