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

Merge topic 'use-generator-target' 

c099e00f Access policy status from cmGeneratorTarget at generate time.
d74bca5a cmGeneratorTarget: Copy the policy map from the cmTarget.
c6e86955 cmTarget: Remove unused NameResolvesToFramework.
18046bd5 cmCommonTargetGenerator: Use NameResolvesToFramework without cmTarget.
91411641 Move ComputeLinkType out of cmTarget.
6d94078e cmGeneratorTarget: Move IsDLLPlatform from cmTarget.
3ebc6285 cmGeneratorTarget: Move HaveWellDefinedOutputFiles from cmTarget.
311018e5 cmGeneratorTarget: Move GetExportMacro from cmTarget.
215cd21a cmGeneratorTarget: Provide direct access to the backtrace.
1df8bd3a cmGlobalGenerator: Port IsRootOnlyTarget to cmGeneratorTarget.
83703bda cmGeneratorTarget: Copy IsExecutableWithExports from cmTarget.
This commit is contained in:
Brad King 2015-10-21 09:17:01 -04:00 committed by CMake Topic Stage
parent d31d92bf1d c099e00fc0
commit 9206120e30
26 changed files with 221 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Source/cmCommonTargetGenerator.cxx
View File

@ -265,7 +265,7 @@ std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l)
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
{
if(this->Target->NameResolvesToFramework(*i))
if(this->GlobalGenerator->NameResolvesToFramework(*i))
{
std::string frameworkDir = *i;
frameworkDir += "/../";
@ -349,7 +349,8 @@ std::string cmCommonTargetGenerator::GetDefines(const std::string &l)
std::set<std::string> defines;
const char *lang = l.c_str();
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = this->Target->GetExportMacro())
if(const char* exportMacro =
this->GeneratorTarget->GetExportMacro())
{
this->LocalGenerator->AppendDefines(defines, exportMacro);
}

4
Source/cmComputeLinkDepends.cxx
View File

@ -185,7 +185,9 @@ cmComputeLinkDepends
// The configuration being linked.
this->HasConfig = !config.empty();
this->Config = (this->HasConfig)? config : std::string();
this->LinkType = this->Target->Target->ComputeLinkType(this->Config);
std::vector<std::string> debugConfigs =
this->Makefile->GetCMakeInstance()->GetDebugConfigs();
this->LinkType = CMP0003_ComputeLinkType(this->Config, debugConfigs);
// Enable debug mode if requested.
this->DebugMode = this->Makefile->IsOn("CMAKE_LINK_DEPENDS_DEBUG_MODE");

22
Source/cmComputeLinkInformation.cxx
View File

@ -407,7 +407,7 @@ cmComputeLinkInformation
// order to support such projects we need to add the directories
// containing libraries linked with a full path to the -L path.
this->OldLinkDirMode =
this->Target->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW;
this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW;
if(this->OldLinkDirMode)
{
// Construct a mask to not bother with this behavior for link
@ -571,7 +571,7 @@ bool cmComputeLinkInformation::Compute()
"name."
;
this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}
return true;
@ -635,7 +635,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
{
// Compute the proper name to use to link this library.
const std::string& config = this->Config;
bool impexe = (tgt && tgt->Target->IsExecutableWithExports());
bool impexe = (tgt && tgt->IsExecutableWithExports());
if(impexe && !this->UseImportLibrary && !this->LoaderFlag)
{
// Skip linking to executables on platforms with no import
@ -1140,7 +1140,7 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item)
// Full path libraries should specify a valid library file name.
// See documentation of CMP0008.
std::string generator = this->GlobalGenerator->GetName();
if(this->Target->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
if(this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
(generator.find("Visual Studio") != generator.npos ||
generator.find("Xcode") != generator.npos))
{
@ -1221,7 +1221,7 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
}
// Check the policy for whether we should use the approach below.
switch (this->Target->Target->GetPolicyStatusCMP0060())
switch (this->Target->GetPolicyStatusCMP0060())
{
case cmPolicies::WARN:
if (this->CMP0060Warn)
@ -1531,7 +1531,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
this->OrderLinkerSearchPath->AddLinkLibrary(item);
// Produce any needed message.
switch(this->Target->Target->GetPolicyStatusCMP0008())
switch(this->Target->GetPolicyStatusCMP0008())
{
case cmPolicies::WARN:
{
@ -1548,7 +1548,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
<< " " << item << "\n"
<< "which is a full-path but not a valid library file name.";
this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}
}
case cmPolicies::OLD:
@ -1566,7 +1566,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
<< " " << item << "\n"
<< "which is a full-path but not a valid library file name.";
this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}
break;
}
@ -1583,7 +1583,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
}
// Enforce policy constraints.
switch(this->Target->Target->GetPolicyStatusCMP0003())
switch(this->Target->GetPolicyStatusCMP0003())
{
case cmPolicies::WARN:
if(!this->CMakeInstance->GetState()
@ -1594,7 +1594,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
std::ostringstream w;
this->PrintLinkPolicyDiagnosis(w);
this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}
case cmPolicies::OLD:
// OLD behavior is to add the paths containing libraries with
@ -1610,7 +1610,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n";
this->PrintLinkPolicyDiagnosis(e);
this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
return false;
}
}

