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

Merge topic 'refactor-link-internals' 

f5c18c9c cmTarget: Drop GetDirectLinkLibraries methods
281eb3d8 cmTarget: Improve HaveBuildTreeRPATH implementation
d912220e cmTarget: Lookup targets in LinkInterface and LinkImplementation
edce4351 cmExportFileGenerator: Make SetImportLinkProperty a template
097be413 cmTarget: Add GetUtilityItems to get target ordering dependencies
4dad5fd2 cmTarget: Add cmLinkItem to refer to a target by name and pointer
a2723442 Fix scope of transitive target name lookups
069d60fe cmTarget: Add method to lookup other targets in a target's scope
47ab3ca6 cmTarget: Constify GetLinkImplementationClosure results
9f3ed029 cmTarget: Constify GetTransitivePropertyTargets results
6f0951af cmTarget: Drop 'head' target from GetImportInfo
0dc9e88d cmTarget: Remove 'head' argument from GetLinkImplementation
4ac72455 cmTarget: Drop 'head' argument from GetLinkClosure
bcdb7ff9 cmTarget: Remove 'head' argument from GetLinkerLanguage
bd9b667b cmComputeLinkInformation: Remove 'head' argument
06328dd5 cmTarget: Remove 'head' argument from GetLinkInformation
...
This commit is contained in:
Brad King 2014-06-25 13:11:50 -04:00 committed by CMake Topic Stage
parent 4c27c51f25 f5c18c9c1c
commit cbf0107977
17 changed files with 467 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
Source/cmComputeLinkDepends.cxx
View File

