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

Merge topic 'refactor-install'

Browse Source 
a23fcc95 cmInstallTargetGenerator: Port to cmGeneratorTarget.
4e41913f cmInstallCommand: Store only a targetName, not a cmTarget.
e5e52970 cmInstallGenerator: Add a Compute() virtual hook.
3ef8aaaa cmInstallCommand: Move the SetHaveInstallRule invocation.
5f662b38 cmScriptGenerator: Remove unused method.
0368552d cmGlobalGenerator: Move QtAutogen handling to Compute().
5edb3354 cmGlobalGenerator: Virtualize the Compute step and override it.
ff1019bf cmGlobalGenerator: Move generation object creation to Compute().
aa2407d8 Xcode: Use allBuild target return value.
610572b7 cmMakefile: Simplify generate-time cmGeneratorTarget creation.
2e94cba3 cmGlobalGenerator: Move FinalizeTargetCompileInfo to Compute().
fb9355c5 cmGlobalGenerator: Return from Compute whether to generate.
29e8b7bf cmGlobalGenerator: Create a new Compute step before generation.
1ef9b2b6 cmGlobalGenerator: Remove the TargetManifest member.
5c14f780 cmGlobalGenerator: Remove unused manifest accessor.
a1209be5 VisualStudio: Skip global targets when processing.
...
This commit is contained in:
Brad King 2015-07-31 09:21:45 -04:00 committed by CMake Topic Stage
commit 82e77d7430
24 changed files with 215 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmExportInstallFileGenerator.cxx
View File

@ -398,7 +398,7 @@ cmExportInstallFileGenerator
}
// Get the target to be installed.
cmTarget* target = itgen->GetTarget();
cmTarget* target = itgen->GetTarget()->Target;
// Construct the installed location of the target.
std::string dest = itgen->GetDestination(config);

10
Source/cmGeneratorTarget.cxx
View File

@ -1150,35 +1150,35 @@ void cmGeneratorTarget::GenerateTargetManifest(
f = dir;
f += "/";
f += name;
gg->AddToManifest(config, f);
gg->AddToManifest(f);
}
if(!soName.empty())
{
f = dir;
f += "/";
f += soName;
gg->AddToManifest(config, f);
gg->AddToManifest(f);
}
if(!realName.empty())
{
f = dir;
f += "/";
f += realName;
gg->AddToManifest(config, f);
gg->AddToManifest(f);
}
if(!pdbName.empty())
{
f = dir;
f += "/";
f += pdbName;
gg->AddToManifest(config, f);
gg->AddToManifest(f);
}
if(!impName.empty())
{
f = this->Target->GetDirectory(config, true);
f += "/";
f += impName;
gg->AddToManifest(config, f);
gg->AddToManifest(f);
}
}

35
Source/cmGlobalGenerator.cxx
View File

