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

Move GetLinkInformation to cmGeneratorTarget

This commit is contained in:
Stephen Kelly 2012-09-15 23:54:01 +02:00
parent 987e12e2f9
commit 4f5384e75c
13 changed files with 95 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
Source/cmGeneratorTarget.cxx
View File

@ -14,9 +14,12 @@
#include "cmTarget.h"
#include "cmMakefile.h"
#include "cmLocalGenerator.h"
#include "cmComputeLinkInformation.h"
#include "cmGlobalGenerator.h"
#include "cmSourceFile.h"
#include <assert.h>
//----------------------------------------------------------------------------
cmGeneratorTarget::cmGeneratorTarget(cmTarget* t): Target(t)
{
@ -27,6 +30,15 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t): Target(t)
this->LookupObjectLibraries();
}
cmGeneratorTarget::~cmGeneratorTarget()
{
for(std::map<cmStdString, cmComputeLinkInformation*>::iterator i
= LinkInformation.begin(); i != LinkInformation.end(); ++i)
{
delete i->second;
}
}
//----------------------------------------------------------------------------
int cmGeneratorTarget::GetType() const
{
@ -277,3 +289,29 @@ void cmGeneratorTarget::GenerateTargetManifest(const char* config)
gg->AddToManifest(config? config:"", f);
}
}
//----------------------------------------------------------------------------
cmComputeLinkInformation*
cmGeneratorTarget::GetLinkInformation(const char* config)
{
// Lookup any existing information for this configuration.
std::map<cmStdString, cmComputeLinkInformation*>::iterator
i = this->LinkInformation.find(config?config:"");
if(i == this->LinkInformation.end())
{
// Compute information for this configuration.
cmComputeLinkInformation* info =
new cmComputeLinkInformation(this->Target, config);
if(!info || !info->Compute())
{
delete info;
info = 0;
}
// Store the information for this configuration.
std::map<cmStdString, cmComputeLinkInformation*>::value_type
entry(config?config:"", info);
i = this->LinkInformation.insert(entry).first;
}
return i->second;
}

6
Source/cmGeneratorTarget.h
View File