8
Source/cmComputeTargetDepends.cxx
View File

@ -245,7 +245,7 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
->IssueMessage(cmake::FATAL_ERROR,
"Only executables and non-OBJECT libraries may "
"reference target objects.",
depender->Target->GetBacktrace());
depender->GetBacktrace());
return;
}
const_cast<cmGeneratorTarget*>(depender)->Target->AddUtility(objLib);
@ -325,7 +325,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
// within the project.
if(dependee &&
dependee->GetType() == cmState::EXECUTABLE &&
!dependee->Target->IsExecutableWithExports())
!dependee->IsExecutableWithExports())
{
dependee = 0;
}
@ -362,7 +362,7 @@ void cmComputeTargetDepends::AddTargetDepend(
cmake::MessageType messageType = cmake::AUTHOR_WARNING;
bool issueMessage = false;
std::ostringstream e;
switch(depender->Target->GetPolicyStatusCMP0046())
switch(depender->GetPolicyStatusCMP0046())
{
case cmPolicies::WARN:
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0046) << "\n";
@ -401,7 +401,7 @@ void cmComputeTargetDepends::AddTargetDepend(
// within the project.
if(linking && dependee &&
dependee->GetType() == cmState::EXECUTABLE &&
!dependee->Target->IsExecutableWithExports())
!dependee->IsExecutableWithExports())
{
dependee = 0;
}

6
Source/cmExportBuildFileGenerator.cxx
View File

@ -107,8 +107,8 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
gte, properties);
const bool newCMP0022Behavior =
gte->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& gte->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
gte->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
if (newCMP0022Behavior)
{
this->PopulateInterfaceLinkLibrariesProperty(gte,
@ -220,7 +220,7 @@ cmExportBuildFileGenerator
// Add the import library for windows DLLs.
if(dll_platform &&
(target->GetType() == cmState::SHARED_LIBRARY ||
target->Target->IsExecutableWithExports()) &&
target->IsExecutableWithExports()) &&
mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"))
{
std::string prop = "IMPORTED_IMPLIB";

12
Source/cmExportFileGenerator.cxx
View File

@ -270,7 +270,7 @@ static bool checkInterfaceDirs(const std::string &prepro,
{
if (prop == "INTERFACE_INCLUDE_DIRECTORIES")
{
switch (target->Target->GetPolicyStatusCMP0041())
switch (target->GetPolicyStatusCMP0041())
{
case cmPolicies::WARN:
messageType = cmake::WARNING;
@ -317,7 +317,7 @@ static bool checkInterfaceDirs(const std::string &prepro,
{
if (!shouldContinue)
{
switch(target->Target->GetPolicyStatusCMP0052())
switch(target->GetPolicyStatusCMP0052())
{
case cmPolicies::WARN:
{
@ -830,10 +830,8 @@ cmExportFileGenerator
}
const bool newCMP0022Behavior =
target->Target
->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& target->Target
->GetPolicyStatusCMP0022() != cmPolicies::OLD;
target->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
if(newCMP0022Behavior && !this->ExportOld)
{
@ -1075,7 +1073,7 @@ cmExportFileGenerator
}
// Mark the imported executable if it has exports.
if(target->Target->IsExecutableWithExports())
if(target->IsExecutableWithExports())
{
os << "set_property(TARGET " << targetName
<< " PROPERTY ENABLE_EXPORTS 1)\n";

4
Source/cmExportInstallFileGenerator.cxx
View File

@ -169,8 +169,8 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
properties, missingTargets);
const bool newCMP0022Behavior =
gt->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& gt->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
gt->GetPolicyStatusCMP0022() != cmPolicies::WARN
&& gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
if (newCMP0022Behavior)
{
if (this->PopulateInterfaceLinkLibrariesProperty(gt,

2
Source/cmExtraSublimeTextGenerator.cxx
View File

@ -427,7 +427,7 @@ ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg,
const std::string& config = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = target->Target->GetExportMacro())
if(const char* exportMacro = target->GetExportMacro())
{
lg->AppendDefines(defines, exportMacro);
}

2
Source/cmGeneratorExpressionNode.cxx
View File

@ -1579,7 +1579,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactSonameTag>
const GeneratorExpressionContent *content)
{
// The target soname file (.so.1).
if(target->Target->IsDLLPlatform())
if(target->IsDLLPlatform())
{
::reportError(context, content->GetOriginalExpression(),
"TARGET_SONAME_FILE is not allowed "

136
Source/cmGeneratorTarget.cxx
View File

@ -62,7 +62,7 @@ void reportBadObjLib(std::vector<cmSourceFile*> const& badObjLib,
e << "but may contain only sources that compile, header files, and "
"other files that would not affect linking of a normal library.";
cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
target->Target->GetBacktrace());
target->GetBacktrace());
}
}
@ -304,6 +304,12 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg)
t->GetSourceEntries(),
t->GetSourceBacktraces(),
this->SourceEntries, true);
this->DLLPlatform = (this->Makefile->IsOn("WIN32") ||
this->Makefile->IsOn("CYGWIN") ||
this->Makefile->IsOn("MINGW"));
this->PolicyMap = t->PolicyMap;
}
cmGeneratorTarget::~cmGeneratorTarget()
@ -366,7 +372,7 @@ const char* cmGeneratorTarget::GetOutputTargetType(bool implib) const
switch(this->GetType())
{
case cmState::SHARED_LIBRARY:
if(this->Target->IsDLLPlatform())
if(this->IsDLLPlatform())
{
if(implib)
{
@ -483,7 +489,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config,
->IssueMessage(
cmake::FATAL_ERROR,
"Target '" + this->GetName() + "' OUTPUT_NAME depends on itself.",
this->Target->GetBacktrace());
this->GetBacktrace());
}
return i->second;
}
@ -1007,7 +1013,7 @@ static bool processSources(cmGeneratorTarget const* tgt,
{
cmake* cm = tgt->GetLocalGenerator()->GetCMakeInstance();
cm->IssueMessage(cmake::FATAL_ERROR, e,
tgt->Target->GetBacktrace());
tgt->GetBacktrace());
}
return contextDependent;
}
@ -1471,7 +1477,7 @@ bool cmGeneratorTarget::HasMacOSXRpathInstallNameDir(
w << " corrupt.";
cmake* cm = this->LocalGenerator->GetCMakeInstance();
cm->IssueMessage(cmake::FATAL_ERROR, w.str(),
this->Target->GetBacktrace());
this->GetBacktrace());
}
return true;
@ -1492,7 +1498,7 @@ bool cmGeneratorTarget::MacOSXRpathInstallNameDirDefault() const
return this->GetPropertyAsBool("MACOSX_RPATH");
}
cmPolicies::PolicyStatus cmp0042 = this->Target->GetPolicyStatusCMP0042();
cmPolicies::PolicyStatus cmp0042 = this->GetPolicyStatusCMP0042();
if(cmp0042 == cmPolicies::WARN)
{
@ -1703,6 +1709,47 @@ std::string cmGeneratorTarget::GetInstallNameDirForInstallTree() const
}
}
cmListFileBacktrace cmGeneratorTarget::GetBacktrace() const
{
return this->Target->GetBacktrace();
}
//----------------------------------------------------------------------------
bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const
{
return
this->GetType() == cmState::STATIC_LIBRARY ||
this->GetType() == cmState::SHARED_LIBRARY ||
this->GetType() == cmState::MODULE_LIBRARY ||
this->GetType() == cmState::EXECUTABLE;
}
//----------------------------------------------------------------------------
const char* cmGeneratorTarget::GetExportMacro() const
{
// Define the symbol for targets that export symbols.
if(this->GetType() == cmState::SHARED_LIBRARY ||
this->GetType() == cmState::MODULE_LIBRARY ||
this->IsExecutableWithExports())
{
if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL"))
{
this->ExportMacro = custom_export_name;
}
else
{
std::string in = this->GetName();
in += "_EXPORTS";
this->ExportMacro = cmSystemTools::MakeCidentifier(in);
}
return this->ExportMacro.c_str();
}
else
{
return 0;
}
}
//----------------------------------------------------------------------------
class cmTargetCollectLinkLanguages
{
@ -1749,7 +1796,7 @@ public:
"call is missing for an IMPORTED target, or an ALIAS target is "
"missing?";
this->Target->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
messageType, e.str(), this->Target->Target->GetBacktrace());
messageType, e.str(), this->Target->GetBacktrace());
}
}
return;
@ -1846,7 +1893,7 @@ public:
e << "Set the LINKER_LANGUAGE property for this target.";
cmake* cm = this->Target->GetLocalGenerator()->GetCMakeInstance();
cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}
return *this->Preferred.begin();
}
@ -2017,6 +2064,11 @@ cmGeneratorTarget::GetModuleDefinitionFile(const std::string& config) const
return data;
}
bool cmGeneratorTarget::IsDLLPlatform() const
{
return this->DLLPlatform;
}
//----------------------------------------------------------------------------
void
cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs,
@ -2583,7 +2635,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
cmake::MessageType messageType = cmake::FATAL_ERROR;
if (checkCMP0027)
{
switch(tgt->Target->GetPolicyStatusCMP0027())
switch(tgt->GetPolicyStatusCMP0027())
{
case cmPolicies::WARN:
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0027) << "\n";
@ -2622,7 +2674,7 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
}
else
{
switch(tgt->Target->GetPolicyStatusCMP0021())
switch(tgt->GetPolicyStatusCMP0021())
{
case cmPolicies::WARN:
{
@ -4571,7 +4623,7 @@ cmGeneratorTarget::GetLinkInterface(const std::string& config,
// Link interfaces are not supported for executables that do not
// export symbols.
if(this->GetType() == cmState::EXECUTABLE &&
!this->Target->IsExecutableWithExports())
!this->IsExecutableWithExports())
{
return 0;
}
@ -4654,8 +4706,8 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config,
}
}
}
else if (this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN
|| this->Target->GetPolicyStatusCMP0022() == cmPolicies::OLD)
else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN
|| this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
{
// The link implementation is the default link interface.
cmLinkImplementationLibraries const*
@ -4720,7 +4772,7 @@ cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config,
// Link interfaces are not supported for executables that do not
// export symbols.
if(this->GetType() == cmState::EXECUTABLE &&
!this->Target->IsExecutableWithExports())
!this->IsExecutableWithExports())
{
return 0;
}
@ -4788,7 +4840,7 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo(
}
// Only libraries and executables have well-defined output files.
if(!this->Target->HaveWellDefinedOutputFiles())
if(!this->HaveWellDefinedOutputFiles())
{
std::string msg = "cmGeneratorTarget::GetOutputInfo called for ";
msg += this->GetName();
@ -4831,7 +4883,7 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo(
this->LocalGenerator->GetCMakeInstance()->IssueMessage(
cmake::FATAL_ERROR,
"Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.",
this->Target->GetBacktrace());
this->GetBacktrace());
return 0;
}
return &i->second;
@ -5023,15 +5075,15 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
// libraries and executables that export symbols.
const char* explicitLibraries = 0;
std::string linkIfaceProp;
if(this->Target->GetPolicyStatusCMP0022() != cmPolicies::OLD &&
this->Target->GetPolicyStatusCMP0022() != cmPolicies::WARN)
if(this->GetPolicyStatusCMP0022() != cmPolicies::OLD &&
this->GetPolicyStatusCMP0022() != cmPolicies::WARN)
{
// CMP0022 NEW behavior is to use INTERFACE_LINK_LIBRARIES.
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
explicitLibraries = this->GetProperty(linkIfaceProp);
}
else if(this->GetType() == cmState::SHARED_LIBRARY ||
this->Target->IsExecutableWithExports())
this->IsExecutableWithExports())
{
// CMP0022 OLD behavior is to use LINK_INTERFACE_LIBRARIES if set on a
// shared lib or executable.
@ -5050,7 +5102,7 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
}
if(explicitLibraries &&
this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
this->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
!this->PolicyWarnedCMP0022)
{
// Compare the explicitly set old link interface properties to the
@ -5095,8 +5147,8 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
iface.Libraries,
iface.HadHeadSensitiveCondition);
}
else if (this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN
|| this->Target->GetPolicyStatusCMP0022() == cmPolicies::OLD)
else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN
|| this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
// If CMP0022 is NEW then the plain tll signature sets the
// INTERFACE_LINK_LIBRARIES, so if we get here then the project
// cleared the property explicitly and we should not fall back
@ -5107,7 +5159,7 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
this->GetLinkImplementationLibrariesInternal(config, headTarget);
iface.Libraries.insert(iface.Libraries.end(),
impl->Libraries.begin(), impl->Libraries.end());
if(this->Target->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
if(this->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
!this->PolicyWarnedCMP0022 && !usage_requirements_only)
{
// Compare the link implementation fallback link interface to the
@ -5350,7 +5402,7 @@ void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config,
info.ImportLibrary = imp;
}
else if(this->GetType() == cmState::SHARED_LIBRARY ||
this->Target->IsExecutableWithExports())
this->IsExecutableWithExports())
{
std::string impProp = "IMPORTED_IMPLIB";
impProp += suffix;
@ -5569,7 +5621,7 @@ std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
if(lib != item)
{
cmake* cm = this->LocalGenerator->GetCMakeInstance();
switch(this->Target->GetPolicyStatusCMP0004())
switch(this->GetPolicyStatusCMP0004())
{
case cmPolicies::WARN:
{
@ -5578,7 +5630,7 @@ std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
<< "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace.";
cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
this->Target->GetBacktrace());
this->GetBacktrace());
}
case cmPolicies::OLD:
break;
@ -5589,7 +5641,7 @@ std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
<< item << "\" which has leading or trailing whitespace. "
<< "This is now an error according to policy CMP0004.";
cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->GetBacktrace());
this->GetBacktrace());
}
break;
case cmPolicies::REQUIRED_IF_USED:
@ -5600,7 +5652,7 @@ std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
<< "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace.";
cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->GetBacktrace());
this->GetBacktrace());
}
break;
}
@ -5777,7 +5829,7 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
bool noMessage = false;
cmake::MessageType messageType = cmake::FATAL_ERROR;
std::ostringstream e;
switch(this->Target->GetPolicyStatusCMP0038())
switch(this->GetPolicyStatusCMP0038())
{
case cmPolicies::WARN:
{
@ -5798,7 +5850,7 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
{
e << "Target \"" << this->GetName() << "\" links to itself.";
this->LocalGenerator->GetCMakeInstance()->IssueMessage(
messageType, e.str(), this->Target->GetBacktrace());
messageType, e.str(), this->GetBacktrace());
if (messageType == cmake::FATAL_ERROR)
{
return;
@ -5827,7 +5879,12 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
this->MaxLanguageStandards);
}
cmTargetLinkLibraryType linkType = this->Target->ComputeLinkType(config);
// Get the list of configurations considered to be DEBUG.
std::vector<std::string> debugConfigs =
this->Makefile->GetCMakeInstance()->GetDebugConfigs();
cmTargetLinkLibraryType linkType =
CMP0003_ComputeLinkType(config, debugConfigs);
cmTarget::LinkLibraryVectorType const& oldllibs =
this->Target->GetOriginalLinkLibraries();
for(cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin();
@ -5858,7 +5915,7 @@ cmGeneratorTarget::FindTargetToLink(std::string const& name) const
// name conflict between an external library and an executable
// within the project.
if(tgt && tgt->GetType() == cmState::EXECUTABLE &&
!tgt->Target->IsExecutableWithExports())
!tgt->IsExecutableWithExports())
{
tgt = 0;
}
@ -5873,7 +5930,7 @@ cmGeneratorTarget::FindTargetToLink(std::string const& name) const
"with the ENABLE_EXPORTS property set.";
cmake* cm = this->LocalGenerator->GetCMakeInstance();
cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->GetBacktrace());
this->GetBacktrace());
tgt = 0;
}
@ -5913,12 +5970,19 @@ bool cmGeneratorTarget::GetImplibGNUtoMS(std::string const& gnuName,
return false;
}
//----------------------------------------------------------------------------
bool cmGeneratorTarget::IsExecutableWithExports() const
{
return (this->GetType() == cmState::EXECUTABLE &&
this->GetPropertyAsBool("ENABLE_EXPORTS"));
}
//----------------------------------------------------------------------------
bool cmGeneratorTarget::HasImportLibrary() const
{
return (this->Target->IsDLLPlatform() &&
return (this->IsDLLPlatform() &&
(this->GetType() == cmState::SHARED_LIBRARY ||
this->Target->IsExecutableWithExports()));
this->IsExecutableWithExports()));
}
//----------------------------------------------------------------------------
@ -5944,7 +6008,7 @@ bool cmGeneratorTarget::IsLinkable() const
this->GetType() == cmState::MODULE_LIBRARY ||
this->GetType() == cmState::UNKNOWN_LIBRARY ||
this->GetType() == cmState::INTERFACE_LIBRARY ||
this->Target->IsExecutableWithExports());
this->IsExecutableWithExports());
}
//----------------------------------------------------------------------------