@ -34,6 +34,7 @@
#include "cmExportBuildFileGenerator.h"
#include "cmCPackPropertiesGenerator.h"
#include "cmAlgorithms.h"
#include "cmInstallGenerator.h"
#include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx>
@ -1212,7 +1213,7 @@ bool cmGlobalGenerator::CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const
return false;
}
void cmGlobalGenerator::DoGenerate()
bool cmGlobalGenerator::Compute()
{
// Some generators track files replaced during the Generate.
// Start with an empty vector:
@ -1221,17 +1222,11 @@ void cmGlobalGenerator::DoGenerate()
// clear targets to issue warning CMP0042 for
this->CMP0042WarnTargets.clear();
this->Generate();
}
void cmGlobalGenerator::Generate()
{
// Check whether this generator is allowed to run.
if(!this->CheckALLOW_DUPLICATE_CUSTOM_TARGETS())
{
return;
return false;
}
this->FinalizeTargetCompileInfo();
this->CreateGenerationObjects();
@ -1266,6 +1261,24 @@ void cmGlobalGenerator::Generate()
}
#endif
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
cmMakefile* mf = this->LocalGenerators[i]->GetMakefile();
std::vector<cmInstallGenerator*>& gens = mf->GetInstallGenerators();
for (std::vector<cmInstallGenerator*>::const_iterator git = gens.begin();
git != gens.end(); ++git)
{
(*git)->Compute(this->LocalGenerators[i]);
}
}
return true;
}
void cmGlobalGenerator::Generate()
{
unsigned int i;
// Trace the dependencies, after that no custom commands should be added
// because their dependencies might not be handled correctly
for (i = 0; i < this->LocalGenerators.size(); ++i)
@ -2698,12 +2711,8 @@ void cmGlobalGenerator::AddTargetDepends(cmGeneratorTarget const* target,
//----------------------------------------------------------------------------
void cmGlobalGenerator::AddToManifest(const std::string& config,
std::string const& f)
void cmGlobalGenerator::AddToManifest(std::string const& f)
{
// Add to the main manifest for this configuration.
this->TargetManifest[config].insert(f);
// Add to the content listing for the file's directory.
std::string dir = cmSystemTools::GetFilenamePath(f);
std::string file = cmSystemTools::GetFilenameName(f);

16
Source/cmGlobalGenerator.h
View File

@ -86,6 +86,7 @@ public:
*/
virtual void Configure();
virtual bool Compute();
enum TargetTypes {
AllTargets,
@ -99,7 +100,7 @@ public:
* basically creates a series of LocalGenerators for each directory and
* requests that they Generate.
*/
void DoGenerate();
virtual void Generate();
/**
* Set/Get and Clear the enabled languages.
@ -200,7 +201,7 @@ public:
cmExportSetMap& GetExportSets() {return this->ExportSets;}
/** Add a file to the manifest of generated targets for a configuration. */
void AddToManifest(const std::string& config, std::string const& f);
void AddToManifest(std::string const& f);
void EnableInstallTarget();
@ -264,11 +265,6 @@ public:
const std::string& suffix,
std::string& dir);
/** Get the manifest of all targets that will be built for each
configuration. This is valid during generation only. */
cmTargetManifest const& GetTargetManifest() const
{ return this->TargetManifest; }
/** Get the content of a directory. Directory listings are cached
and re-loaded from disk only when modified. During the generation
step the content will include the target files to be built even if
@ -373,8 +369,6 @@ public:
std::string MakeSilentFlag;
protected:
virtual void Generate();
typedef std::vector<cmLocalGenerator*> GeneratorVector;
// for a project collect all its targets by following depend
// information, and also collect all the targets
@ -429,10 +423,6 @@ protected:
std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets;
std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets;
// Manifest of all targets that will be built for each configuration.
// This is computed just before local generators generate.
cmTargetManifest TargetManifest;
// All targets in the entire project.
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX11_UNORDERED_MAP

11
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -314,9 +314,18 @@ cmGlobalVisualStudio10Generator::CreateLocalGenerator(cmLocalGenerator* parent,
}
//----------------------------------------------------------------------------
bool cmGlobalVisualStudio10Generator::Compute()
{
if (!cmGlobalVisualStudio8Generator::Compute())
{
return false;
}
this->LongestSource = LongestSourcePath();
return true;
}
void cmGlobalVisualStudio10Generator::Generate()
{
this->LongestSource = LongestSourcePath();
this->cmGlobalVisualStudio8Generator::Generate();
if(this->LongestSource.Length > 0)
{

2
Source/cmGlobalVisualStudio10Generator.h
View File

@ -45,6 +45,8 @@ public:
std::vector<std::string> const& makeOptions = std::vector<std::string>()
);
virtual bool Compute();
///! create the correct local generator
virtual cmLocalGenerator *CreateLocalGenerator(cmLocalGenerator* parent,
cmState::Snapshot snapshot);

13
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -254,6 +254,8 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false,
no_working_directory, no_depends,
noCommandLines);
cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg);
mf->AddGeneratorTarget(tgt, gt);
// Organize in the "predefined targets" folder:
//
@ -345,8 +347,13 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator::Generate()
bool cmGlobalVisualStudio8Generator::Compute()
{
if (!cmGlobalVisualStudio7Generator::Compute())
{
return false;
}
if(this->AddCheckTarget())
{
// All targets depend on the build-system check target.
@ -360,9 +367,7 @@ void cmGlobalVisualStudio8Generator::Generate()
}
}
}
// Now perform the main generation.
this->cmGlobalVisualStudio7Generator::Generate();
return true;
}
//----------------------------------------------------------------------------

2
Source/cmGlobalVisualStudio8Generator.h
View File

@ -67,7 +67,7 @@ public:
return !this->WindowsCEVersion.empty(); }
protected:
virtual void Generate();
virtual bool Compute();
virtual const char* GetIDEVersion() { return "8.0"; }
virtual std::string FindDevEnvCommand();

17
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -64,8 +64,13 @@ std::string cmGlobalVisualStudioGenerator::GetRegistryBase(
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudioGenerator::Generate()
bool cmGlobalVisualStudioGenerator::Compute()
{
if (!cmGlobalGenerator::Compute())
{
return false;
}
// Add a special target that depends on ALL projects for easy build
// of one configuration only.
const char* no_working_dir = 0;
@ -85,6 +90,8 @@ void cmGlobalVisualStudioGenerator::Generate()
AddUtilityCommand("ALL_BUILD", true, no_working_dir,
no_depends, no_commands, false,
"Build all projects");
cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]);
allBuild->GetMakefile()->AddGeneratorTarget(allBuild, gt);
#if 0
// Can't activate this code because we want ALL_BUILD
@ -108,6 +115,10 @@ void cmGlobalVisualStudioGenerator::Generate()
for(cmTargets::iterator t = targets.begin();
t != targets.end(); ++t)
{
if (t->second.GetType() == cmTarget::GLOBAL_TARGET)
{
continue;
}
if(!this->IsExcluded(gen[0], t->second))
{
allBuild->AddUtility(t->second.GetName());
@ -130,9 +141,7 @@ void cmGlobalVisualStudioGenerator::Generate()
static_cast<cmLocalVisualStudioGenerator*>(*lgi);
lg->AddCMakeListsRules();
}
// Run all the local generators.
this->cmGlobalGenerator::Generate();
return true;
}
//----------------------------------------------------------------------------

2
Source/cmGlobalVisualStudioGenerator.h
View File

@ -108,7 +108,7 @@ public:
cmGeneratorTarget*, std::vector<cmCustomCommand>& commands,
std::string const& configName);
protected:
virtual void Generate();
virtual bool Compute();
// Does this VS version link targets to each other if there are
// dependencies in the SLN file? This was done for VS versions

28
Source/cmGlobalXCodeGenerator.cxx
View File

@ -378,8 +378,13 @@ cmGlobalXCodeGenerator::CreateLocalGenerator(cmLocalGenerator* parent,
}
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::Generate()
bool cmGlobalXCodeGenerator::Compute()
{
if (!cmGlobalGenerator::Compute())
{
return false;
}
std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
// make sure extra targets are added before calling
// the parent generate which will call trace depends
@ -390,11 +395,17 @@ void cmGlobalXCodeGenerator::Generate()
// add ALL_BUILD, INSTALL, etc
this->AddExtraTargets(root, it->second);
}
return true;
}
void cmGlobalXCodeGenerator::Generate()
{
this->cmGlobalGenerator::Generate();
if(cmSystemTools::GetErrorOccuredFlag())
{
return;
}
std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
{
cmLocalGenerator* root = it->second[0];
@ -449,10 +460,11 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
// Add ALL_BUILD
const char* no_working_directory = 0;
std::vector<std::string> no_depends;
mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
cmTarget* allbuild = mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
no_working_directory,
"echo", "Build all projects");
cmTarget* allbuild = mf->FindTarget("ALL_BUILD");
cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root);
mf->AddGeneratorTarget(allbuild, allBuildGt);
// Refer to the main build configuration file for easy editing.
std::string listfile = mf->GetCurrentSourceDirectory();
@ -481,9 +493,12 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
std::string file = this->ConvertToRelativeForMake(
this->CurrentReRunCMakeMakefile.c_str());
cmSystemTools::ReplaceString(file, "\\ ", " ");
mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, true, no_depends,
cmTarget* check = mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET,
true, no_depends,
no_working_directory,
"make", "-f", file.c_str());
cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root);
mf->AddGeneratorTarget(check, checkGt);
}
// now make the allbuild depend on all the non-utility targets
@ -502,6 +517,11 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
{
cmTarget& target = l->second;
if (target.GetType() == cmTarget::GLOBAL_TARGET)
{
continue;
}
if (regenerate && (l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET))
{
target.AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);

1
Source/cmGlobalXCodeGenerator.h
View File

@ -88,6 +88,7 @@ public:
virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
void AppendFlag(std::string& flags, std::string const& flag);
protected:
virtual bool Compute();
virtual void Generate();
private:
cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,

9
Source/cmInstallCommand.cxx
View File

@ -27,7 +27,8 @@ static cmInstallTargetGenerator* CreateInstallTargetGenerator(cmTarget& target,
{
cmInstallGenerator::MessageLevel message =
cmInstallGenerator::SelectMessageLevel(target.GetMakefile());
return new cmInstallTargetGenerator(target, args.GetDestination().c_str(),
return new cmInstallTargetGenerator(target.GetName(),
args.GetDestination().c_str(),
impLib, args.GetPermissions().c_str(),
args.GetConfigurations(), args.GetComponent().c_str(),
message,
@ -752,6 +753,12 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
installsPublicHeader = installsPublicHeader || publicHeaderGenerator != 0;
installsResource = installsResource || resourceGenerator;
if (installsArchive || installsRuntime || installsFramework
|| installsLibrary || installsBundle)
{
target.SetHaveInstallRule(true);
}
this->Makefile->AddInstallGenerator(archiveGenerator);
this->Makefile->AddInstallGenerator(libraryGenerator);
this->Makefile->AddInstallGenerator(runtimeGenerator);

2
Source/cmInstallGenerator.h
View File

@ -62,6 +62,8 @@ public:
/** Select message level from CMAKE_INSTALL_MESSAGE or 'never'. */
static MessageLevel SelectMessageLevel(cmMakefile* mf, bool never = false);
virtual void Compute(cmLocalGenerator*) {}
protected:
virtual void GenerateScript(std::ostream& os);

89
Source/cmInstallTargetGenerator.cxx
View File

@ -16,26 +16,29 @@
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmGeneratorTarget.h"
#include "cmake.h"
#include <assert.h>
//----------------------------------------------------------------------------
cmInstallTargetGenerator
::cmInstallTargetGenerator(cmTarget& t, const char* dest, bool implib,
::cmInstallTargetGenerator(const std::string& targetName,
const char* dest, bool implib,
const char* file_permissions,
std::vector<std::string> const& configurations,
const char* component,
MessageLevel message,
bool optional):
cmInstallGenerator(dest, configurations, component, message), Target(&t),
cmInstallGenerator(dest, configurations, component, message),
TargetName(targetName),
Target(0),
FilePermissions(file_permissions),
ImportLibrary(implib),
Optional(optional)
{
this->ActionsPerConfig = true;
this->NamelinkMode = NamelinkModeNone;
this->Target->SetHaveInstallRule(true);
}
//----------------------------------------------------------------------------
@ -69,15 +72,17 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
{
// Compute the build tree directory from which to copy the target.
std::string fromDirConfig;
if(this->Target->NeedRelinkBeforeInstall(config))
if(this->Target->Target->NeedRelinkBeforeInstall(config))
{
fromDirConfig = this->Target->GetMakefile()->GetCurrentBinaryDirectory();
fromDirConfig =
this->Target->Target->GetMakefile()->GetCurrentBinaryDirectory();
fromDirConfig += cmake::GetCMakeFilesDirectory();
fromDirConfig += "/CMakeRelink.dir/";
}
else
{
fromDirConfig = this->Target->GetDirectory(config, this->ImportLibrary);
fromDirConfig =
this->Target->Target->GetDirectory(config, this->ImportLibrary);
fromDirConfig += "/";
}
std::string toDir =
@ -88,7 +93,8 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
std::vector<std::string> filesFrom;
std::vector<std::string> filesTo;
std::string literal_args;
cmTarget::TargetType targetType = this->Target->GetType();
cmTarget::TargetType targetType =
static_cast<cmTarget::TargetType>(this->Target->GetType());
cmInstallType type = cmInstallType();
switch(targetType)
{
@ -105,7 +111,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
case cmTarget::UTILITY:
case cmTarget::GLOBAL_TARGET:
case cmTarget::UNKNOWN_LIBRARY:
this->Target->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR,
this->Target->Target->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR,
"cmInstallTargetGenerator created with non-installable target.");
return;
}
@ -118,7 +124,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
std::string targetNameReal;
std::string targetNameImport;
std::string targetNamePDB;
this->Target->GetExecutableNames(targetName, targetNameReal,
this->Target->Target->GetExecutableNames(targetName, targetNameReal,
targetNameImport, targetNamePDB,
config);
if(this->ImportLibrary)
@ -128,7 +134,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
filesFrom.push_back(from1);
filesTo.push_back(to1);
std::string targetNameImportLib;
if(this->Target->GetImplibGNUtoMS(targetNameImport,
if(this->Target->Target->GetImplibGNUtoMS(targetNameImport,
targetNameImportLib))
{
filesFrom.push_back(fromDirConfig + targetNameImportLib);
@ -144,7 +150,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
std::string to1 = toDir + targetName;
// Handle OSX Bundles.
if(this->Target->IsAppBundleOnApple())
if(this->Target->Target->IsAppBundleOnApple())
{
// Install the whole app bundle directory.
type = cmInstallType_DIRECTORY;
@ -178,7 +184,8 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
std::string targetNameReal;
std::string targetNameImport;
std::string targetNamePDB;
this->Target->GetLibraryNames(targetName, targetNameSO, targetNameReal,
this->Target->Target->GetLibraryNames(targetName, targetNameSO,
targetNameReal,
targetNameImport, targetNamePDB,
config);
if(this->ImportLibrary)
@ -191,7 +198,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
filesFrom.push_back(from1);
filesTo.push_back(to1);
std::string targetNameImportLib;
if(this->Target->GetImplibGNUtoMS(targetNameImport,
if(this->Target->Target->GetImplibGNUtoMS(targetNameImport,
targetNameImportLib))
{
filesFrom.push_back(fromDirConfig + targetNameImportLib);
@ -201,7 +208,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
// An import library looks like a static library.
type = cmInstallType_STATIC_LIBRARY;
}
else if(this->Target->IsFrameworkOnApple())
else if(this->Target->Target->IsFrameworkOnApple())
{
// There is a bug in cmInstallCommand if this fails.
assert(this->NamelinkMode == NamelinkModeNone);
@ -219,7 +226,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
filesFrom.push_back(from1);
filesTo.push_back(to1);
}
else if(this->Target->IsCFBundleOnApple())
else if(this->Target->Target->IsCFBundleOnApple())
{
// Install the whole app bundle directory.
type = cmInstallType_DIRECTORY;
@ -343,7 +350,7 @@ cmInstallTargetGenerator::GetDestination(std::string const& config) const
{
cmGeneratorExpression ge;
return ge.Parse(this->Destination)
->Evaluate(this->Target->GetMakefile(), config);
->Evaluate(this->Target->Target->GetMakefile(), config);
}
//----------------------------------------------------------------------------
@ -352,7 +359,7 @@ cmInstallTargetGenerator::GetInstallFilename(const std::string& config) const
{
NameType nameType = this->ImportLibrary? NameImplib : NameNormal;
return
cmInstallTargetGenerator::GetInstallFilename(this->Target, config,
cmInstallTargetGenerator::GetInstallFilename(this->Target->Target, config,
nameType);
}
@ -431,6 +438,12 @@ cmInstallTargetGenerator::GetInstallFilename(cmTarget const* target,
return fname;
}
void cmInstallTargetGenerator::Compute(cmLocalGenerator* lg)
{
this->Target = lg->GetGlobalGenerator()->GetGeneratorTarget(
lg->GetMakefile()->FindTarget(this->TargetName));
}
//----------------------------------------------------------------------------
void
cmInstallTargetGenerator
@ -533,8 +546,8 @@ cmInstallTargetGenerator
}
// Fix the install_name settings in installed binaries.
std::string installNameTool =
this->Target->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_NAME_TOOL");
std::string installNameTool = this->Target->Target->GetMakefile()
->GetSafeDefinition("CMAKE_INSTALL_NAME_TOOL");
if(installNameTool.empty())
{
@ -544,7 +557,8 @@ cmInstallTargetGenerator
// Build a map of build-tree install_name to install-tree install_name for
// shared libraries linked to this target.
std::map<std::string, std::string> install_name_remap;
if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config))
if(cmComputeLinkInformation* cli =
this->Target->Target->GetLinkInformation(config))
{
std::set<cmTarget const*> const& sharedLibs
= cli->GetSharedLibrariesLinked();
@ -588,11 +602,11 @@ cmInstallTargetGenerator
if(this->Target->GetType() == cmTarget::SHARED_LIBRARY)
{
std::string for_build =
this->Target->GetInstallNameDirForBuildTree(config);
this->Target->Target->GetInstallNameDirForBuildTree(config);
std::string for_install =
this->Target->GetInstallNameDirForInstallTree();
this->Target->Target->GetInstallNameDirForInstallTree();
if(this->Target->IsFrameworkOnApple() && for_install.empty())
if(this->Target->Target->IsFrameworkOnApple() && for_install.empty())
{
// Frameworks seem to have an id corresponding to their own full
// path.
@ -606,7 +620,7 @@ cmInstallTargetGenerator
{
// Prepare to refer to the install-tree install_name.
new_id = for_install;
new_id += this->GetInstallFilename(this->Target, config, NameSO);
new_id += this->GetInstallFilename(this->Target->Target, config, NameSO);
}
}
@ -639,20 +653,22 @@ cmInstallTargetGenerator
std::string const& toDestDirPath)
{
// Skip the chrpath if the target does not need it.
if(this->ImportLibrary || !this->Target->IsChrpathUsed(config))
if(this->ImportLibrary || !this->Target->Target->IsChrpathUsed(config))
{
return;
}
// Skip if on Apple
if(this->Target->GetMakefile()->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
if(this->Target->Target->GetMakefile()
->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
{
return;
}
// Get the link information for this target.
// It can provide the RPATH.
cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
cmComputeLinkInformation* cli =
this->Target->Target->GetLinkInformation(config);
if(!cli)
{
return;
@ -677,20 +693,21 @@ cmInstallTargetGenerator
std::string const& toDestDirPath)
{
// Skip the chrpath if the target does not need it.
if(this->ImportLibrary || !this->Target->IsChrpathUsed(config))
if(this->ImportLibrary || !this->Target->Target->IsChrpathUsed(config))
{
return;
}
// Get the link information for this target.
// It can provide the RPATH.
cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
cmComputeLinkInformation* cli =
this->Target->Target->GetLinkInformation(config);
if(!cli)
{
return;
}
cmMakefile* mf = this->Target->GetMakefile();
cmMakefile* mf = this->Target->Target->GetMakefile();
if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
{
@ -802,20 +819,20 @@ cmInstallTargetGenerator::AddStripRule(std::ostream& os,
}
// Don't handle OSX Bundles.
if(this->Target->GetMakefile()->IsOn("APPLE") &&
this->Target->GetPropertyAsBool("MACOSX_BUNDLE"))
if(this->Target->Target->GetMakefile()->IsOn("APPLE") &&
this->Target->Target->GetPropertyAsBool("MACOSX_BUNDLE"))
{
return;
}
if(! this->Target->GetMakefile()->IsSet("CMAKE_STRIP"))
if(! this->Target->Target->GetMakefile()->IsSet("CMAKE_STRIP"))
{
return;
}
os << indent << "if(CMAKE_INSTALL_DO_STRIP)\n";
os << indent << " execute_process(COMMAND \""
<< this->Target->GetMakefile()->GetDefinition("CMAKE_STRIP")
<< this->Target->Target->GetMakefile()->GetDefinition("CMAKE_STRIP")
<< "\" \"" << toDestDirPath << "\")\n";
os << indent << "endif()\n";
}
@ -834,13 +851,13 @@ cmInstallTargetGenerator::AddRanlibRule(std::ostream& os,
// Perform post-installation processing on the file depending
// on its type.
if(!this->Target->GetMakefile()->IsOn("APPLE"))
if(!this->Target->Target->GetMakefile()->IsOn("APPLE"))
{
return;
}
std::string ranlib =
this->Target->GetMakefile()->GetRequiredDefinition("CMAKE_RANLIB");
this->Target->Target->GetMakefile()->GetRequiredDefinition("CMAKE_RANLIB");
if(ranlib.empty())
{
return;

14
Source/cmInstallTargetGenerator.h
View File

@ -13,7 +13,9 @@
#define cmInstallTargetGenerator_h
#include "cmInstallGenerator.h"
#include "cmTarget.h"
class cmTarget;
class cmGeneratorTarget;
/** \class cmInstallTargetGenerator
* \brief Generate target installation rules.
@ -22,7 +24,7 @@ class cmInstallTargetGenerator: public cmInstallGenerator
{
public:
cmInstallTargetGenerator(
cmTarget& t, const char* dest, bool implib,
std::string const& targetName, const char* dest, bool implib,
const char* file_permissions,
std::vector<std::string> const& configurations,
const char* component,
@ -56,7 +58,10 @@ public:
const std::string& config,
NameType nameType = NameNormal);
cmTarget* GetTarget() const { return this->Target; }
void Compute(cmLocalGenerator* lg);
cmGeneratorTarget* GetTarget() const { return this->Target; }
bool IsImportLibrary() const { return this->ImportLibrary; }
std::string GetDestination(std::string const& config) const;
@ -98,7 +103,8 @@ protected:
void AddRanlibRule(std::ostream& os, Indent const& indent,
const std::string& toDestDirPath);
cmTarget* Target;
std::string TargetName;
cmGeneratorTarget* Target;
std::string FilePermissions;
NamelinkModeType NamelinkMode;
bool ImportLibrary;

18
Source/cmLocalGenerator.cxx
View File

@ -2375,11 +2375,15 @@ cmLocalGenerator::ConstructComment(cmCustomCommandGenerator const& ccg,
class cmInstallTargetGeneratorLocal: public cmInstallTargetGenerator
{
public:
cmInstallTargetGeneratorLocal(cmTarget& t, const char* dest, bool implib):
cmInstallTargetGeneratorLocal(cmLocalGenerator* lg, std::string const& t,
const char* dest, bool implib):
cmInstallTargetGenerator(
t, dest, implib, "", std::vector<std::string>(), "Unspecified",
cmInstallGenerator::SelectMessageLevel(t.GetMakefile()),
false) {}
cmInstallGenerator::SelectMessageLevel(lg->GetMakefile()),
false)
{
this->Compute(lg);
}
};
//----------------------------------------------------------------------------
@ -2428,7 +2432,7 @@ cmLocalGenerator
{
// Use a target install generator.
cmInstallTargetGeneratorLocal
g(l->second, destination.c_str(), false);
g(this, l->first, destination.c_str(), false);
g.Generate(os, config, configurationTypes);
}
break;
@ -2439,18 +2443,18 @@ cmLocalGenerator
// to the normal destination and the DLL to the runtime
// destination.
cmInstallTargetGeneratorLocal
g1(l->second, destination.c_str(), true);
g1(this, l->first, destination.c_str(), true);
g1.Generate(os, config, configurationTypes);
// We also skip over the leading slash given by the user.
destination = l->second.GetRuntimeInstallPath().substr(1);
cmSystemTools::ConvertToUnixSlashes(destination);
cmInstallTargetGeneratorLocal
g2(l->second, destination.c_str(), false);
g2(this, l->first, destination.c_str(), false);
g2.Generate(os, config, configurationTypes);
#else
// Use a target install generator.
cmInstallTargetGeneratorLocal
g(l->second, destination.c_str(), false);
g(this, l->first, destination.c_str(), false);
g.Generate(os, config, configurationTypes);
#endif
}

3
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -88,7 +88,8 @@ void cmLocalVisualStudio6Generator::AddCMakeListsRules()
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++)
{
if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY)
if (l->second.GetType() == cmTarget::INTERFACE_LIBRARY
|| l->second.GetType() == cmTarget::GLOBAL_TARGET)
{
continue;
}

4
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -108,6 +108,10 @@ void cmLocalVisualStudio7Generator::AddCMakeListsRules()
// Add the rule to targets that need it.
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
{
if (l->second.GetType() == cmTarget::GLOBAL_TARGET)
{
continue;
}
if(l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
{
l->second.AddSource(sf->GetFullPath());

11
Source/cmMakefile.cxx
View File

@ -1205,7 +1205,8 @@ cmMakefile::AddCustomCommandOldStyle(const std::string& target,
}
//----------------------------------------------------------------------------
void cmMakefile::AddUtilityCommand(const std::string& utilityName,
cmTarget*
cmMakefile::AddUtilityCommand(const std::string& utilityName,
bool excludeFromAll,
const std::vector<std::string>& depends,
const char* workingDirectory,
@ -1238,7 +1239,7 @@ void cmMakefile::AddUtilityCommand(const std::string& utilityName,
commandLines.push_back(commandLine);
// Call the real signature of this method.
this->AddUtilityCommand(utilityName, excludeFromAll, workingDirectory,
return this->AddUtilityCommand(utilityName, excludeFromAll, workingDirectory,
depends, commandLines);
}
@ -1905,6 +1906,12 @@ const char* cmMakefile::GetCurrentBinaryDirectory() const
return this->StateSnapshot.GetDirectory().GetCurrentBinary();
}
void cmMakefile::AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt)
{
this->GeneratorTargets[t] = gt;
this->GetGlobalGenerator()->AddGeneratorTarget(t, gt);
}
//----------------------------------------------------------------------------
void cmMakefile::AddIncludeDirectories(const std::vector<std::string> &incs,
bool before)

8
Source/cmMakefile.h
View File

@ -194,7 +194,8 @@ public:
* Add a utility to the build. A utiltity target is a command that
* is run every time the target is built.
*/
void AddUtilityCommand(const std::string& utilityName, bool excludeFromAll,
cmTarget* AddUtilityCommand(const std::string& utilityName,
bool excludeFromAll,
const std::vector<std::string>& depends,
const char* workingDirectory,
const char* command,
@ -416,10 +417,7 @@ public:
{
this->GeneratorTargets = targets;
}
void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt)
{
this->GeneratorTargets[t] = gt;
}
void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt);
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;

1
Source/cmQtAutoGenerators.cxx
View File

@ -476,7 +476,6 @@ bool cmQtAutoGenerators::InitializeAutogenTarget(cmLocalGenerator* lg,
commandLines, false, autogenComment.c_str());
cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
lg->GetGlobalGenerator()->AddGeneratorTarget(autogenTarget, gt);
makefile->AddGeneratorTarget(autogenTarget, gt);
// Set target folder

3
Source/cmScriptGenerator.h
View File

@ -54,9 +54,6 @@ public:
void Generate(std::ostream& os, const std::string& config,
std::vector<std::string> const& configurationTypes);
const std::vector<std::string>& GetConfigurations() const
{ return this->Configurations; }
protected:
typedef cmScriptGeneratorIndent Indent;
virtual void GenerateScript(std::ostream& os);

6
Source/cmake.cxx
View File

@ -1607,7 +1607,11 @@ int cmake::Generate()
{
return -1;
}
this->GlobalGenerator->DoGenerate();
if (!this->GlobalGenerator->Compute())
{
return -1;
}
this->GlobalGenerator->Generate();
if ( !this->GraphVizFile.empty() )
{
std::cout << "Generate graphviz: " << this->GraphVizFile << std::endl;