@ -14,6 +14,7 @@
#include "cmStandardIncludes.h"
class cmComputeLinkInformation;
class cmCustomCommand;
class cmGlobalGenerator;
class cmLocalGenerator;
@ -25,6 +26,7 @@ class cmGeneratorTarget
{
public:
cmGeneratorTarget(cmTarget*);
~cmGeneratorTarget();
int GetType() const;
const char *GetName() const;
@ -61,6 +63,10 @@ public:
/** Add the target output files to the global generator manifest. */
void GenerateTargetManifest(const char* config);
std::map<cmStdString, cmComputeLinkInformation*> LinkInformation;
cmComputeLinkInformation* GetLinkInformation(const char* config);
private:
void ClassifySources();
void LookupObjectLibraries();

3
Source/cmGlobalXCodeGenerator.cxx
View File

@ -2625,7 +2625,8 @@ void cmGlobalXCodeGenerator
}
// Compute the link library and directory information.
cmComputeLinkInformation* pcli = cmtarget->GetLinkInformation(configName);
cmGeneratorTarget* gtgt = this->GetGeneratorTarget(cmtarget);
cmComputeLinkInformation* pcli = gtgt->GetLinkInformation(configName);
if(!pcli)
{
continue;

30
Source/cmInstallTargetGenerator.cxx
View File

@ -16,6 +16,7 @@
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmake.h"
#include "cmGeneratorTarget.h"
#include <assert.h>
@ -26,7 +27,8 @@ cmInstallTargetGenerator
std::vector<std::string> const& configurations,
const char* component, bool optional):
cmInstallGenerator(dest, configurations, component), Target(&t),
ImportLibrary(implib), FilePermissions(file_permissions), Optional(optional)
ImportLibrary(implib), FilePermissions(file_permissions),
Optional(optional), GeneratorTarget(0)
{
this->ActionsPerConfig = true;
this->NamelinkMode = NamelinkModeNone;
@ -484,6 +486,17 @@ void cmInstallTargetGenerator::PostReplacementTweaks(std::ostream& os,
this->AddStripRule(os, indent, file);
}
void cmInstallTargetGenerator::CreateGeneratorTarget()
{
if (!this->GeneratorTarget)
{
this->GeneratorTarget = this->Target->GetMakefile()
->GetLocalGenerator()
->GetGlobalGenerator()
->GetGeneratorTarget(this->Target);
}
}
//----------------------------------------------------------------------------
void
cmInstallTargetGenerator
@ -507,10 +520,13 @@ cmInstallTargetGenerator
return;
}
this->CreateGeneratorTarget();
// Build a map of build-tree install_name to install-tree install_name for
// shared libraries linked to this target.
std::map<cmStdString, cmStdString> install_name_remap;
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config))
if(cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(config))
{
std::set<cmTarget*> const& sharedLibs = cli->GetSharedLibrariesLinked();
for(std::set<cmTarget*>::const_iterator j = sharedLibs.begin();
@ -608,9 +624,12 @@ cmInstallTargetGenerator
return;
}
this->CreateGeneratorTarget();
// Get the link information for this target.
// It can provide the RPATH.
cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(config);
if(!cli)
{
return;
@ -639,9 +658,12 @@ cmInstallTargetGenerator
return;
}
this->CreateGeneratorTarget();
// Get the link information for this target.
// It can provide the RPATH.
cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(config);
if(!cli)
{
return;

5
Source/cmInstallTargetGenerator.h
View File

@ -15,6 +15,8 @@
#include "cmInstallGenerator.h"
#include "cmTarget.h"
class cmGeneratorTarget;
/** \class cmInstallTargetGenerator
* \brief Generate target installation rules.
*/
@ -92,7 +94,10 @@ protected:
void AddRanlibRule(std::ostream& os, Indent const& indent,
const std::string& toDestDirPath);
void CreateGeneratorTarget();
cmTarget* Target;
cmGeneratorTarget* GeneratorTarget;
bool ImportLibrary;
std::string FilePermissions;
bool Optional;

5
Source/cmLocalGenerator.cxx
View File

@ -1656,7 +1656,8 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
bool relink)
{
const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE");
cmComputeLinkInformation* pcli = tgt.GetLinkInformation(config);
cmGeneratorTarget* gtgt = this->GlobalGenerator->GetGeneratorTarget(&tgt);
cmComputeLinkInformation* pcli = gtgt->GetLinkInformation(config);
if(!pcli)
{
return;
@ -1677,7 +1678,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_";
linkFlagsVar += linkLanguage;
linkFlagsVar += "_FLAGS";
if( tgt.GetType() == cmTarget::EXECUTABLE )
if( gtgt->GetType() == cmTarget::EXECUTABLE )
{
linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar.c_str());
linkLibs += " ";

4
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -1776,8 +1776,10 @@ void cmLocalVisualStudio6Generator
const std::string extraOptions,
std::string& options)
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
// Compute the link information for this configuration.
cmComputeLinkInformation* pcli = target.GetLinkInformation(configName);
cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
if(!pcli)
{
return;

8
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -1079,7 +1079,9 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
targetNameImport, targetNamePDB, configName);
// Compute the link library and directory information.
cmComputeLinkInformation* pcli = target.GetLinkInformation(configName);
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
if(!pcli)
{
return;
@ -1164,7 +1166,9 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
targetNameImport, targetNamePDB, configName);
// Compute the link library and directory information.
cmComputeLinkInformation* pcli = target.GetLinkInformation(configName);
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
if(!pcli)
{
return;

6
Source/cmMakefileTargetGenerator.cxx
View File

@ -1022,7 +1022,8 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
<< "SET(CMAKE_TARGET_LINKED_INFO_FILES\n";
std::set<cmTarget const*> emitted;
const char* cfg = this->LocalGenerator->ConfigurationName.c_str();
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(cfg))
if(cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(cfg))
{
cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
for(cmComputeLinkInformation::ItemVector::const_iterator
@ -1590,7 +1591,8 @@ void cmMakefileTargetGenerator
// Loop over all library dependencies.
const char* cfg = this->LocalGenerator->ConfigurationName.c_str();
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(cfg))
if(cmComputeLinkInformation* cli =
this->GeneratorTarget->GetLinkInformation(cfg))
{
std::vector<std::string> const& libDeps = cli->GetDepends();
for(std::vector<std::string>::const_iterator j = libDeps.begin();

2
Source/cmNinjaTargetGenerator.cxx
View File

@ -231,7 +231,7 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
return cmNinjaDeps();
cmComputeLinkInformation* cli =
this->Target->GetLinkInformation(this->GetConfigName());
this->GeneratorTarget->GetLinkInformation(this->GetConfigName());
if(!cli)
return cmNinjaDeps();

50
Source/cmTarget.cxx
View File

@ -15,7 +15,6 @@
#include "cmSourceFile.h"
#include "cmLocalGenerator.h"
#include "cmGlobalGenerator.h"
#include "cmComputeLinkInformation.h"
#include "cmDocumentCompileDefinitions.h"
#include "cmDocumentLocationUndefined.h"
#include "cmListFileCache.h"
@ -4600,32 +4599,6 @@ std::string cmTarget::CheckCMP0004(std::string const& item)
return lib;
}
//----------------------------------------------------------------------------
cmComputeLinkInformation*
cmTarget::GetLinkInformation(const char* config)
{
// Lookup any existing information for this configuration.
std::map<cmStdString, cmComputeLinkInformation*>::iterator
i = this->LinkInformation.find(config?config:"");
if(i == this->LinkInformation.end())
{
// Compute information for this configuration.
cmComputeLinkInformation* info =
new cmComputeLinkInformation(this, config);
if(!info || !info->Compute())
{
delete info;
info = 0;
}
// Store the information for this configuration.
std::map<cmStdString, cmComputeLinkInformation*>::value_type
entry(config?config:"", info);
i = this->LinkInformation.insert(entry).first;
}
return i->second;
}
//----------------------------------------------------------------------------
std::vector<std::string> cmTarget::GetIncludeDirectories()
{
@ -4707,29 +4680,6 @@ std::string cmTarget::GetMacContentDirectory(const char* config,
return fpath;
}
//----------------------------------------------------------------------------
cmTargetLinkInformationMap
::cmTargetLinkInformationMap(cmTargetLinkInformationMap const& r): derived()
{
// Ideally cmTarget instances should never be copied. However until
// we can make a sweep to remove that, this copy constructor avoids
// allowing the resources (LinkInformation) from getting copied. In
// the worst case this will lead to extra cmComputeLinkInformation
// instances. We also enforce in debug mode that the map be emptied
// when copied.
static_cast<void>(r);
assert(r.empty());
}
//----------------------------------------------------------------------------
cmTargetLinkInformationMap::~cmTargetLinkInformationMap()
{
for(derived::iterator i = this->begin(); i != this->end(); ++i)
{
delete i->second;
}
}
//----------------------------------------------------------------------------
cmTargetInternalPointer::cmTargetInternalPointer()
{

14
Source/cmTarget.h
View File

@ -22,18 +22,8 @@ class cmake;
class cmMakefile;
class cmSourceFile;
class cmGlobalGenerator;
class cmComputeLinkInformation;
class cmListFileBacktrace;
struct cmTargetLinkInformationMap:
public std::map<cmStdString, cmComputeLinkInformation*>
{
typedef std::map<cmStdString, cmComputeLinkInformation*> derived;
cmTargetLinkInformationMap() {}
cmTargetLinkInformationMap(cmTargetLinkInformationMap const& r);
~cmTargetLinkInformationMap();
};
class cmTargetInternals;
class cmTargetInternalPointer
{
@ -397,8 +387,6 @@ public:
std::string GetInstallNameDirForInstallTree(const char* config,
bool for_xcode = false);
cmComputeLinkInformation* GetLinkInformation(const char* config);
// Get the properties
cmPropertyMap &GetProperties() { return this->Properties; };
@ -596,8 +584,6 @@ private:
ImportInfo const* GetImportInfo(const char* config);
void ComputeImportInfo(std::string const& desired_config, ImportInfo& info);
cmTargetLinkInformationMap LinkInformation;
bool ComputeLinkInterface(const char* config, LinkInterface& iface);
void ComputeLinkImplementation(const char* config,

2
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -1452,7 +1452,7 @@ void cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const&
// Replace spaces in libs with ;
cmSystemTools::ReplaceString(libs, " ", ";");
cmComputeLinkInformation* pcli =
this->Target->GetLinkInformation(config.c_str());
this->GeneratorTarget->GetLinkInformation(config.c_str());
if(!pcli)
{
cmSystemTools::Error