26
Source/cmGeneratorTarget.h
View File

@ -33,6 +33,14 @@ public:
bool IsImported() const;
const char *GetLocation(const std::string& config) const;
#define DECLARE_TARGET_POLICY(POLICY) \
cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \
{ return this->PolicyMap.Get(cmPolicies::POLICY); }
CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY)
#undef DECLARE_TARGET_POLICY
/** Get the location of the target in the build tree with a placeholder
referencing the configuration in the native build system. This
location is suitable for use as the LOCATION target property. */
@ -166,6 +174,12 @@ public:
* install tree. For example: "\@rpath/" or "\@loader_path/". */
std::string GetInstallNameDirForInstallTree() const;
cmListFileBacktrace GetBacktrace() const;
/** Get the macro to define when building sources in this target.
If no macro should be defined null is returned. */
const char* GetExportMacro() const;
/** Get the soname of the target. Allowed only for a shared library. */
std::string GetSOName(const std::string& config) const;
@ -190,6 +204,12 @@ public:
std::string GetModuleDefinitionFile(const std::string& config) const;
/** Return whether or not the target is for a DLL platform. */
bool IsDLLPlatform() const;
/** @return whether this target have a well defined output file name. */
bool HaveWellDefinedOutputFiles() const;
/** Link information from the transitive closure of the link
implementation and the interfaces of its dependencies. */
struct LinkClosure
@ -406,6 +426,8 @@ public:
bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out,
const char* newExt = 0) const;
bool IsExecutableWithExports() const;
/** Return whether or not the target has a DLL import library. */
bool HasImportLibrary() const;
@ -483,6 +505,8 @@ private:
std::set<cmSourceFile const*> ExplicitObjectName;
mutable std::map<std::string, std::vector<std::string> > SystemIncludesCache;
mutable std::string ExportMacro;
void ConstructSourceFileFlags() const;
mutable bool SourceFileFlagsConstructed;
mutable std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap;
@ -625,6 +649,7 @@ private:
typedef std::map<OutputNameKey, std::string> OutputNameMapType;
mutable OutputNameMapType OutputNameMap;
mutable std::set<cmLinkItem> UtilityItems;
cmPolicies::PolicyMap PolicyMap;
mutable bool PolicyWarnedCMP0022;
mutable bool DebugIncludesDone;
mutable bool DebugCompileOptionsDone;
@ -633,6 +658,7 @@ private:
mutable bool DebugSourcesDone;
mutable bool LinkImplementationLanguageIsContextDependent;
mutable bool UtilityItemsDone;
bool DLLPlatform;
bool ComputePDBOutputDir(const std::string& kind, const std::string& config,
std::string& out) const;