@ -172,12 +172,10 @@ satisfy dependencies.
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmComputeLinkDepends cmComputeLinkDepends
::cmComputeLinkDepends(cmTarget const* target, const std::string& config, ::cmComputeLinkDepends(cmTarget const* target, const std::string& config)
cmTarget const* head)
{ {
// Store context information. // Store context information.
this->Target = target; this->Target = target;
this->HeadTarget = head;
this->Makefile = this->Target->GetMakefile(); this->Makefile = this->Target->GetMakefile();
this->LocalGenerator = this->Makefile->GetLocalGenerator(); this->LocalGenerator = this->Makefile->GetLocalGenerator();
this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator(); this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator();
@ -294,8 +292,7 @@ cmComputeLinkDepends::AllocateLinkEntry(std::string const& item)
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
int cmComputeLinkDepends::AddLinkEntry(int depender_index, int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
std::string const& item)
{ {
// Check if the item entry has already been added. // Check if the item entry has already been added.
std::map<std::string, int>::iterator lei = this->LinkEntryIndex.find(item); std::map<std::string, int>::iterator lei = this->LinkEntryIndex.find(item);
@ -312,7 +309,7 @@ int cmComputeLinkDepends::AddLinkEntry(int depender_index,
int index = lei->second; int index = lei->second;
LinkEntry& entry = this->EntryList[index]; LinkEntry& entry = this->EntryList[index];
entry.Item = item; entry.Item = item;
entry.Target = this->FindTargetToLink(depender_index, entry.Item); entry.Target = item.Target;
entry.IsFlag = (!entry.Target && item[0] == '-' && item[1] != 'l' && entry.IsFlag = (!entry.Target && item[0] == '-' && item[1] != 'l' &&
item.substr(0, 10) != "-framework"); item.substr(0, 10) != "-framework");
@ -356,7 +353,7 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
{ {
// Follow the target dependencies. // Follow the target dependencies.
if(cmTarget::LinkInterface const* iface = if(cmTarget::LinkInterface const* iface =
entry.Target->GetLinkInterface(this->Config, this->HeadTarget)) entry.Target->GetLinkInterface(this->Config, this->Target))
{ {
const bool isIface = const bool isIface =
entry.Target->GetType() == cmTarget::INTERFACE_LIBRARY; entry.Target->GetType() == cmTarget::INTERFACE_LIBRARY;
@ -372,11 +369,11 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
this->FollowSharedDeps(depender_index, iface); this->FollowSharedDeps(depender_index, iface);
// Support for CMP0003. // Support for CMP0003.
for(std::vector<std::string>::const_iterator for(std::vector<cmLinkItem>::const_iterator
oi = iface->WrongConfigLibraries.begin(); oi = iface->WrongConfigLibraries.begin();
oi != iface->WrongConfigLibraries.end(); ++oi) oi != iface->WrongConfigLibraries.end(); ++oi)
{ {
this->CheckWrongConfigItem(depender_index, *oi); this->CheckWrongConfigItem(*oi);
} }
} }
} }
@ -408,9 +405,9 @@ cmComputeLinkDepends
void void
cmComputeLinkDepends cmComputeLinkDepends
::QueueSharedDependencies(int depender_index, ::QueueSharedDependencies(int depender_index,
std::vector<std::string> const& deps) std::vector<cmLinkItem> const& deps)
{ {
for(std::vector<std::string>::const_iterator li = deps.begin(); for(std::vector<cmLinkItem>::const_iterator li = deps.begin();
li != deps.end(); ++li) li != deps.end(); ++li)
{ {
SharedDepEntry qe; SharedDepEntry qe;
@ -434,8 +431,7 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
// Initialize the item entry. // Initialize the item entry.
LinkEntry& entry = this->EntryList[lei->second]; LinkEntry& entry = this->EntryList[lei->second];
entry.Item = dep.Item; entry.Item = dep.Item;
entry.Target = this->FindTargetToLink(dep.DependerIndex, entry.Target = dep.Item.Target;
dep.Item);
// This item was added specifically because it is a dependent // This item was added specifically because it is a dependent
// shared library. It may get special treatment // shared library. It may get special treatment
@ -455,7 +451,7 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
if(entry.Target) if(entry.Target)
{ {
if(cmTarget::LinkInterface const* iface = if(cmTarget::LinkInterface const* iface =
entry.Target->GetLinkInterface(this->Config, this->HeadTarget)) entry.Target->GetLinkInterface(this->Config, this->Target))
{ {
// Follow public and private dependencies transitively. // Follow public and private dependencies transitively.
this->FollowSharedDeps(index, iface, true); this->FollowSharedDeps(index, iface, true);
@ -474,7 +470,7 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
cmSystemTools::ExpandListArgument(value, deplist); cmSystemTools::ExpandListArgument(value, deplist);
// Look for entries meant for this configuration. // Look for entries meant for this configuration.
std::vector<std::string> actual_libs; std::vector<cmLinkItem> actual_libs;
cmTarget::LinkLibraryType llt = cmTarget::GENERAL; cmTarget::LinkLibraryType llt = cmTarget::GENERAL;
bool haveLLT = false; bool haveLLT = false;
for(std::vector<std::string>::const_iterator di = deplist.begin(); for(std::vector<std::string>::const_iterator di = deplist.begin();
@ -522,11 +518,13 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
// If the library is meant for this link type then use it. // If the library is meant for this link type then use it.
if(llt == cmTarget::GENERAL || llt == this->LinkType) if(llt == cmTarget::GENERAL || llt == this->LinkType)
{ {
actual_libs.push_back(*di); cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
actual_libs.push_back(item);
} }
else if(this->OldLinkDirMode) else if(this->OldLinkDirMode)
{ {
this->CheckWrongConfigItem(depender_index, *di); cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
this->CheckWrongConfigItem(item);
} }
// Reset the link type until another explicit type is given. // Reset the link type until another explicit type is given.
@ -544,38 +542,38 @@ void cmComputeLinkDepends::AddDirectLinkEntries()
{ {
// Add direct link dependencies in this configuration. // Add direct link dependencies in this configuration.
cmTarget::LinkImplementation const* impl = cmTarget::LinkImplementation const* impl =
this->Target->GetLinkImplementation(this->Config, this->HeadTarget); this->Target->GetLinkImplementation(this->Config);
this->AddLinkEntries(-1, impl->Libraries); this->AddLinkEntries(-1, impl->Libraries);
for(std::vector<std::string>::const_iterator for(std::vector<cmLinkItem>::const_iterator
wi = impl->WrongConfigLibraries.begin(); wi = impl->WrongConfigLibraries.begin();
wi != impl->WrongConfigLibraries.end(); ++wi) wi != impl->WrongConfigLibraries.end(); ++wi)
{ {
this->CheckWrongConfigItem(-1, *wi); this->CheckWrongConfigItem(*wi);
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void void
cmComputeLinkDepends::AddLinkEntries(int depender_index, cmComputeLinkDepends::AddLinkEntries(
std::vector<std::string> const& libs) int depender_index, std::vector<cmLinkItem> const& libs)
{ {
// Track inferred dependency sets implied by this list. // Track inferred dependency sets implied by this list.
std::map<int, DependSet> dependSets; std::map<int, DependSet> dependSets;
// Loop over the libraries linked directly by the depender. // Loop over the libraries linked directly by the depender.
for(std::vector<std::string>::const_iterator li = libs.begin(); for(std::vector<cmLinkItem>::const_iterator li = libs.begin();
li != libs.end(); ++li) li != libs.end(); ++li)
{ {
// Skip entries that will resolve to the target getting linked or // Skip entries that will resolve to the target getting linked or
// are empty. // are empty.
std::string item = this->Target->CheckCMP0004(*li); cmLinkItem const& item = *li;
if(item == this->Target->GetName() || item.empty()) if(item == this->Target->GetName() || item.empty())
{ {
continue; continue;
} }
// Add a link entry for this item. // Add a link entry for this item.
int dependee_index = this->AddLinkEntry(depender_index, item); int dependee_index = this->AddLinkEntry(*li);
// The dependee must come after the depender. // The dependee must come after the depender.
if(depender_index >= 0) if(depender_index >= 0)
@ -625,40 +623,15 @@ cmTarget const* cmComputeLinkDepends::FindTargetToLink(int depender_index,
const std::string& name) const std::string& name)
{ {
// Look for a target in the scope of the depender. // Look for a target in the scope of the depender.
cmMakefile* mf = this->Makefile; cmTarget const* from = this->Target;
if(depender_index >= 0) if(depender_index >= 0)
{ {
if(cmTarget const* depender = this->EntryList[depender_index].Target) if(cmTarget const* depender = this->EntryList[depender_index].Target)
{ {
mf = depender->GetMakefile(); from = depender;
} }
} }
cmTarget const* tgt = mf->FindTargetToUse(name); return from->FindTargetToLink(name);
// Skip targets that will not really be linked. This is probably a
// name conflict between an external library and an executable
// within the project.
if(tgt && tgt->GetType() == cmTarget::EXECUTABLE &&
!tgt->IsExecutableWithExports())
{
tgt = 0;
}
if(tgt && tgt->GetType() == cmTarget::OBJECT_LIBRARY)
{
cmOStringStream e;
e << "Target \"" << this->Target->GetName() << "\" links to "
"OBJECT library \"" << tgt->GetName() << "\" but this is not "
"allowed. "
"One may link only to STATIC or SHARED libraries, or to executables "
"with the ENABLE_EXPORTS property set.";
this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->GetBacktrace());
tgt = 0;
}
// Return the target found, if any.
return tgt;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -955,7 +928,7 @@ int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
if(cmTarget const* target = this->EntryList[*ni].Target) if(cmTarget const* target = this->EntryList[*ni].Target)
{ {
if(cmTarget::LinkInterface const* iface = if(cmTarget::LinkInterface const* iface =
target->GetLinkInterface(this->Config, this->HeadTarget)) target->GetLinkInterface(this->Config, this->Target))
{ {
if(iface->Multiplicity > count) if(iface->Multiplicity > count)
{ {
@ -988,8 +961,7 @@ void cmComputeLinkDepends::DisplayFinalEntries()
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmComputeLinkDepends::CheckWrongConfigItem(int depender_index, void cmComputeLinkDepends::CheckWrongConfigItem(cmLinkItem const& item)
std::string const& item)
{ {
if(!this->OldLinkDirMode) if(!this->OldLinkDirMode)
{ {
@ -999,12 +971,8 @@ void cmComputeLinkDepends::CheckWrongConfigItem(int depender_index,
// For CMake 2.4 bug-compatibility we need to consider the output // For CMake 2.4 bug-compatibility we need to consider the output
// directories of targets linked in another configuration as link // directories of targets linked in another configuration as link
// directories. // directories.
if(cmTarget const* tgt if(item.Target && !item.Target->IsImported())
= this->FindTargetToLink(depender_index, item))
{ {
if(!tgt->IsImported()) this->OldWrongConfigItems.insert(item.Target);
{
this->OldWrongConfigItems.insert(tgt);
}
} }
} }

14
Source/cmComputeLinkDepends.h
View File

@ -32,8 +32,7 @@ class cmake;
class cmComputeLinkDepends class cmComputeLinkDepends
{ {
public: public:
cmComputeLinkDepends(cmTarget const* target, const std::string& config, cmComputeLinkDepends(cmTarget const* target, const std::string& config);
cmTarget const* head);
~cmComputeLinkDepends(); ~cmComputeLinkDepends();
// Basic information about each link item. // Basic information about each link item.
@ -60,7 +59,6 @@ private:
// Context information. // Context information.
cmTarget const* Target; cmTarget const* Target;
cmTarget const* HeadTarget;
cmMakefile* Makefile; cmMakefile* Makefile;
cmLocalGenerator* LocalGenerator; cmLocalGenerator* LocalGenerator;
cmGlobalGenerator const* GlobalGenerator; cmGlobalGenerator const* GlobalGenerator;
@ -79,11 +77,11 @@ private:
std::map<std::string, int>::iterator std::map<std::string, int>::iterator
AllocateLinkEntry(std::string const& item); AllocateLinkEntry(std::string const& item);
int AddLinkEntry(int depender_index, std::string const& item); int AddLinkEntry(cmLinkItem const& item);
void AddVarLinkEntries(int depender_index, const char* value); void AddVarLinkEntries(int depender_index, const char* value);
void AddDirectLinkEntries(); void AddDirectLinkEntries();
void AddLinkEntries(int depender_index, void AddLinkEntries(int depender_index,
std::vector<std::string> const& libs); std::vector<cmLinkItem> const& libs);
cmTarget const* FindTargetToLink(int depender_index, cmTarget const* FindTargetToLink(int depender_index,
const std::string& name); const std::string& name);
@ -105,7 +103,7 @@ private:
// of the interface. // of the interface.
struct SharedDepEntry struct SharedDepEntry
{ {
std::string Item; cmLinkItem Item;
int DependerIndex; int DependerIndex;
}; };
std::queue<SharedDepEntry> SharedDepQueue; std::queue<SharedDepEntry> SharedDepQueue;
@ -114,7 +112,7 @@ private:
cmTarget::LinkInterface const* iface, cmTarget::LinkInterface const* iface,
bool follow_interface = false); bool follow_interface = false);
void QueueSharedDependencies(int depender_index, void QueueSharedDependencies(int depender_index,
std::vector<std::string> const& deps); std::vector<cmLinkItem> const& deps);
void HandleSharedDependency(SharedDepEntry const& dep); void HandleSharedDependency(SharedDepEntry const& dep);
// Dependency inferral for each link item. // Dependency inferral for each link item.
@ -165,7 +163,7 @@ private:
// Compatibility help. // Compatibility help.
bool OldLinkDirMode; bool OldLinkDirMode;
void CheckWrongConfigItem(int depender_index, std::string const& item); void CheckWrongConfigItem(cmLinkItem const& item);
std::set<cmTarget const*> OldWrongConfigItems; std::set<cmTarget const*> OldWrongConfigItems;
}; };

14
Source/cmComputeLinkInformation.cxx
View File

@ -239,12 +239,10 @@ because this need be done only for shared libraries without soname-s.
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmComputeLinkInformation cmComputeLinkInformation
::cmComputeLinkInformation(cmTarget const* target, const std::string& config, ::cmComputeLinkInformation(cmTarget const* target, const std::string& config)
cmTarget const* headTarget)
{ {
// Store context information. // Store context information.
this->Target = target; this->Target = target;
this->HeadTarget = headTarget;
this->Makefile = this->Target->GetMakefile(); this->Makefile = this->Target->GetMakefile();
this->LocalGenerator = this->Makefile->GetLocalGenerator(); this->LocalGenerator = this->Makefile->GetLocalGenerator();
this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator(); this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator();
@ -267,7 +265,7 @@ cmComputeLinkInformation
this->OrderDependentRPath = 0; this->OrderDependentRPath = 0;
// Get the language used for linking this target. // Get the language used for linking this target.
this->LinkLanguage = this->Target->GetLinkerLanguage(config, headTarget); this->LinkLanguage = this->Target->GetLinkerLanguage(config);
if(this->LinkLanguage.empty()) if(this->LinkLanguage.empty())
{ {
// The Compute method will do nothing, so skip the rest of the // The Compute method will do nothing, so skip the rest of the
@ -505,8 +503,7 @@ bool cmComputeLinkInformation::Compute()
} }
// Compute the ordered link line items. // Compute the ordered link line items.
cmComputeLinkDepends cld(this->Target, this->Config, cmComputeLinkDepends cld(this->Target, this->Config);
this->HeadTarget);
cld.SetOldLinkDirMode(this->OldLinkDirMode); cld.SetOldLinkDirMode(this->OldLinkDirMode);
cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute(); cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();
@ -572,8 +569,7 @@ bool cmComputeLinkInformation::Compute()
void cmComputeLinkInformation::AddImplicitLinkInfo() void cmComputeLinkInformation::AddImplicitLinkInfo()
{ {
// The link closure lists all languages whose implicit info is needed. // The link closure lists all languages whose implicit info is needed.
cmTarget::LinkClosure const* lc=this->Target->GetLinkClosure(this->Config, cmTarget::LinkClosure const* lc=this->Target->GetLinkClosure(this->Config);
this->HeadTarget);
for(std::vector<std::string>::const_iterator li = lc->Languages.begin(); for(std::vector<std::string>::const_iterator li = lc->Languages.begin();
li != lc->Languages.end(); ++li) li != lc->Languages.end(); ++li)
{ {
@ -1972,7 +1968,7 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
// present. This is done even when skipping rpath support. // present. This is done even when skipping rpath support.
{ {
cmTarget::LinkClosure const* lc = cmTarget::LinkClosure const* lc =
this->Target->GetLinkClosure(this->Config, this->HeadTarget); this->Target->GetLinkClosure(this->Config);
for(std::vector<std::string>::const_iterator li = lc->Languages.begin(); for(std::vector<std::string>::const_iterator li = lc->Languages.begin();
li != lc->Languages.end(); ++li) li != lc->Languages.end(); ++li)
{ {

4
Source/cmComputeLinkInformation.h
View File

@ -29,8 +29,7 @@ class cmOrderDirectories;
class cmComputeLinkInformation class cmComputeLinkInformation
{ {
public: public:
cmComputeLinkInformation(cmTarget const* target, const std::string& config, cmComputeLinkInformation(cmTarget const* target, const std::string& config);
cmTarget const* headTarget);
~cmComputeLinkInformation(); ~cmComputeLinkInformation();
bool Compute(); bool Compute();
@ -75,7 +74,6 @@ private:
// Context information. // Context information.
cmTarget const* Target; cmTarget const* Target;
cmTarget const* HeadTarget;
cmMakefile* Makefile; cmMakefile* Makefile;
cmLocalGenerator* LocalGenerator; cmLocalGenerator* LocalGenerator;
cmGlobalGenerator* GlobalGenerator; cmGlobalGenerator* GlobalGenerator;

46
Source/cmComputeTargetDepends.cxx
View File

@ -249,20 +249,21 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
const_cast<cmTarget*>(depender)->AddUtility(objLib); const_cast<cmTarget*>(depender)->AddUtility(objLib);
} }
} }
std::vector<std::string> tlibs;
depender->GetDirectLinkLibraries(*it, tlibs, depender); cmTarget::LinkImplementation const* impl =
depender->GetLinkImplementation(*it);
// A target should not depend on itself. // A target should not depend on itself.
emitted.insert(depender->GetName()); emitted.insert(depender->GetName());
for(std::vector<std::string>::const_iterator lib = tlibs.begin(); for(std::vector<cmLinkItem>::const_iterator
lib != tlibs.end(); ++lib) lib = impl->Libraries.begin();
lib != impl->Libraries.end(); ++lib)
{ {
// Don't emit the same library twice for this target. // Don't emit the same library twice for this target.
if(emitted.insert(*lib).second) if(emitted.insert(*lib).second)
{ {
this->AddTargetDepend(depender_index, *lib, true); this->AddTargetDepend(depender_index, *lib, true);
this->AddInterfaceDepends(depender_index, *lib, this->AddInterfaceDepends(depender_index, *lib, emitted);
true, emitted);
} }
} }
} }
@ -270,11 +271,11 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
// Loop over all utility dependencies. // Loop over all utility dependencies.
{ {
std::set<std::string> const& tutils = depender->GetUtilities(); std::set<cmLinkItem> const& tutils = depender->GetUtilityItems();
std::set<std::string> emitted; std::set<std::string> emitted;
// A target should not depend on itself. // A target should not depend on itself.
emitted.insert(depender->GetName()); emitted.insert(depender->GetName());
for(std::set<std::string>::const_iterator util = tutils.begin(); for(std::set<cmLinkItem>::const_iterator util = tutils.begin();
util != tutils.end(); ++util) util != tutils.end(); ++util)
{ {
// Don't emit the same utility twice for this target. // Don't emit the same utility twice for this target.
@ -296,7 +297,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
if(cmTarget::LinkInterface const* iface = if(cmTarget::LinkInterface const* iface =
dependee->GetLinkInterface(config, depender)) dependee->GetLinkInterface(config, depender))
{ {
for(std::vector<std::string>::const_iterator for(std::vector<cmLinkItem>::const_iterator
lib = iface->Libraries.begin(); lib = iface->Libraries.begin();
lib != iface->Libraries.end(); ++lib) lib != iface->Libraries.end(); ++lib)
{ {
@ -304,8 +305,7 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
if(emitted.insert(*lib).second) if(emitted.insert(*lib).second)
{ {
this->AddTargetDepend(depender_index, *lib, true); this->AddTargetDepend(depender_index, *lib, true);
this->AddInterfaceDepends(depender_index, *lib, this->AddInterfaceDepends(depender_index, *lib, emitted);
true, emitted);
} }
} }
} }
@ -313,17 +313,15 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmComputeTargetDepends::AddInterfaceDepends(int depender_index, void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
const std::string& dependee_name, cmLinkItem const& dependee_name,
bool linking,
std::set<std::string> &emitted) std::set<std::string> &emitted)
{ {
cmTarget const* depender = this->Targets[depender_index]; cmTarget const* depender = this->Targets[depender_index];
cmTarget const* dependee = cmTarget const* dependee = dependee_name.Target;
depender->GetMakefile()->FindTargetToUse(dependee_name);
// Skip targets that will not really be linked. This is probably a // Skip targets that will not really be linked. This is probably a
// name conflict between an external library and an executable // name conflict between an external library and an executable
// within the project. // within the project.
if(linking && dependee && if(dependee &&
dependee->GetType() == cmTarget::EXECUTABLE && dependee->GetType() == cmTarget::EXECUTABLE &&
!dependee->IsExecutableWithExports()) !dependee->IsExecutableWithExports())
{ {
@ -347,16 +345,15 @@ void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmComputeTargetDepends::AddTargetDepend(int depender_index, void cmComputeTargetDepends::AddTargetDepend(
const std::string& dependee_name, int depender_index, cmLinkItem const& dependee_name,
bool linking) bool linking)
{ {
// Get the depender. // Get the depender.
cmTarget const* depender = this->Targets[depender_index]; cmTarget const* depender = this->Targets[depender_index];
// Check the target's makefile first. // Check the target's makefile first.
cmTarget const* dependee = cmTarget const* dependee = dependee_name.Target;
depender->GetMakefile()->FindTargetToUse(dependee_name);
if(!dependee && !linking && if(!dependee && !linking &&
(depender->GetType() != cmTarget::GLOBAL_TARGET)) (depender->GetType() != cmTarget::GLOBAL_TARGET))
@ -424,12 +421,11 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
if(dependee->IsImported()) if(dependee->IsImported())
{ {
// Skip imported targets but follow their utility dependencies. // Skip imported targets but follow their utility dependencies.
std::set<std::string> const& utils = dependee->GetUtilities(); std::set<cmLinkItem> const& utils = dependee->GetUtilityItems();
for(std::set<std::string>::const_iterator i = utils.begin(); for(std::set<cmLinkItem>::const_iterator i = utils.begin();
i != utils.end(); ++i) i != utils.end(); ++i)
{ {
if(cmTarget const* transitive_dependee = if(cmTarget const* transitive_dependee = i->Target)
dependee->GetMakefile()->FindTargetToUse(*i))
{ {
this->AddTargetDepend(depender_index, transitive_dependee, false); this->AddTargetDepend(depender_index, transitive_dependee, false);
} }

7
Source/cmComputeTargetDepends.h
View File

@ -20,6 +20,7 @@
class cmComputeComponentGraph; class cmComputeComponentGraph;
class cmGlobalGenerator; class cmGlobalGenerator;
class cmLinkItem;
class cmTarget; class cmTarget;
class cmTargetDependSet; class cmTargetDependSet;
@ -46,14 +47,14 @@ private:
void CollectDepends(); void CollectDepends();
void CollectTargetDepends(int depender_index); void CollectTargetDepends(int depender_index);
void AddTargetDepend(int depender_index, void AddTargetDepend(int depender_index,
const std::string& dependee_name, cmLinkItem const& dependee_name,
bool linking); bool linking);
void AddTargetDepend(int depender_index, cmTarget const* dependee, void AddTargetDepend(int depender_index, cmTarget const* dependee,
bool linking); bool linking);
bool ComputeFinalDepends(cmComputeComponentGraph const& ccg); bool ComputeFinalDepends(cmComputeComponentGraph const& ccg);
void AddInterfaceDepends(int depender_index, void AddInterfaceDepends(int depender_index,
const std::string& dependee_name, cmLinkItem const& dependee_name,
bool linking, std::set<std::string> &emitted); std::set<std::string> &emitted);
void AddInterfaceDepends(int depender_index, cmTarget const* dependee, void AddInterfaceDepends(int depender_index, cmTarget const* dependee,
const std::string& config, const std::string& config,
std::set<std::string> &emitted); std::set<std::string> &emitted);

8
Source/cmExportFileGenerator.cxx
View File

@ -865,15 +865,16 @@ cmExportFileGenerator
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
template <typename T>
void void
cmExportFileGenerator cmExportFileGenerator
::SetImportLinkProperty(std::string const& suffix, ::SetImportLinkProperty(std::string const& suffix,
cmTarget* target, cmTarget* target,
const std::string& propName, const std::string& propName,
std::vector<std::string> const& entries, std::vector<T> const& entries,
ImportPropertyMap& properties, ImportPropertyMap& properties,
std::vector<std::string>& missingTargets std::vector<std::string>& missingTargets
) )
{ {
// Skip the property if there are no entries. // Skip the property if there are no entries.
if(entries.empty()) if(entries.empty())
@ -884,7 +885,7 @@ cmExportFileGenerator
// Construct the property value. // Construct the property value.
std::string link_entries; std::string link_entries;
const char* sep = ""; const char* sep = "";
for(std::vector<std::string>::const_iterator li = entries.begin(); for(typename std::vector<T>::const_iterator li = entries.begin();
li != entries.end(); ++li) li != entries.end(); ++li)
{ {
// Separate this from the previous entry. // Separate this from the previous entry.
@ -902,7 +903,6 @@ cmExportFileGenerator
properties[prop] = link_entries; properties[prop] = link_entries;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os, void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os,
const std::string& config) const std::string& config)

4
Source/cmExportFileGenerator.h
View File

@ -95,9 +95,11 @@ protected:
std::string const& suffix, cmTarget* target, std::string const& suffix, cmTarget* target,
ImportPropertyMap& properties, ImportPropertyMap& properties,
std::vector<std::string>& missingTargets); std::vector<std::string>& missingTargets);
template <typename T>
void SetImportLinkProperty(std::string const& suffix, void SetImportLinkProperty(std::string const& suffix,
cmTarget* target, const std::string& propName, cmTarget* target, const std::string& propName,
std::vector<std::string> const& entries, std::vector<T> const& entries,
ImportPropertyMap& properties, ImportPropertyMap& properties,
std::vector<std::string>& missingTargets); std::vector<std::string>& missingTargets);

22
Source/cmGeneratorExpressionEvaluator.cxx
View File

@ -799,7 +799,8 @@ static const char* targetPropertyTransitiveWhitelist[] = {
#undef TRANSITIVE_PROPERTY_NAME #undef TRANSITIVE_PROPERTY_NAME
std::string getLinkedTargetsContent(const std::vector<cmTarget*> &targets, std::string getLinkedTargetsContent(
std::vector<cmTarget const*> &targets,
cmTarget const* target, cmTarget const* target,
cmTarget const* headTarget, cmTarget const* headTarget,
cmGeneratorExpressionContext *context, cmGeneratorExpressionContext *context,
@ -810,7 +811,7 @@ std::string getLinkedTargetsContent(const std::vector<cmTarget*> &targets,
std::string sep; std::string sep;
std::string depString; std::string depString;
for (std::vector<cmTarget*>::const_iterator for (std::vector<cmTarget const*>::const_iterator
it = targets.begin(); it = targets.begin();
it != targets.end(); ++it) it != targets.end(); ++it)
{ {
@ -827,7 +828,7 @@ std::string getLinkedTargetsContent(const std::vector<cmTarget*> &targets,
sep = ";"; sep = ";";
} }
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(depString); cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(depString);
std::string linkedTargetsContent = cge->Evaluate(context->Makefile, std::string linkedTargetsContent = cge->Evaluate(target->GetMakefile(),
context->Config, context->Config,
context->Quiet, context->Quiet,
headTarget, headTarget,
@ -840,21 +841,21 @@ std::string getLinkedTargetsContent(const std::vector<cmTarget*> &targets,
return linkedTargetsContent; return linkedTargetsContent;
} }
std::string getLinkedTargetsContent(const std::vector<std::string> &libraries, std::string getLinkedTargetsContent(std::vector<cmLinkItem> const &libraries,
cmTarget const* target, cmTarget const* target,
cmTarget const* headTarget, cmTarget const* headTarget,
cmGeneratorExpressionContext *context, cmGeneratorExpressionContext *context,
cmGeneratorExpressionDAGChecker *dagChecker, cmGeneratorExpressionDAGChecker *dagChecker,
const std::string &interfacePropertyName) const std::string &interfacePropertyName)
{ {
std::vector<cmTarget*> tgts; std::vector<cmTarget const*> tgts;
for (std::vector<std::string>::const_iterator for (std::vector<cmLinkItem>::const_iterator
it = libraries.begin(); it = libraries.begin();
it != libraries.end(); ++it) it != libraries.end(); ++it)
{ {
if (cmTarget *tgt = context->Makefile->FindTargetToUse(*it)) if (it->Target)
{ {
tgts.push_back(tgt); tgts.push_back(it->Target);
} }
} }
return getLinkedTargetsContent(tgts, target, headTarget, context, return getLinkedTargetsContent(tgts, target, headTarget, context,
@ -1082,7 +1083,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
cmStrCmp(propertyName)) != transEnd) cmStrCmp(propertyName)) != transEnd)
{ {
std::vector<cmTarget*> tgts; std::vector<cmTarget const*> tgts;
target->GetTransitivePropertyTargets(context->Config, target->GetTransitivePropertyTargets(context->Config,
headTarget, tgts); headTarget, tgts);
if (!tgts.empty()) if (!tgts.empty())
@ -1098,8 +1099,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
cmStrCmp(interfacePropertyName)) != transEnd) cmStrCmp(interfacePropertyName)) != transEnd)
{ {
const cmTarget::LinkImplementation *impl const cmTarget::LinkImplementation *impl
= target->GetLinkImplementationLibraries(context->Config, = target->GetLinkImplementationLibraries(context->Config);
headTarget);
if(impl) if(impl)
{ {
linkedTargetsContent = linkedTargetsContent =

14
Source/cmGeneratorTarget.cxx
View File

@ -252,7 +252,7 @@ cmGeneratorTarget::GetSourceDepends(cmSourceFile const* sf) const
return 0; return 0;
} }
static void handleSystemIncludesDep(cmMakefile *mf, cmTarget* depTgt, static void handleSystemIncludesDep(cmMakefile *mf, cmTarget const* depTgt,
const std::string& config, const std::string& config,
cmTarget *headTarget, cmTarget *headTarget,
cmGeneratorExpressionDAGChecker *dagChecker, cmGeneratorExpressionDAGChecker *dagChecker,
@ -449,7 +449,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
if (iter == this->SystemIncludesCache.end()) if (iter == this->SystemIncludesCache.end())
{ {
cmTarget::LinkImplementation const* impl cmTarget::LinkImplementation const* impl
= this->Target->GetLinkImplementation(config, this->Target); = this->Target->GetLinkImplementation(config);
if(!impl) if(!impl)
{ {
return false; return false;
@ -474,11 +474,11 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
&dagChecker), result); &dagChecker), result);
} }
std::set<cmTarget*> uniqueDeps; std::set<cmTarget const*> uniqueDeps;
for(std::vector<std::string>::const_iterator li = impl->Libraries.begin(); for(std::vector<cmLinkItem>::const_iterator li = impl->Libraries.begin();
li != impl->Libraries.end(); ++li) li != impl->Libraries.end(); ++li)
{ {
cmTarget* tgt = this->Makefile->FindTargetToUse(*li); cmTarget const* tgt = li->Target;
if (!tgt) if (!tgt)
{ {
continue; continue;
@ -489,10 +489,10 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
handleSystemIncludesDep(this->Makefile, tgt, config, this->Target, handleSystemIncludesDep(this->Makefile, tgt, config, this->Target,
&dagChecker, result, excludeImported); &dagChecker, result, excludeImported);
std::vector<cmTarget*> deps; std::vector<cmTarget const*> deps;
tgt->GetTransitivePropertyTargets(config, this->Target, deps); tgt->GetTransitivePropertyTargets(config, this->Target, deps);
for(std::vector<cmTarget*>::const_iterator di = deps.begin(); for(std::vector<cmTarget const*>::const_iterator di = deps.begin();
di != deps.end(); ++di) di != deps.end(); ++di)
{ {
if (uniqueDeps.insert(*di).second) if (uniqueDeps.insert(*di).second)

2
Source/cmGlobalXCodeGenerator.cxx
View File

@ -1255,7 +1255,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget)
// If the language is compiled as a source trust Xcode to link with it. // If the language is compiled as a source trust Xcode to link with it.
cmTarget::LinkImplementation const* impl = cmTarget::LinkImplementation const* impl =
cmtarget.GetLinkImplementation("NOCONFIG", &cmtarget); cmtarget.GetLinkImplementation("NOCONFIG");
for(std::vector<std::string>::const_iterator li = impl->Languages.begin(); for(std::vector<std::string>::const_iterator li = impl->Languages.begin();
li != impl->Languages.end(); ++li) li != impl->Languages.end(); ++li)
{ {

532
Source/cmTarget.cxx
View File

File diff suppressed because it is too large Load Diff

90
Source/cmTarget.h
View File

@ -43,12 +43,22 @@ class cmTarget;
class cmGeneratorTarget; class cmGeneratorTarget;
class cmTargetTraceDependencies; class cmTargetTraceDependencies;
struct cmTargetLinkInformationMap: // Basic information about each link item.
public std::map<std::pair<cmTarget const* , std::string>, class cmLinkItem: public std::string
cmComputeLinkInformation*>
{ {
typedef std::map<std::pair<cmTarget const* , std::string>, typedef std::string std_string;
cmComputeLinkInformation*> derived; public:
cmLinkItem(): std_string(), Target(0) {}
cmLinkItem(const std_string& n,
cmTarget const* t): std_string(n), Target(t) {}
cmLinkItem(cmLinkItem const& r): std_string(r), Target(r.Target) {}
cmTarget const* Target;
};
struct cmTargetLinkInformationMap:
public std::map<std::string, cmComputeLinkInformation*>
{
typedef std::map<std::string, cmComputeLinkInformation*> derived;
cmTargetLinkInformationMap() {} cmTargetLinkInformationMap() {}
cmTargetLinkInformationMap(cmTargetLinkInformationMap const& r); cmTargetLinkInformationMap(cmTargetLinkInformationMap const& r);
~cmTargetLinkInformationMap(); ~cmTargetLinkInformationMap();
@ -159,12 +169,6 @@ public:
return this->LinkLibraries;} return this->LinkLibraries;}
const LinkLibraryVectorType &GetOriginalLinkLibraries() const const LinkLibraryVectorType &GetOriginalLinkLibraries() const
{return this->OriginalLinkLibraries;} {return this->OriginalLinkLibraries;}
void GetDirectLinkLibraries(const std::string& config,
std::vector<std::string> &,
cmTarget const* head) const;
void GetInterfaceLinkLibraries(const std::string& config,
std::vector<std::string> &,
cmTarget const* head) const;
/** Compute the link type to use for the given configuration. */ /** Compute the link type to use for the given configuration. */
LinkLibraryType ComputeLinkType(const std::string& config) const; LinkLibraryType ComputeLinkType(const std::string& config) const;
@ -221,6 +225,7 @@ public:
void AddUtility(const std::string& u, cmMakefile *makefile = 0); void AddUtility(const std::string& u, cmMakefile *makefile = 0);
///! Get the utilities used by this target ///! Get the utilities used by this target
std::set<std::string>const& GetUtilities() const { return this->Utilities; } std::set<std::string>const& GetUtilities() const { return this->Utilities; }
std::set<cmLinkItem>const& GetUtilityItems() const;
cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
/** Finalize the target at the end of the Configure step. */ /** Finalize the target at the end of the Configure step. */
@ -252,10 +257,10 @@ public:
std::vector<std::string> Languages; std::vector<std::string> Languages;
// Libraries listed in the interface. // Libraries listed in the interface.
std::vector<std::string> Libraries; std::vector<cmLinkItem> Libraries;
// Shared library dependencies needed for linking on some platforms. // Shared library dependencies needed for linking on some platforms.
std::vector<std::string> SharedDeps; std::vector<cmLinkItem> SharedDeps;
// Number of repetitions of a strongly connected component of two // Number of repetitions of a strongly connected component of two
// or more static libraries. // or more static libraries.
@ -263,7 +268,7 @@ public:
// Libraries listed for other configurations. // Libraries listed for other configurations.
// Needed only for OLD behavior of CMP0003. // Needed only for OLD behavior of CMP0003.
std::vector<std::string> WrongConfigLibraries; std::vector<cmLinkItem> WrongConfigLibraries;
bool ImplementationIsInterface; bool ImplementationIsInterface;
@ -277,11 +282,10 @@ public:
LinkInterface const* GetLinkInterfaceLibraries(const std::string& config, LinkInterface const* GetLinkInterfaceLibraries(const std::string& config,
cmTarget const* headTarget) const; cmTarget const* headTarget) const;
void GetTransitivePropertyTargets(const std::string& config, void GetTransitivePropertyTargets(const std::string& config,
cmTarget const* headTarget, cmTarget const* headTarget,
std::vector<cmTarget*> &libs) const; std::vector<cmTarget const*> &libs) const;
void GetTransitiveTargetClosure(const std::string& config, std::vector<cmTarget const*> const&
cmTarget const* headTarget, GetLinkImplementationClosure(const std::string& config) const;
std::vector<cmTarget*> &libs) const;
/** The link implementation specifies the direct library /** The link implementation specifies the direct library
dependencies needed by the object files of the target. */ dependencies needed by the object files of the target. */
@ -291,18 +295,17 @@ public:
std::vector<std::string> Languages; std::vector<std::string> Languages;
// Libraries linked directly in this configuration. // Libraries linked directly in this configuration.
std::vector<std::string> Libraries; std::vector<cmLinkItem> Libraries;
// Libraries linked directly in other configurations. // Libraries linked directly in other configurations.
// Needed only for OLD behavior of CMP0003. // Needed only for OLD behavior of CMP0003.
std::vector<std::string> WrongConfigLibraries; std::vector<cmLinkItem> WrongConfigLibraries;
}; };
LinkImplementation const* GetLinkImplementation(const std::string& config, LinkImplementation const*
cmTarget const* head) const; GetLinkImplementation(const std::string& config) const;
LinkImplementation const* GetLinkImplementationLibraries( LinkImplementation const*
const std::string& config, GetLinkImplementationLibraries(const std::string& config) const;
cmTarget const* head) const;
/** Link information from the transitive closure of the link /** Link information from the transitive closure of the link
implementation and the interfaces of its dependencies. */ implementation and the interfaces of its dependencies. */
@ -314,8 +317,9 @@ public:
// Languages whose runtime libraries must be linked. // Languages whose runtime libraries must be linked.
std::vector<std::string> Languages; std::vector<std::string> Languages;
}; };
LinkClosure const* GetLinkClosure(const std::string& config, LinkClosure const* GetLinkClosure(const std::string& config) const;
cmTarget const* head) const;
cmTarget const* FindTargetToLink(std::string const& name) const;
/** Strip off leading and trailing whitespace from an item named in /** Strip off leading and trailing whitespace from an item named in
the link dependencies of this target. */ the link dependencies of this target. */
@ -361,8 +365,7 @@ public:
GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const; GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const;
///! Return the preferred linker language for this target ///! Return the preferred linker language for this target
std::string GetLinkerLanguage(const std::string& config = "", std::string GetLinkerLanguage(const std::string& config = "") const;
cmTarget const* head = 0) const;
/** Get the full name of the target according to the settings in its /** Get the full name of the target according to the settings in its
makefile. */ makefile. */
@ -446,8 +449,8 @@ public:
* install tree. For example: "\@rpath/" or "\@loader_path/". */ * install tree. For example: "\@rpath/" or "\@loader_path/". */
std::string GetInstallNameDirForInstallTree() const; std::string GetInstallNameDirForInstallTree() const;
cmComputeLinkInformation* GetLinkInformation(const std::string& config, cmComputeLinkInformation*
cmTarget const* head = 0) const; GetLinkInformation(const std::string& config) const;
// Get the properties // Get the properties
cmPropertyMap &GetProperties() const { return this->Properties; } cmPropertyMap &GetProperties() const { return this->Properties; }
@ -740,10 +743,9 @@ private:
// Cache import information from properties for each configuration. // Cache import information from properties for each configuration.
struct ImportInfo; struct ImportInfo;
ImportInfo const* GetImportInfo(const std::string& config, ImportInfo const* GetImportInfo(const std::string& config) const;
cmTarget const* workingTarget) const; void ComputeImportInfo(std::string const& desired_config,
void ComputeImportInfo(std::string const& desired_config, ImportInfo& info, ImportInfo& info) const;
cmTarget const* head) const;
// Cache target compile paths for each configuration. // Cache target compile paths for each configuration.
struct CompileInfo; struct CompileInfo;
@ -753,19 +755,31 @@ private:
void CheckPropertyCompatibility(cmComputeLinkInformation *info, void CheckPropertyCompatibility(cmComputeLinkInformation *info,
const std::string& config) const; const std::string& config) const;
LinkInterface const*
GetImportLinkInterface(const std::string& config,
cmTarget const* head) const;
const char* ComputeLinkInterfaceLibraries(const std::string& config, const char* ComputeLinkInterfaceLibraries(const std::string& config,
LinkInterface& iface, LinkInterface& iface,
cmTarget const* head, cmTarget const* head,
bool &exists) const; bool &exists) const;
LinkImplementation const*
GetLinkImplementationLibrariesInternal(const std::string& config,
cmTarget const* head) const;
void ComputeLinkImplementation(const std::string& config, void ComputeLinkImplementation(const std::string& config,
LinkImplementation& impl, LinkImplementation& impl,
cmTarget const* head) const; cmTarget const* head) const;
void ComputeLinkImplementationLanguages(const std::string& config, void ComputeLinkImplementationLanguages(const std::string& config,
LinkImplementation& impl, LinkImplementation& impl,
cmTarget const* head) const; cmTarget const* head) const;
void ComputeLinkClosure(const std::string& config, LinkClosure& lc, void ComputeLinkClosure(const std::string& config, LinkClosure& lc) const;
cmTarget const* head) const;
void ExpandLinkItems(std::string const& prop, std::string const& value,
std::string const& config, cmTarget const* headTarget,
std::vector<cmLinkItem>& items) const;
void LookupLinkItems(std::vector<std::string> const& names,
std::vector<cmLinkItem>& items) const;
std::string ProcessSourceItemCMP0049(const std::string& s); std::string ProcessSourceItemCMP0049(const std::string& s);

12
Tests/InterfaceLibrary/CMakeLists.txt
View File

@ -8,8 +8,18 @@ target_compile_definitions(iface_nodepends INTERFACE IFACE_DEFINE)
add_subdirectory(headerdir) add_subdirectory(headerdir)
# Add an interface target in a subdirectory that uses an imported interface.
add_subdirectory(ifacedir)
# Poison an imported interface with the same name as that in the subdir
# to ensure that the transitive lookup occurs in the subdir.
add_library(imp::iface INTERFACE IMPORTED)
set_property(TARGET imp::iface APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL SOMEPROP)
set_property(TARGET imp::iface PROPERTY INTERFACE_SOMEPROP OFF)
set_property(TARGET imp::iface PROPERTY INTERFACE_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/does_not_exist.cpp)
add_executable(InterfaceLibrary definetestexe.cpp) add_executable(InterfaceLibrary definetestexe.cpp)
target_link_libraries(InterfaceLibrary iface_nodepends headeriface) target_link_libraries(InterfaceLibrary iface_nodepends headeriface subiface)
add_subdirectory(libsdir) add_subdirectory(libsdir)

4
Tests/InterfaceLibrary/definetestexe.cpp
View File

@ -15,7 +15,9 @@
#error Expected IFACE_HEADER_BUILDDIR #error Expected IFACE_HEADER_BUILDDIR
#endif #endif
extern int sub();
int main(int,char**) int main(int,char**)
{ {
return 0; return sub();
} }

8
Tests/InterfaceLibrary/ifacedir/CMakeLists.txt Normal file
View File

@ -0,0 +1,8 @@
add_library(imp::iface INTERFACE IMPORTED)
set_property(TARGET imp::iface APPEND PROPERTY COMPATIBLE_INTERFACE_BOOL SOMEPROP)
set_property(TARGET imp::iface PROPERTY INTERFACE_SOMEPROP ON)
set_property(TARGET imp::iface PROPERTY INTERFACE_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/sub.cpp)
add_library(subiface INTERFACE)
target_link_libraries(subiface INTERFACE imp::iface)
set_property(TARGET subiface PROPERTY INTERFACE_SOMEPROP ON)

1
Tests/InterfaceLibrary/ifacedir/sub.cpp Normal file
View File

@ -0,0 +1 @@
int sub() { return 0; }