2
Source/cmGhsMultiTargetGenerator.cxx
View File

@ -297,7 +297,7 @@ std::string cmGhsMultiTargetGenerator::GetDefines(const std::string &language,
std::set<std::string> defines;
const char *lang = language.c_str();
// Add the export symbol definition for shared library objects.
if (const char *exportMacro = this->Target->GetExportMacro())
if (const char *exportMacro = this->GeneratorTarget->GetExportMacro())
{
this->LocalGenerator->AppendDefines(defines, exportMacro);
}

6
Source/cmGlobalGenerator.cxx
View File

@ -2701,13 +2701,13 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
for (cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
{
cmTarget* target = &l->second;
if(this->IsRootOnlyTarget(target) &&
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
if(this->IsRootOnlyTarget(gt) &&
target->GetMakefile() != root->GetMakefile())
{
continue;
}
// put the target in the set of original targets
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
originalTargets.insert(gt);
// Get the set of targets that depend on target
this->AddTargetDepends(gt, projectTargets);
@ -2716,7 +2716,7 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
}
//----------------------------------------------------------------------------
bool cmGlobalGenerator::IsRootOnlyTarget(cmTarget* target) const
bool cmGlobalGenerator::IsRootOnlyTarget(cmGeneratorTarget* target) const
{
return (target->GetType() == cmState::GLOBAL_TARGET ||
target->GetName() == this->GetAllTargetName());

2
Source/cmGlobalGenerator.h
View File

@ -376,7 +376,7 @@ protected:
void GetTargetSets(TargetDependSet& projectTargets,
TargetDependSet& originalTargets,
cmLocalGenerator* root, GeneratorVector const&);
bool IsRootOnlyTarget(cmTarget* target) const;
bool IsRootOnlyTarget(cmGeneratorTarget* target) const;
void AddTargetDepends(const cmGeneratorTarget* target,
TargetDependSet& projectTargets);
void SetLanguageEnabledFlag(const std::string& l, cmMakefile* mf);

2
Source/cmGlobalXCodeGenerator.cxx
View File

@ -1850,7 +1850,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
this->AppendDefines(ppDefs,
"CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
}
if(const char* exportMacro = target.GetExportMacro())
if(const char* exportMacro = gtgt->GetExportMacro())
{
// Add the export symbol definition for shared library objects.
this->AppendDefines(ppDefs, exportMacro);

24
Source/cmLinkItem.h
View File

@ -14,6 +14,7 @@
#define cmLinkItem_h
#include "cmListFileCache.h"
#include "cmSystemTools.h"
class cmGeneratorTarget;
@ -118,4 +119,27 @@ struct cmOptionalLinkImplementation: public cmLinkImplementation
bool HadHeadSensitiveCondition;
};
/** Compute the link type to use for the given configuration. */
inline cmTargetLinkLibraryType
CMP0003_ComputeLinkType(const std::string& config,
std::vector<std::string> const& debugConfigs)
{
// No configuration is always optimized.
if(config.empty())
{
return OPTIMIZED_LibraryType;
}
// Check if any entry in the list matches this configuration.
std::string configUpper = cmSystemTools::UpperCase(config);
if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) !=
debugConfigs.end())
{
return DEBUG_LibraryType;
}
// The current configuration is not a debug configuration.
return OPTIMIZED_LibraryType;
}
#endif

12
Source/cmLocalGenerator.cxx
View File

@ -1438,7 +1438,7 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE");
linkFlags += " ";
}
if (target->Target->IsExecutableWithExports())
if (target->IsExecutableWithExports())
{
std::string exportFlagVar = "CMAKE_EXE_EXPORTS_";
exportFlagVar += linkLanguage;
@ -1545,7 +1545,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
GetGlobalPropertyAsBool("TARGET_SUPPORTS_SHARED_LIBS"))
{
bool add_shlib_flags = false;
switch(tgt.Target->GetPolicyStatusCMP0065())
switch(tgt.GetPolicyStatusCMP0065())
{
case cmPolicies::WARN:
if(!tgt.GetPropertyAsBool("ENABLE_EXPORTS") &&
@ -1976,7 +1976,7 @@ AddCompilerRequirementFlag(std::string &flags,
std::string e =
lang + "_STANDARD is set to invalid value '" + standard + "'";
this->GetGlobalGenerator()->GetCMakeInstance()
->IssueMessage(cmake::FATAL_ERROR, e, target->Target->GetBacktrace());
->IssueMessage(cmake::FATAL_ERROR, e, target->GetBacktrace());
return;
}
@ -2100,9 +2100,9 @@ void cmLocalGenerator
std::string *pWarnCMP0063 = 0;
if (target->GetType() != cmState::SHARED_LIBRARY &&
target->GetType() != cmState::MODULE_LIBRARY &&
!target->Target->IsExecutableWithExports())
!target->IsExecutableWithExports())
{
switch (target->Target->GetPolicyStatusCMP0063())
switch (target->GetPolicyStatusCMP0063())
{
case cmPolicies::OLD:
return;
@ -2135,7 +2135,7 @@ void cmLocalGenerator
"For compatibility CMake is not honoring them for this target.";
target->Target->GetMakefile()->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
target->Target->GetBacktrace());
target->GetBacktrace());
}
}

2
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -1543,7 +1543,7 @@ void cmLocalVisualStudio6Generator
// Add the export symbol definition for shared library objects.
std::string exportSymbol;
if(const char* exportMacro = target.GetExportMacro())
if(const char* exportMacro = gt->GetExportMacro())
{
exportSymbol = exportMacro;
}

2
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -777,7 +777,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
targetOptions.AddDefine(configDefine);
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = target.GetExportMacro())
if(const char* exportMacro = gt->GetExportMacro())
{
targetOptions.AddDefine(exportMacro);
}

4
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@ -209,7 +209,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
}
// Add symbol export flags if necessary.
if(this->Target->IsExecutableWithExports())
if(this->GeneratorTarget->IsExecutableWithExports())
{
std::string export_flag_var = "CMAKE_EXE_EXPORTS_";
export_flag_var += linkLanguage;
@ -297,7 +297,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
std::string linkRule = this->GetLinkRule(linkRuleVar);
std::vector<std::string> commands1;
cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
if(this->Target->IsExecutableWithExports())
if(this->GeneratorTarget->IsExecutableWithExports())
{
// If a separate rule for creating an import library is specified
// add it now.

2
Source/cmOSXBundleGenerator.cxx
View File

@ -34,7 +34,7 @@ cmOSXBundleGenerator(cmGeneratorTarget* target,
//----------------------------------------------------------------------------
bool cmOSXBundleGenerator::MustSkip()
{
return !this->GT->Target->HaveWellDefinedOutputFiles();
return !this->GT->HaveWellDefinedOutputFiles();
}
//----------------------------------------------------------------------------

4
Source/cmOrderDirectories.cxx
View File

@ -555,7 +555,7 @@ void cmOrderDirectories::FindImplicitConflicts()
<< "Some of these libraries may not be found correctly.";
this->GlobalGenerator->GetCMakeInstance()
->IssueMessage(cmake::WARNING, w.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}
//----------------------------------------------------------------------------
@ -637,5 +637,5 @@ void cmOrderDirectories::DiagnoseCycle()
e << "Some of these libraries may not be found correctly.";
this->GlobalGenerator->GetCMakeInstance()
->IssueMessage(cmake::WARNING, e.str(),
this->Target->Target->GetBacktrace());
this->Target->GetBacktrace());
}

17
Source/cmPolicies.h
View File

@ -230,6 +230,23 @@ class cmPolicy;
#define CM_FOR_EACH_POLICY_ID(POLICY) \
CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID)
#define CM_FOR_EACH_TARGET_POLICY(F) \
F(CMP0003) \
F(CMP0004) \
F(CMP0008) \
F(CMP0020) \
F(CMP0021) \
F(CMP0022) \
F(CMP0027) \
F(CMP0038) \
F(CMP0041) \
F(CMP0042) \
F(CMP0046) \
F(CMP0052) \
F(CMP0060) \
F(CMP0063) \
F(CMP0065)
/** \class cmPolicies
* \brief Handles changes in CMake behavior and policies

68
Source/cmTarget.cxx
View File

@ -582,31 +582,6 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories() const
return this->LinkDirectories;
}
//----------------------------------------------------------------------------
cmTargetLinkLibraryType cmTarget::ComputeLinkType(
const std::string& config) const
{
// No configuration is always optimized.
if(config.empty())
{
return OPTIMIZED_LibraryType;
}
// Get the list of configurations considered to be DEBUG.
std::vector<std::string> debugConfigs =
this->Makefile->GetCMakeInstance()->GetDebugConfigs();
// Check if any entry in the list matches this configuration.
std::string configUpper = cmSystemTools::UpperCase(config);
if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) !=
debugConfigs.end())
{
return DEBUG_LibraryType;
}
// The current configuration is not a debug configuration.
return OPTIMIZED_LibraryType;
}
//----------------------------------------------------------------------------
void cmTarget::ClearDependencyInformation( cmMakefile& mf,
const std::string& target )
@ -635,13 +610,6 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf,
}
}
//----------------------------------------------------------------------------
bool cmTarget::NameResolvesToFramework(const std::string& libname) const
{
return this->Makefile->GetGlobalGenerator()->
NameResolvesToFramework(libname);
}
//----------------------------------------------------------------------------
std::string cmTarget::GetDebugGeneratorExpressions(const std::string &value,
cmTargetLinkLibraryType llt) const
@ -1559,16 +1527,6 @@ void cmTarget::MarkAsImported()
this->IsImportedTarget = true;
}
//----------------------------------------------------------------------------
bool cmTarget::HaveWellDefinedOutputFiles() const
{
return
this->GetType() == cmState::STATIC_LIBRARY ||
this->GetType() == cmState::SHARED_LIBRARY ||
this->GetType() == cmState::MODULE_LIBRARY ||
this->GetType() == cmState::EXECUTABLE;
}
//----------------------------------------------------------------------------
bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const
{
@ -2109,32 +2067,6 @@ std::string cmTarget::GetFrameworkVersion() const
}
}
//----------------------------------------------------------------------------
const char* cmTarget::GetExportMacro() const
{
// Define the symbol for targets that export symbols.
if(this->GetType() == cmState::SHARED_LIBRARY ||
this->GetType() == cmState::MODULE_LIBRARY ||
this->IsExecutableWithExports())
{
if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL"))
{
this->ExportMacro = custom_export_name;
}
else
{
std::string in = this->GetName();
in += "_EXPORTS";
this->ExportMacro = cmSystemTools::MakeCindentifier(in);
}
return this->ExportMacro.c_str();
}
else
{
return 0;
}
}
bool cmTarget::GetMappedConfig(std::string const& desired_config,
const char** loc,
const char** imp,

33
Source/cmTarget.h
View File

@ -26,23 +26,6 @@
# endif
#endif
#define CM_FOR_EACH_TARGET_POLICY(F) \
F(CMP0003) \
F(CMP0004) \
F(CMP0008) \
F(CMP0020) \
F(CMP0021) \
F(CMP0022) \
F(CMP0027) \
F(CMP0038) \
F(CMP0041) \
F(CMP0042) \
F(CMP0046) \
F(CMP0052) \
F(CMP0060) \
F(CMP0063) \
F(CMP0065)
class cmake;
class cmMakefile;
class cmSourceFile;
@ -140,16 +123,11 @@ public:
const LinkLibraryVectorType &GetOriginalLinkLibraries() const
{return this->OriginalLinkLibraries;}
/** Compute the link type to use for the given configuration. */
cmTargetLinkLibraryType ComputeLinkType(const std::string& config) const;
/**
* Clear the dependency information recorded for this target, if any.
*/
void ClearDependencyInformation(cmMakefile& mf, const std::string& target);
// Check to see if a library is a framework and treat it different on Mac
bool NameResolvesToFramework(const std::string& libname) const;
void AddLinkLibrary(cmMakefile& mf,
const std::string& target, const std::string& lib,
cmTargetLinkLibraryType llt);
@ -220,17 +198,10 @@ public:
const char** imp,
std::string& suffix) const;
/** Get the macro to define when building sources in this target.
If no macro should be defined null is returned. */
const char* GetExportMacro() const;
/** Return whether this target is an executable with symbol exports
enabled. */
bool IsExecutableWithExports() const;
/** Return whether or not the target is for a DLL platform. */
bool IsDLLPlatform() const { return this->DLLPlatform; }
/** Return whether this target is a shared library Framework on
Apple. */
bool IsFrameworkOnApple() const;
@ -245,9 +216,6 @@ public:
/** Get a backtrace from the creation of the target. */
cmListFileBacktrace const& GetBacktrace() const;
/** @return whether this target have a well defined output file name. */
bool HaveWellDefinedOutputFiles() const;
void InsertInclude(std::string const& entry,
cmListFileBacktrace const& bt,
bool before = false);
@ -369,7 +337,6 @@ private:
std::string Name;
std::string InstallPath;
std::string RuntimeInstallPath;
mutable std::string ExportMacro;
std::vector<std::string> LinkDirectories;
std::vector<cmCustomCommand> PreBuildCommands;
std::vector<cmCustomCommand> PreLinkCommands;

3
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -1961,7 +1961,8 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
configDefine += configName;
configDefine += "\"";
clOptions.AddDefine(configDefine);
if(const char* exportMacro = this->Target->GetExportMacro())
if(const char* exportMacro =
this->GeneratorTarget->GetExportMacro())
{
clOptions.AddDefine(exportMacro);
}