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

Merge topic 'use-generator-target' 

79c3a2a8 cmGlobalGenerator: Remove map from cmTarget to cmGeneratorTarget
c389f8bb cmLocalGenerator: Port Find method away from GetGeneratorTarget
02533038 VS6: Port to FindGeneratorTarget
b6278e9f cmake: Port find_package mode away from GetGeneratorTarget
7a6caae1 cmMakefile: Add imported target accessor
0fb187cc CMP0026: Port away from GetGeneratorTarget
8caf1f36 cmGlobalGenerator: Add FindGeneratorTarget API
278ba2db cmGeneratorTarget: Add API for globally visible IMPORTED
79c11d23 Xcode: Port away from GetGeneratorTarget
9b244cc0 cmLocalGenerator: Store imported targets in a separate container.
def6da61 cmLocalGenerator: Port FindGeneratorTarget away from GetGeneratorTarget
a67231ac cmTarget: Implement ALIAS in terms of name mapping
d566f39a cmGlobalGenerator: Remove unneeded GetGeneratorTarget
0c97d32f cmGlobalGenerator: Remove direct storage of targets
383bfd95 cmTargetCollectLinkLanguages: Remove cmMakefile dependency
7f6bedda cmGeneratorTarget: Port cmOptionalLinkImplementation
...
This commit is contained in:
Brad King 2015-10-28 08:48:05 -04:00 committed by CMake Topic Stage
parent 27570a6d0e 79c3a2a8f7
commit 1e8c920d04
49 changed files with 622 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmAddExecutableCommand.cxx
View File

@ -192,7 +192,7 @@ bool cmAddExecutableCommand
this->SetError(e.str());
return false;
}
this->Makefile->AddAlias(exename, aliasedTarget);
this->Makefile->AddAlias(exename, aliasedName);
return true;
}

2
Source/cmAddLibraryCommand.cxx
View File

@ -314,7 +314,7 @@ bool cmAddLibraryCommand
this->SetError(e.str());
return false;
}
this->Makefile->AddAlias(libName, aliasedTarget);
this->Makefile->AddAlias(libName, aliasedName);
return true;
}

8
Source/cmAuxSourceDirectoryCommand.cxx
View File

@ -60,10 +60,10 @@ bool cmAuxSourceDirectoryCommand::InitialPass
std::string ext = file.substr(dotpos+1);
std::string base = file.substr(0, dotpos);
// Process only source files
if(!base.empty()
&& std::find( this->Makefile->GetSourceExtensions().begin(),
this->Makefile->GetSourceExtensions().end(), ext )
!= this->Makefile->GetSourceExtensions().end() )
std::vector<std::string> srcExts =
this->Makefile->GetCMakeInstance()->GetSourceExtensions();
if(!base.empty() &&
std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end())
{
std::string fullname = templateDirectory;
fullname += "/";

6
Source/cmComputeLinkInformation.cxx
View File

@ -377,9 +377,9 @@ cmComputeLinkInformation
// Add the search path entries requested by the user to path ordering.
this->OrderLinkerSearchPath
->AddUserDirectories(this->Target->Target->GetLinkDirectories());
->AddUserDirectories(this->Target->GetLinkDirectories());
this->OrderRuntimeSearchPath
->AddUserDirectories(this->Target->Target->GetLinkDirectories());
->AddUserDirectories(this->Target->GetLinkDirectories());
// Set up the implicit link directories.
this->LoadImplicitLinkInfo();
@ -413,7 +413,7 @@ cmComputeLinkInformation
// Construct a mask to not bother with this behavior for link
// directories already specified by the user.
std::vector<std::string> const& dirs =
this->Target->Target->GetLinkDirectories();
this->Target->GetLinkDirectories();
this->OldLinkDirMask.insert(dirs.begin(), dirs.end());
}

2
Source/cmComputeTargetDepends.cxx
View File

@ -382,7 +382,7 @@ void cmComputeTargetDepends::AddTargetDepend(
<< "\" of target \"" << depender->GetName() << "\" does not exist.";
cmListFileBacktrace const* backtrace =
depender->Target->GetUtilityBacktrace(dependee_name);
depender->GetUtilityBacktrace(dependee_name);
if(backtrace)
{
cm->IssueMessage(messageType, e.str(), *backtrace);

6
Source/cmExportBuildFileGenerator.cxx
View File

@ -213,12 +213,8 @@ cmExportBuildFileGenerator
properties[prop] = value;
}
// Check whether this is a DLL platform.
bool dll_platform =
(mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW"));
// Add the import library for windows DLLs.
if(dll_platform &&
if(target->IsDLLPlatform() &&
(target->GetType() == cmState::SHARED_LIBRARY ||
target->IsExecutableWithExports()) &&
mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"))

5
Source/cmExportFileGenerator.cxx
View File

@ -879,10 +879,7 @@ cmExportFileGenerator
if(target->GetType() == cmState::SHARED_LIBRARY ||
target->GetType() == cmState::MODULE_LIBRARY)
{
// Check whether this is a DLL platform.
bool dll_platform =
(mf->IsOn("WIN32") || mf->IsOn("CYGWIN") || mf->IsOn("MINGW"));
if(!dll_platform)
if(!target->IsDLLPlatform())
{
std::string prop;
std::string value;

16
Source/cmExportTryCompileFileGenerator.cxx
View File

@ -105,16 +105,18 @@ cmExportTryCompileFileGenerator::PopulateProperties(
ImportPropertyMap& properties,
std::set<cmGeneratorTarget const*> &emitted)
{
cmPropertyMap props = target->Target->GetProperties();
for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i)
std::vector<std::string> props = target->GetPropertyKeys();
for(std::vector<std::string>::const_iterator i = props.begin();
i != props.end(); ++i)
{
properties[i->first] = i->second.GetValue();
if(i->first.find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0
|| i->first.find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0
|| i->first.find("INTERFACE_LINK_LIBRARIES") == 0)
properties[*i] = target->GetProperty(*i);
if(i->find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0
|| i->find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0
|| i->find("INTERFACE_LINK_LIBRARIES") == 0)
{
std::string evalResult = this->FindTargets(i->first,
std::string evalResult = this->FindTargets(*i,
target, emitted);
std::vector<std::string> depends;

14
Source/cmExtraCodeBlocksGenerator.cxx
View File

@ -383,6 +383,9 @@ void cmExtraCodeBlocksGenerator
all_files_map_t allFiles;
std::vector<std::string> cFiles;
std::vector<std::string> srcExts =
this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
lg!=lgs.end(); lg++)
{
@ -420,9 +423,7 @@ void cmExtraCodeBlocksGenerator
{
std::string srcext = (*si)->GetExtension();
for(std::vector<std::string>::const_iterator
ext = mf->GetSourceExtensions().begin();
ext != mf->GetSourceExtensions().end();
++ext)
ext = srcExts.begin(); ext != srcExts.end(); ++ext)
{
if (srcext == *ext)
{
@ -449,6 +450,9 @@ void cmExtraCodeBlocksGenerator
}
}
std::vector<std::string> headerExts =
this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
// The following loop tries to add header files matching to implementation
// files to the project. It does that by iterating over all
// C/C++ source files,
@ -468,8 +472,8 @@ void cmExtraCodeBlocksGenerator
// check if there's a matching header around
for(std::vector<std::string>::const_iterator
ext = mf->GetHeaderExtensions().begin();
ext != mf->GetHeaderExtensions().end();
ext = headerExts.begin();
ext != headerExts.end();
++ext)
{
std::string hname=headerBasename;

13
Source/cmExtraCodeLiteGenerator.cxx
View File

@ -149,6 +149,11 @@ void cmExtraCodeLiteGenerator
// which may have an acompanying header, one for all other files
std::string projectType;
std::vector<std::string> srcExts =
this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
std::vector<std::string> headerExts =
this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
std::map<std::string, cmSourceFile*> cFiles;
std::set<std::string> otherFiles;
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
@ -207,9 +212,7 @@ void cmExtraCodeLiteGenerator
{
std::string srcext = (*si)->GetExtension();
for(std::vector<std::string>::const_iterator
ext = mf->GetSourceExtensions().begin();
ext != mf->GetSourceExtensions().end();
++ext)
ext = srcExts.begin(); ext != srcExts.end(); ++ext)
{
if (srcext == *ext)
{
@ -253,8 +256,8 @@ void cmExtraCodeLiteGenerator
// check if there's a matching header around
for(std::vector<std::string>::const_iterator
ext = mf->GetHeaderExtensions().begin();
ext != mf->GetHeaderExtensions().end();
ext = headerExts.begin();
ext != headerExts.end();
++ext)
{
std::string hname=headerBasename;

8
Source/cmGeneratorExpressionNode.cxx
View File

@ -393,7 +393,7 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0)
{
switch(context->LG->GetMakefile()->GetPolicyStatus(cmPolicies::CMP0044))
switch(context->LG->GetPolicyStatus(cmPolicies::CMP0044))
{
case cmPolicies::WARN:
{
@ -999,7 +999,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
if (propertyName == "LINKER_LANGUAGE")
{
if (target->Target->LinkLanguagePropagatesToDependents() &&
if (target->LinkLanguagePropagatesToDependents() &&
dagCheckerParent && (dagCheckerParent->EvaluatingLinkLibraries()
|| dagCheckerParent->EvaluatingSources()))
{
@ -1100,7 +1100,7 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
"COMPILE_DEFINITIONS_"))
{
cmPolicies::PolicyStatus polSt =
context->LG->GetMakefile()->GetPolicyStatus(cmPolicies::CMP0043);
context->LG->GetPolicyStatus(cmPolicies::CMP0043);
if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
{
interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS";
@ -1442,7 +1442,7 @@ cmPolicies::PolicyStatus statusForTarget(cmGeneratorTarget const* tgt,
#define RETURN_POLICY(POLICY) \
if (strcmp(policy, #POLICY) == 0) \
{ \
return tgt->Target->GetPolicyStatus ## POLICY (); \
return tgt->GetPolicyStatus ## POLICY (); \
} \
CM_FOR_EACH_TARGET_POLICY(RETURN_POLICY)

113
Source/cmGeneratorTarget.cxx
View File

@ -796,7 +796,7 @@ std::set<cmLinkItem> const& cmGeneratorTarget::GetUtilityItems() const
if(!this->UtilityItemsDone)
{
this->UtilityItemsDone = true;
std::set<std::string> const& utilities = this->Target->GetUtilities();
std::set<std::string> const& utilities = this->GetUtilities();
for(std::set<std::string>::const_iterator i = utilities.begin();
i != utilities.end(); ++i)
{
@ -833,11 +833,34 @@ const char* cmGeneratorTarget::GetLocation(const std::string& config) const
return location.c_str();
}
std::vector<cmCustomCommand> const&
cmGeneratorTarget::GetPreBuildCommands() const
{
return this->Target->GetPreBuildCommands();
}
std::vector<cmCustomCommand> const&
cmGeneratorTarget::GetPreLinkCommands() const
{
return this->Target->GetPreLinkCommands();
}
std::vector<cmCustomCommand> const&
cmGeneratorTarget::GetPostBuildCommands() const
{
return this->Target->GetPostBuildCommands();
}
bool cmGeneratorTarget::IsImported() const
{
return this->Target->IsImported();
}
bool cmGeneratorTarget::IsImportedGloballyVisible() const
{
return this->Target->IsImportedGloballyVisible();
}
//----------------------------------------------------------------------------
const char* cmGeneratorTarget::GetLocationForBuild() const
{
@ -1623,7 +1646,7 @@ cmGeneratorTarget::GetFrameworkDirectory(const std::string& config,
if(!rootDir && !this->Makefile->PlatformIsAppleIos())
{
fpath += "/Versions/";
fpath += this->Target->GetFrameworkVersion();
fpath += this->GetFrameworkVersion();
}
return fpath;
}
@ -1714,6 +1737,22 @@ cmListFileBacktrace cmGeneratorTarget::GetBacktrace() const
return this->Target->GetBacktrace();
}
const std::vector<std::string>&cmGeneratorTarget::GetLinkDirectories() const
{
return this->Target->GetLinkDirectories();
}
const std::set<std::string>& cmGeneratorTarget::GetUtilities() const
{
return this->Target->GetUtilities();
}
const cmListFileBacktrace*
cmGeneratorTarget::GetUtilityBacktrace(const std::string& u) const
{
return this->Target->GetUtilityBacktrace(u);
}
//----------------------------------------------------------------------------
bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const
{
@ -1759,7 +1798,7 @@ public:
UNORDERED_SET<std::string>& languages,
cmGeneratorTarget const* head):
Config(config), Languages(languages), HeadTarget(head),
Makefile(target->Target->GetMakefile()), Target(target)
Target(target)
{ this->Visited.insert(target); }
void Visit(cmLinkItem const& item)
@ -1771,7 +1810,8 @@ public:
bool noMessage = false;
cmake::MessageType messageType = cmake::FATAL_ERROR;
std::stringstream e;
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0028))
switch(this->Target->GetLocalGenerator()
->GetPolicyStatus(cmPolicies::CMP0028))
{
case cmPolicies::WARN:
{
@ -1825,7 +1865,6 @@ private:
std::string Config;
UNORDERED_SET<std::string>& Languages;
cmGeneratorTarget const* HeadTarget;
cmMakefile* Makefile;
const cmGeneratorTarget* Target;
std::set<cmGeneratorTarget const*> Visited;
};
@ -2267,11 +2306,11 @@ cmTargetTraceDependencies
// Queue pre-build, pre-link, and post-build rule dependencies.
this->CheckCustomCommands(
this->GeneratorTarget->Target->GetPreBuildCommands());
this->GeneratorTarget->GetPreBuildCommands());
this->CheckCustomCommands(
this->GeneratorTarget->Target->GetPreLinkCommands());
this->GeneratorTarget->GetPreLinkCommands());
this->CheckCustomCommands(
this->GeneratorTarget->Target->GetPostBuildCommands());
this->GeneratorTarget->GetPostBuildCommands());
}
//----------------------------------------------------------------------------
@ -3313,7 +3352,7 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name,
if(!this->Makefile->PlatformIsAppleIos())
{
realName += "Versions/";
realName += this->Target->GetFrameworkVersion();
realName += this->GetFrameworkVersion();
realName += "/";
}
realName += base;
@ -4217,9 +4256,11 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
PropertyType *)
{
PropertyType propContent = getTypedProperty<PropertyType>(tgt, p);
const bool explicitlySet = tgt->Target->GetProperties()
.find(p)
!= tgt->Target->GetProperties().end();
std::vector<std::string> headPropKeys = tgt->GetPropertyKeys();
const bool explicitlySet =
std::find(headPropKeys.begin(), headPropKeys.end(),
p) != headPropKeys.end();
const bool impliedByUse =
tgt->IsNullImpliedByLinkLibraries(p);
assert((impliedByUse ^ explicitlySet)
@ -4264,9 +4305,11 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
cmGeneratorTarget const* theTarget = *li;
const bool ifaceIsSet = theTarget->Target->GetProperties()
.find(interfaceProperty)
!= theTarget->Target->GetProperties().end();
std::vector<std::string> propKeys = theTarget->GetPropertyKeys();
const bool ifaceIsSet =
std::find(propKeys.begin(), propKeys.end(),
interfaceProperty) != propKeys.end();
PropertyType ifacePropContent =
getTypedProperty<PropertyType>(theTarget,
interfaceProperty);
@ -4507,6 +4550,25 @@ void cmGeneratorTarget::GetTargetVersion(bool soversion,
}
}
//----------------------------------------------------------------------------
std::string cmGeneratorTarget::GetFrameworkVersion() const
{
assert(this->GetType() != cmState::INTERFACE_LIBRARY);
if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION"))
{
return fversion;
}
else if(const char* tversion = this->GetProperty("VERSION"))
{
return tversion;
}
else
{
return "A";
}
}
//----------------------------------------------------------------------------
void cmGeneratorTarget::ComputeVersionedName(std::string& vName,
std::string const& prefix,
@ -4524,6 +4586,19 @@ void cmGeneratorTarget::ComputeVersionedName(std::string& vName,
vName += this->Makefile->IsOn("APPLE") ? suffix : std::string();
}
std::vector<std::string> cmGeneratorTarget::GetPropertyKeys() const
{
cmPropertyMap propsObject = this->Target->GetProperties();
std::vector<std::string> props;
props.reserve(propsObject.size());
for (cmPropertyMap::const_iterator it = propsObject.begin();
it != propsObject.end(); ++it)
{
props.push_back(it->first);
}
return props;
}
//----------------------------------------------------------------------------
void
cmGeneratorTarget::ReportPropertyOrigin(const std::string &p,
@ -4717,7 +4792,7 @@ void cmGeneratorTarget::ComputeLinkInterface(const std::string& config,
iface.WrongConfigLibraries = impl->WrongConfigLibraries;
}
if(this->Target->LinkLanguagePropagatesToDependents())
if(this->LinkLanguagePropagatesToDependents())
{
// Targets using this archive need its language runtime libraries.
if(cmLinkImplementation const* impl =
@ -5432,7 +5507,7 @@ void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config,
}
// Get the link languages.
if(this->Target->LinkLanguagePropagatesToDependents())
if(this->LinkLanguagePropagatesToDependents())
{
std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES";
linkProp += suffix;
@ -5490,7 +5565,7 @@ cmGeneratorTarget::GetLinkImplementation(const std::string& config) const
}
std::string CONFIG = cmSystemTools::UpperCase(config);
cmOptionalLinkImplementation& impl = this->LinkImplMap[CONFIG][this->Target];
cmOptionalLinkImplementation& impl = this->LinkImplMap[CONFIG][this];
if(!impl.LibrariesDone)
{
impl.LibrariesDone = true;
@ -5770,7 +5845,7 @@ cmGeneratorTarget::GetLinkImplementationLibrariesInternal(
return &hm.begin()->second;
}
cmOptionalLinkImplementation& impl = hm[head->Target];
cmOptionalLinkImplementation& impl = hm[head];
if(!impl.LibrariesDone)
{
impl.LibrariesDone = true;

20
Source/cmGeneratorTarget.h
View File

@ -31,8 +31,13 @@ public:
cmLocalGenerator* GetLocalGenerator() const;
bool IsImported() const;
bool IsImportedGloballyVisible() const;
const char *GetLocation(const std::string& config) const;
std::vector<cmCustomCommand> const &GetPreBuildCommands() const;
std::vector<cmCustomCommand> const &GetPreLinkCommands() const;
std::vector<cmCustomCommand> const &GetPostBuildCommands() const;
#define DECLARE_TARGET_POLICY(POLICY) \
cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \
{ return this->PolicyMap.Get(cmPolicies::POLICY); }
@ -53,6 +58,7 @@ public:
std::string GetName() const;
std::string GetExportName() const;
std::vector<std::string> GetPropertyKeys() const;
const char *GetProperty(const std::string& prop) const;
bool GetPropertyAsBool(const std::string& prop) const;
void GetSourceFiles(std::vector<cmSourceFile*>& files,
@ -161,6 +167,10 @@ public:
std::string GetFrameworkDirectory(const std::string& config,
bool rootDir) const;
/** Return the framework version string. Undefined if
IsFrameworkOnApple returns false. */
std::string GetFrameworkVersion() const;
/** @return the Mac CFBundle directory without the base */
std::string GetCFBundleDirectory(const std::string& config,
bool contentOnly) const;
@ -176,6 +186,14 @@ public:
cmListFileBacktrace GetBacktrace() const;
const std::vector<std::string>& GetLinkDirectories() const;
std::set<std::string>const& GetUtilities() const;
cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
bool LinkLanguagePropagatesToDependents() const
{ return this->GetType() == cmState::STATIC_LIBRARY; }
/** Get the macro to define when building sources in this target.
If no macro should be defined null is returned. */
const char* GetExportMacro() const;
@ -630,7 +648,7 @@ private:
const std::string& config) const;
struct HeadToLinkImplementationMap:
public std::map<cmTarget const*, cmOptionalLinkImplementation> {};
public std::map<cmGeneratorTarget const*, cmOptionalLinkImplementation> {};
typedef std::map<std::string,
HeadToLinkImplementationMap> LinkImplMapType;
mutable LinkImplMapType LinkImplMap;

4
Source/cmGhsMultiTargetGenerator.cxx
View File

@ -392,10 +392,10 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries()
void cmGhsMultiTargetGenerator::WriteCustomCommands()
{
WriteCustomCommandsHelper(
this->GeneratorTarget->Target->GetPreBuildCommands(),
this->GeneratorTarget->GetPreBuildCommands(),
cmTarget::PRE_BUILD);
WriteCustomCommandsHelper(
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget->GetPostBuildCommands(),
cmTarget::POST_BUILD);
}

191
Source/cmGlobalGenerator.cxx
View File

@ -1208,8 +1208,6 @@ void cmGlobalGenerator::Configure()
void cmGlobalGenerator::CreateGenerationObjects(TargetTypes targetTypes)
{
this->CreateLocalGenerators();
cmDeleteAll(this->GeneratorTargets);
this->GeneratorTargets.clear();
this->CreateGeneratorTargets(targetTypes);
this->ComputeBuildFileGenerators();
}
@ -1583,10 +1581,12 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo()
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes,
cmLocalGenerator *lg)
void cmGlobalGenerator::CreateGeneratorTargets(
TargetTypes targetTypes,
cmMakefile *mf,
cmLocalGenerator *lg,
std::map<cmTarget*, cmGeneratorTarget*> const& importedMap)
{
cmMakefile* mf = lg->GetMakefile();
if (targetTypes == AllTargets)
{
cmTargets& targets = mf->GetTargets();
@ -1595,27 +1595,42 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes,
{
cmTarget* t = &ti->second;
cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg);
this->GeneratorTargets[t] = gt;
lg->AddGeneratorTarget(gt);
}
}
std::vector<cmTarget*> itgts = mf->GetImportedTargets();
for(std::vector<cmTarget*>::const_iterator
j = mf->GetOwnedImportedTargets().begin();
j != mf->GetOwnedImportedTargets().end(); ++j)
j = itgts.begin(); j != itgts.end(); ++j)
{
cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg);
this->GeneratorTargets[*j] = gt;
lg->AddImportedGeneratorTarget(importedMap.find(*j)->second);
}
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes)
{
std::map<cmTarget*, cmGeneratorTarget*> importedMap;
for(unsigned int i=0; i < this->Makefiles.size(); ++i)
{
cmMakefile* mf = this->Makefiles[i];
for(std::vector<cmTarget*>::const_iterator
j = mf->GetOwnedImportedTargets().begin();
j != mf->GetOwnedImportedTargets().end(); ++j)
{
cmLocalGenerator* lg = this->LocalGenerators[i];
cmGeneratorTarget* gt = new cmGeneratorTarget(*j, lg);
lg->AddOwnedImportedGeneratorTarget(gt);
importedMap[*j] = gt;
}
}
// Construct per-target generator information.
for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
{
this->CreateGeneratorTargets(targetTypes, this->LocalGenerators[i]);
this->CreateGeneratorTargets(targetTypes, this->Makefiles[i],
this->LocalGenerators[i], importedMap);
}
}
@ -1623,9 +1638,6 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes)
//----------------------------------------------------------------------------
void cmGlobalGenerator::ClearGeneratorMembers()
{
cmDeleteAll(this->GeneratorTargets);
this->GeneratorTargets.clear();
cmDeleteAll(this->BuildExportSets);
this->BuildExportSets.clear();
@ -1637,28 +1649,12 @@ void cmGlobalGenerator::ClearGeneratorMembers()
this->ExportSets.clear();
this->TargetDependencies.clear();
this->TotalTargets.clear();
this->ImportedTargets.clear();
this->ProjectMap.clear();
this->RuleHashes.clear();
this->DirectoryContentMap.clear();
this->BinaryDirectories.clear();
}
//----------------------------------------------------------------------------
cmGeneratorTarget*
cmGlobalGenerator::GetGeneratorTarget(cmTarget const* t) const
{
cmGeneratorTargetsType::const_iterator ti = this->GeneratorTargets.find(t);
if(ti == this->GeneratorTargets.end())
{
this->CMakeInstance->IssueMessage(
cmake::INTERNAL_ERROR, "Missing cmGeneratorTarget instance!");
return 0;
}
return ti->second;
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const
{
@ -2169,9 +2165,10 @@ cmGlobalGenerator::FindLocalGenerator(const std::string& start_dir) const
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::AddAlias(const std::string& name, cmTarget *tgt)
void cmGlobalGenerator::AddAlias(const std::string& name,
std::string const& tgtName)
{
this->AliasTargets[name] = tgt;
this->AliasTargets[name] = tgtName;
}
//----------------------------------------------------------------------------
@ -2180,6 +2177,79 @@ bool cmGlobalGenerator::IsAlias(const std::string& name) const
return this->AliasTargets.find(name) != this->AliasTargets.end();
}
cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const
{
for (unsigned int i = 0; i < this->Makefiles.size(); ++i)
{
cmTargets& tgts = this->Makefiles[i]->GetTargets();
for (cmTargets::iterator it = tgts.begin(); it != tgts.end(); ++it)
{
if (it->second.GetName() == name)
{
return &it->second;
}
}
}
return 0;
}
cmGeneratorTarget*
cmGlobalGenerator::FindGeneratorTargetImpl(std::string const& name) const
{
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
std::vector<cmGeneratorTarget*> tgts =
this->LocalGenerators[i]->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin();
it != tgts.end(); ++it)
{
if ((*it)->GetName() == name)
{
return *it;
}
}
}
return 0;
}
cmTarget*
cmGlobalGenerator::FindImportedTargetImpl(std::string const& name) const
{
for (unsigned int i = 0; i < this->Makefiles.size(); ++i)
{
std::vector<cmTarget*> tgts =
this->Makefiles[i]->GetOwnedImportedTargets();
for (std::vector<cmTarget*>::iterator it = tgts.begin();
it != tgts.end(); ++it)
{
if ((*it)->GetName() == name && (*it)->IsImportedGloballyVisible())
{
return *it;
}
}
}
return 0;
}
cmGeneratorTarget* cmGlobalGenerator::FindImportedGeneratorTargetImpl(
std::string const& name) const
{
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
std::vector<cmGeneratorTarget*> tgts =
this->LocalGenerators[i]->GetImportedGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin();
it != tgts.end(); ++it)
{
if ((*it)->IsImportedGloballyVisible() && (*it)->GetName() == name)
{
return *it;
}
}
}
return 0;
}
//----------------------------------------------------------------------------
cmTarget*
cmGlobalGenerator::FindTarget(const std::string& name,
@ -2187,23 +2257,28 @@ cmGlobalGenerator::FindTarget(const std::string& name,
{
if (!excludeAliases)
{
TargetMap::const_iterator ai = this->AliasTargets.find(name);
std::map<std::string, std::string>::const_iterator ai =
this->AliasTargets.find(name);
if (ai != this->AliasTargets.end())
{
return ai->second;
return this->FindTargetImpl(ai->second);
}
}
TargetMap::const_iterator i = this->TotalTargets.find ( name );
if ( i != this->TotalTargets.end() )
if (cmTarget* tgt = this->FindTargetImpl(name))
{
return i->second;
return tgt;
}
i = this->ImportedTargets.find(name);
if ( i != this->ImportedTargets.end() )
return this->FindImportedTargetImpl(name);
}
cmGeneratorTarget*
cmGlobalGenerator::FindGeneratorTarget(const std::string& name) const
{
if (cmGeneratorTarget* tgt = this->FindGeneratorTargetImpl(name))
{
return i->second;
return tgt;
}
return 0;
return this->FindImportedGeneratorTargetImpl(name);
}
//----------------------------------------------------------------------------
@ -2217,8 +2292,7 @@ cmGlobalGenerator::NameResolvesToFramework(const std::string& libname) const
if(cmTarget* tgt = this->FindTarget(libname))
{
cmGeneratorTarget* gt = this->GetGeneratorTarget(tgt);
if(gt->IsFrameworkOnApple())
if(tgt->IsFrameworkOnApple())
{
return true;
}
@ -2622,18 +2696,6 @@ cmGlobalGenerator::GetTargetDirectDepends(cmGeneratorTarget const* target)
return this->TargetDependencies[target];
}
void cmGlobalGenerator::AddTarget(cmTarget* t)
{
if(t->IsImported())
{
this->ImportedTargets[t->GetName()] = t;
}
else
{
this->TotalTargets[t->GetName()] = t;
}
}
bool cmGlobalGenerator::IsReservedTarget(std::string const& name)
{
// The following is a list of targets reserved
@ -2939,17 +3001,20 @@ void cmGlobalGenerator::WriteSummary()
fname += "/TargetDirectories.txt";
cmGeneratedFileStream fout(fname.c_str());
// Generate summary information files for each target.
for(TargetMap::const_iterator ti =
this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti)
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
if ((ti->second)->GetType() == cmState::INTERFACE_LIBRARY)
std::vector<cmGeneratorTarget*> tgts =
this->LocalGenerators[i]->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator it = tgts.begin();
it != tgts.end(); ++it)
{
continue;
if ((*it)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
this->WriteSummary(*it);
fout << (*it)->GetSupportDirectory() << "\n";
}
cmGeneratorTarget* gt = this->GetGeneratorTarget(ti->second);
this->WriteSummary(gt);
fout << gt->GetSupportDirectory() << "\n";
}
}

45
Source/cmGlobalGenerator.h
View File

@ -42,10 +42,6 @@ class cmInstallTargetGenerator;
class cmInstallFilesGenerator;
class cmExportBuildFileGenerator;
typedef std::map<cmTarget const*,
cmGeneratorTarget*,
cmTarget::StrictTargetComparison> cmGeneratorTargetsType;
/** \class cmGlobalGenerator
* \brief Responsible for overseeing the generation process for the entire tree
*
@ -254,7 +250,9 @@ public:
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;
void AddAlias(const std::string& name, cmTarget *tgt);
cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const;
void AddAlias(const std::string& name, const std::string& tgtName);
bool IsAlias(const std::string& name) const;
/** Determine if a name resolves to a framework on disk or a built target
@ -280,8 +278,6 @@ public:
std::set<std::string> const& GetDirectoryContent(std::string const& dir,
bool needDisk = true);
void AddTarget(cmTarget* t);
static bool IsReservedTarget(std::string const& name);
virtual const char* GetAllTargetName() const { return "ALL_BUILD"; }
@ -307,14 +303,6 @@ public:
TargetDependSet const& GetTargetDirectDepends(
const cmGeneratorTarget* target);
/** Get per-target generator information. */
cmGeneratorTarget* GetGeneratorTarget(cmTarget const*) const;
void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt)
{
this->GeneratorTargets[t] = gt;
}
const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap()
const {return this->ProjectMap;}
@ -429,19 +417,14 @@ protected:
std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets;
std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets;
// All targets in the entire project.
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
typedef std::unordered_map<std::string, cmTarget*> TargetMap;
#else
typedef cmsys::hash_map<std::string, cmTarget*> TargetMap;
#endif
#else
typedef std::map<std::string,cmTarget *> TargetMap;
#endif
TargetMap TotalTargets;
TargetMap AliasTargets;
TargetMap ImportedTargets;
std::map<std::string, std::string> AliasTargets;
cmTarget* FindTargetImpl(std::string const& name) const;
cmTarget* FindImportedTargetImpl(std::string const& name) const;
cmGeneratorTarget* FindGeneratorTargetImpl(std::string const& name) const;
cmGeneratorTarget*
FindImportedGeneratorTargetImpl(std::string const& name) const;
const char* GetPredefinedTargetsFolder();
virtual bool UseFolderProperty();
@ -487,10 +470,10 @@ private:
typedef std::map<cmGeneratorTarget const*, TargetDependSet> TargetDependMap;
TargetDependMap TargetDependencies;
// Per-target generator information.
cmGeneratorTargetsType GeneratorTargets;
friend class cmake;
void CreateGeneratorTargets(TargetTypes targetTypes, cmLocalGenerator* lg);
void CreateGeneratorTargets(TargetTypes targetTypes, cmMakefile* mf,
cmLocalGenerator* lg,
std::map<cmTarget*, cmGeneratorTarget*> const& importedMap);
void CreateGeneratorTargets(TargetTypes targetTypes);
void ClearGeneratorMembers();

6
Source/cmGlobalKdevelopGenerator.cxx
View File

@ -105,6 +105,9 @@ bool cmGlobalKdevelopGenerator
std::set<std::string> files;
std::string tmp;
std::vector<std::string> hdrExts =
this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
for (std::vector<cmLocalGenerator*>::const_iterator it=lgs.begin();
it!=lgs.end(); it++)
{
@ -160,8 +163,7 @@ bool cmGlobalKdevelopGenerator
// check if there's a matching header around
for(std::vector<std::string>::const_iterator
ext = makefile->GetHeaderExtensions().begin();
ext != makefile->GetHeaderExtensions().end(); ++ext)
ext = hdrExts.begin(); ext != hdrExts.end(); ++ext)
{
std::string hname=headerBasename;
hname += ".";

2
Source/cmGlobalNinjaGenerator.cxx
View File

@ -965,7 +965,7 @@ cmGlobalNinjaGenerator
if (target->GetType() == cmState::GLOBAL_TARGET) {
// Global targets only depend on other utilities, which may not appear in
// the TargetDepends set (e.g. "all").
std::set<std::string> const& utils = target->Target->GetUtilities();
std::set<std::string> const& utils = target->GetUtilities();
std::copy(utils.begin(), utils.end(), std::back_inserter(outputs));
} else {
cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);

4
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -523,7 +523,7 @@ cmGlobalUnixMakefileGenerator3
cmLocalUnixMakefileGenerator3* lg)
{
// Only subdirectories need these rules.
if(lg->GetMakefile()->IsRootMakefile())
if(lg->IsRootMakefile())
{
return;
}
@ -1084,7 +1084,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
// for the passed in makefile or if this is the top Makefile wripte out
// the targets
if (lg2 == lg || lg->GetMakefile()->IsRootMakefile())
if (lg2 == lg || lg->IsRootMakefile())
{
// for each target Generate the rule files for each target.
std::vector<cmGeneratorTarget*> targets = lg2->GetGeneratorTargets();

2
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -235,7 +235,7 @@ void cmGlobalVisualStudio6Generator
std::string project = target->GetName();
std::string location = expath;
this->WriteExternalProject(fout, project.c_str(),
location.c_str(), target->Target->GetUtilities());
location.c_str(), target->GetUtilities());
}
else
{

19
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -401,7 +401,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetConfigurations(
for(OrderedTargetDependSet::const_iterator tt =
projectTargets.begin(); tt != projectTargets.end(); ++tt)
{
cmTarget const* target = (*tt)->Target;
cmGeneratorTarget const* target = *tt;
if(target->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
@ -459,7 +459,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
project.c_str(),
location.c_str(),
target->GetProperty("VS_PROJECT_TYPE"),
target->Target->GetUtilities());
target->GetUtilities());
written = true;
}
else
@ -996,7 +996,8 @@ cmGlobalVisualStudio7Generator
std::set<std::string>
cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
std::vector<std::string> const& configs,
OrderedTargetDependSet const& projectTargets, cmTarget const* target)
OrderedTargetDependSet const& projectTargets,
cmGeneratorTarget const* target)
{
std::set<std::string> activeConfigs;
// if it is a utilitiy target then only make it part of the
@ -1011,13 +1012,13 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
for(std::vector<std::string>::const_iterator i = configs.begin();
i != configs.end(); ++i)
{
const char* propertyValue = target->GetMakefile()
const char* propertyValue = target->Target->GetMakefile()
->GetDefinition("CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD");
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression>
cge = ge.Parse(propertyValue);
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
if(cmSystemTools::IsOn(cge->Evaluate(gt->GetLocalGenerator(), *i)))
if(cmSystemTools::IsOn(cge->Evaluate(target->GetLocalGenerator(),
*i)))
{
activeConfigs.insert(*i);
}
@ -1029,13 +1030,12 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
{
return activeConfigs;
}
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
// inspect EXCLUDE_FROM_DEFAULT_BUILD[_<CONFIG>] properties
for(std::vector<std::string>::const_iterator i = configs.begin();
i != configs.end(); ++i)
{
const char* propertyValue =
gt->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str());
target->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str());
if(cmSystemTools::IsOff(propertyValue))
{
activeConfigs.insert(*i);
@ -1047,9 +1047,8 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
bool
cmGlobalVisualStudio7Generator
::IsDependedOn(OrderedTargetDependSet const& projectTargets,
cmTarget const* targetIn)
cmGeneratorTarget const* gtIn)
{
cmGeneratorTarget* gtIn = this->GetGeneratorTarget(targetIn);
for (OrderedTargetDependSet::const_iterator l = projectTargets.begin();
l != projectTargets.end(); ++l)
{

4
Source/cmGlobalVisualStudio7Generator.h
View File

@ -163,9 +163,9 @@ protected:
std::set<std::string>
IsPartOfDefaultBuild(std::vector<std::string> const& configs,
OrderedTargetDependSet const& projectTargets,
cmTarget const* target);
cmGeneratorTarget const* target);
bool IsDependedOn(OrderedTargetDependSet const& projectTargets,
cmTarget const* target);
cmGeneratorTarget const* target);
std::map<std::string, std::string> GUIDMap;
virtual void WriteFolders(std::ostream& fout);

21
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -257,7 +257,6 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg);
lg->AddGeneratorTarget(gt);
this->AddGeneratorTarget(tgt, gt);
// Organize in the "predefined targets" folder:
//
@ -354,14 +353,18 @@ void cmGlobalVisualStudio8Generator::AddExtraIDETargets()
cmGlobalVisualStudio7Generator::AddExtraIDETargets();
if(this->AddCheckTarget())
{
// All targets depend on the build-system check target.
for(TargetMap::const_iterator
ti = this->TotalTargets.begin();
ti != this->TotalTargets.end(); ++ti)
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
if(ti->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
std::vector<cmGeneratorTarget*> tgts =
this->LocalGenerators[i]->GetGeneratorTargets();
// All targets depend on the build-system check target.
for(std::vector<cmGeneratorTarget*>::iterator ti = tgts.begin();
ti != tgts.end(); ++ti)
{
ti->second->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
if((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
{
(*ti)->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
}
}
}
}
@ -464,8 +467,8 @@ bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies(
{
// Look for utility dependencies that magically link.
for(std::set<std::string>::const_iterator ui =
target->Target->GetUtilities().begin();
ui != target->Target->GetUtilities().end(); ++ui)
target->GetUtilities().begin();
ui != target->GetUtilities().end(); ++ui)
{
if(cmGeneratorTarget* depTarget =
target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str()))

1
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -88,7 +88,6 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]);
gen[0]->AddGeneratorTarget(gt);
this->AddGeneratorTarget(allBuild, gt);
#if 0
// Can't activate this code because we want ALL_BUILD

37
Source/cmGlobalXCodeGenerator.cxx
View File

@ -460,7 +460,6 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root);
root->AddGeneratorTarget(allBuildGt);
root->GetGlobalGenerator()->AddGeneratorTarget(allbuild, allBuildGt);
// Refer to the main build configuration file for easy editing.
std::string listfile = root->GetCurrentSourceDirectory();
@ -496,7 +495,6 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root);
root->AddGeneratorTarget(checkGt);
root->GetGlobalGenerator()->AddGeneratorTarget(check, checkGt);
}
// now make the allbuild depend on all the non-utility targets
@ -1362,12 +1360,17 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::ForceLinkerLanguages()
{
// This makes sure all targets link using the proper language.
for(TargetMap::const_iterator
ti = this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti)
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
cmGeneratorTarget* gt = this->GetGeneratorTarget(ti->second);
this->ForceLinkerLanguage(gt);
std::vector<cmGeneratorTarget*> tgts =
this->LocalGenerators[i]->GetGeneratorTargets();
// All targets depend on the build-system check target.
for(std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin();
ti != tgts.end(); ++ti)
{
// This makes sure all targets link using the proper language.
this->ForceLinkerLanguage(*ti);
}
}
}
@ -1420,7 +1423,7 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt)
bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf)
{
const std::vector<std::string>& hdrExts =
this->CurrentMakefile->GetHeaderExtensions();
this->CMakeInstance->GetHeaderExtensions();
return (std::find(hdrExts.begin(), hdrExts.end(), sf->GetExtension()) !=
hdrExts.end());
}
@ -1469,11 +1472,11 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
cmGeneratorTarget* gtgt)
{
std::vector<cmCustomCommand> const & prebuild
= gtgt->Target->GetPreBuildCommands();
= gtgt->GetPreBuildCommands();
std::vector<cmCustomCommand> const & prelink
= gtgt->Target->GetPreLinkCommands();
= gtgt->GetPreLinkCommands();
std::vector<cmCustomCommand> postbuild
= gtgt->Target->GetPostBuildCommands();
= gtgt->GetPostBuildCommands();
if(gtgt->GetType() == cmState::SHARED_LIBRARY &&
!gtgt->IsFrameworkOnApple())
@ -2141,7 +2144,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
{
if(gtgt->GetPropertyAsBool("FRAMEWORK"))
{
std::string fw_version = gtgt->Target->GetFrameworkVersion();
std::string fw_version = gtgt->GetFrameworkVersion();
buildSettings->AddAttribute("FRAMEWORK_VERSION",
this->CreateString(fw_version.c_str()));
@ -2486,13 +2489,13 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
// put this last so it can override existing settings
// Convert "XCODE_ATTRIBUTE_*" properties directly.
{
cmPropertyMap const& props = gtgt->Target->GetProperties();
for(cmPropertyMap::const_iterator i = props.begin();
std::vector<std::string> const& props = gtgt->GetPropertyKeys();
for(std::vector<std::string>::const_iterator i = props.begin();
i != props.end(); ++i)
{
if(i->first.find("XCODE_ATTRIBUTE_") == 0)
if(i->find("XCODE_ATTRIBUTE_") == 0)
{
std::string attribute = i->first.substr(16);
std::string attribute = i->substr(16);
// Handle [variant=<config>] condition explicitly here.
std::string::size_type beginVariant =
attribute.find("[variant=");
@ -2523,7 +2526,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
if (!attribute.empty())
{
cmGeneratorExpression ge;
std::string processed = ge.Parse(i->second.GetValue())
std::string processed = ge.Parse(gtgt->GetProperty(*i))
->Evaluate(this->CurrentLocalGenerator, configName);
buildSettings->AddAttribute(attribute.c_str(),
this->CreateString(processed));

92
Source/cmLocalGenerator.cxx
View File

@ -51,6 +51,8 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg,
this->Makefile = makefile;
this->AliasTargets = makefile->GetAliasTargets();
this->EmitUniversalBinaryFlags = true;
this->BackwardsCompatibility = 0;
this->BackwardsCompatibilityFinal = false;
@ -60,6 +62,8 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg,
cmLocalGenerator::~cmLocalGenerator()
{
cmDeleteAll(this->GeneratorTargets);
cmDeleteAll(this->OwnedImportedGeneratorTargets);
}
void cmLocalGenerator::IssueMessage(cmake::MessageType t,
@ -453,11 +457,55 @@ void cmLocalGenerator::AddGeneratorTarget(cmGeneratorTarget* gt)
this->GeneratorTargets.push_back(gt);
}
void cmLocalGenerator::AddImportedGeneratorTarget(cmGeneratorTarget* gt)
{
this->ImportedGeneratorTargets.push_back(gt);
}
void cmLocalGenerator::AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt)
{
this->OwnedImportedGeneratorTargets.push_back(gt);
}
struct NamedGeneratorTargetFinder
{
NamedGeneratorTargetFinder(std::string const& name)
: Name(name)
{
}
bool operator()(cmGeneratorTarget* tgt)
{
return tgt->GetName() == this->Name;
}
private:
std::string Name;
};
cmGeneratorTarget* cmLocalGenerator::FindGeneratorTarget(
const std::string& name) const
{
return this->GetGlobalGenerator()->GetGeneratorTarget(
this->Makefile->FindTarget(name));
std::map<std::string, std::string>::const_iterator i =
this->AliasTargets.find(name);
if (i != this->AliasTargets.end())
{
std::vector<cmGeneratorTarget*>::const_iterator ai =
std::find_if(this->GeneratorTargets.begin(),
this->GeneratorTargets.end(),
NamedGeneratorTargetFinder(i->second));
return *ai;
}
std::vector<cmGeneratorTarget*>::const_iterator ti =
std::find_if(this->GeneratorTargets.begin(),
this->GeneratorTargets.end(),
NamedGeneratorTargetFinder(name));
if ( ti != this->GeneratorTargets.end() )
{
return *ti;
}
return 0;
}
//----------------------------------------------------------------------------
@ -490,6 +538,11 @@ void cmLocalGenerator::ComputeTargetManifest()
}
}
bool cmLocalGenerator::IsRootMakefile() const
{
return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid();
}
cmState* cmLocalGenerator::GetState() const
{
return this->GlobalGenerator->GetCMakeInstance()->GetState();
@ -1775,11 +1828,21 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
cmGeneratorTarget*
cmLocalGenerator::FindGeneratorTargetToUse(const std::string& name) const
{
if (cmTarget *t = this->Makefile->FindTargetToUse(name))
std::vector<cmGeneratorTarget*>::const_iterator
imported = std::find_if(this->ImportedGeneratorTargets.begin(),
this->ImportedGeneratorTargets.end(),
NamedGeneratorTargetFinder(name));
if(imported != this->ImportedGeneratorTargets.end())
{
return this->GetGlobalGenerator()->GetGeneratorTarget(t);
return *imported;
}
return 0;
if(cmGeneratorTarget* t = this->FindGeneratorTarget(name))
{
return t;
}
return this->GetGlobalGenerator()->FindGeneratorTarget(name);
}
//----------------------------------------------------------------------------
@ -2028,7 +2091,7 @@ AddCompilerRequirementFlag(std::string &flags,
}
static void AddVisibilityCompileOption(std::string &flags,
cmTarget const* target,
cmGeneratorTarget const* target,
cmLocalGenerator *lg,
const std::string& lang,
std::string* warnCMP0063)
@ -2068,7 +2131,7 @@ static void AddVisibilityCompileOption(std::string &flags,
}
static void AddInlineVisibilityCompileOption(std::string &flags,
cmTarget const* target,
cmGeneratorTarget const* target,
cmLocalGenerator *lg,
std::string* warnCMP0063)
{
@ -2121,12 +2184,11 @@ void cmLocalGenerator
}
}
AddVisibilityCompileOption(flags, target->Target, this, lang, pWarnCMP0063);
AddVisibilityCompileOption(flags, target, this, lang, pWarnCMP0063);
if(lang == "CXX")
{
AddInlineVisibilityCompileOption(flags, target->Target,
this, pWarnCMP0063);
AddInlineVisibilityCompileOption(flags, target, this, pWarnCMP0063);
}
if (!warnCMP0063.empty() &&
@ -2201,7 +2263,7 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
if (flags && flags != originalFlags)
{
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0018))
switch (this->GetPolicyStatus(cmPolicies::CMP0018))
{
case cmPolicies::WARN:
{
@ -2949,7 +3011,7 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4()
{
// Check the policy to decide whether to pay attention to this
// variable.
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0001))
switch(this->GetPolicyStatus(cmPolicies::CMP0001))
{
case cmPolicies::WARN:
// WARN is just OLD without warning because user code does not
@ -2976,6 +3038,12 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4()
actual_compat <= CMake_VERSION_ENCODE(2, 4, 255));
}
cmPolicies::PolicyStatus
cmLocalGenerator::GetPolicyStatus(cmPolicies::PolicyID id) const
{
return this->Makefile->GetPolicyStatus(id);
}
//----------------------------------------------------------------------------
bool cmLocalGenerator::CheckDefinition(std::string const& define) const
{

14
Source/cmLocalGenerator.h
View File

@ -67,6 +67,8 @@ public:
*/
void ComputeTargetManifest();
bool IsRootMakefile() const;
///! Get the makefile for this generator
cmMakefile *GetMakefile() {
return this->Makefile; }
@ -118,7 +120,14 @@ public:
return this->GeneratorTargets;
}
const std::vector<cmGeneratorTarget*> &GetImportedGeneratorTargets() const
{
return this->ImportedGeneratorTargets;
}
void AddGeneratorTarget(cmGeneratorTarget* gt);
void AddImportedGeneratorTarget(cmGeneratorTarget* gt);
void AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt);
cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const;
cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const;
@ -265,6 +274,8 @@ public:
*/
bool NeedBackwardsCompatibility_2_4();
cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const;
cmake* GetCMakeInstance() const;
const char* GetSourceDirectory() const;
@ -369,6 +380,9 @@ protected:
std::set<cmGeneratorTarget const*> WarnCMP0063;
std::vector<cmGeneratorTarget*> GeneratorTargets;
std::vector<cmGeneratorTarget*> ImportedGeneratorTargets;
std::vector<cmGeneratorTarget*> OwnedImportedGeneratorTargets;
std::map<std::string, std::string> AliasTargets;
bool EmitUniversalBinaryFlags;

4
Source/cmLocalNinjaGenerator.cxx
View File

@ -56,7 +56,7 @@ void cmLocalNinjaGenerator::Generate()
#endif
// We do that only once for the top CMakeLists.txt file.
if(this->Makefile->IsRootMakefile())
if(this->IsRootMakefile())
{
this->WriteBuildFileTop();
@ -277,7 +277,7 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
<< "# Write statements declared in CMakeLists.txt:" << std::endl
<< "# "
<< this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE") << std::endl;
if(this->Makefile->IsRootMakefile())
if(this->IsRootMakefile())
os << "# Which is the root file." << std::endl;
cmGlobalNinjaGenerator::WriteDivider(os);
os << std::endl;

18
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -254,7 +254,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
return;
}
// always write the top makefile
if (!this->GetMakefile()->IsRootMakefile())
if (!this->IsRootMakefile())
{
ruleFileStream.SetCopyIfDifferent(true);
}
@ -265,7 +265,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
// only write local targets unless at the top Keep track of targets already
// listed.
std::set<std::string> emittedTargets;
if (!this->GetMakefile()->IsRootMakefile())
if (!this->IsRootMakefile())
{
// write our targets, and while doing it collect up the object
// file rules
@ -880,7 +880,7 @@ void cmLocalUnixMakefileGenerator3
std::vector<std::string> no_depends;
std::vector<std::string> commands;
commands.push_back(runRule);
if(!this->GetMakefile()->IsRootMakefile())
if(!this->IsRootMakefile())
{
this->CreateCDCommand(commands,
this->GetBinaryDirectory(),
@ -1778,8 +1778,8 @@ void cmLocalUnixMakefileGenerator3
{
text = "Running external command ...";
}
depends.insert(depends.end(), (*glIt)->Target->GetUtilities().begin(),
(*glIt)->Target->GetUtilities().end());
depends.insert(depends.end(), (*glIt)->GetUtilities().begin(),
(*glIt)->GetUtilities().end());
this->AppendEcho(commands, text,
cmLocalUnixMakefileGenerator3::EchoGlobal);
@ -1787,15 +1787,15 @@ void cmLocalUnixMakefileGenerator3
// Global targets store their rules in pre- and post-build commands.
this->AppendCustomDepends(depends,
gt->Target->GetPreBuildCommands());
gt->GetPreBuildCommands());
this->AppendCustomDepends(depends,
gt->Target->GetPostBuildCommands());
gt->GetPostBuildCommands());
this->AppendCustomCommands(commands,
gt->Target->GetPreBuildCommands(),
gt->GetPreBuildCommands(),
gt,
cmLocalGenerator::START_OUTPUT);
this->AppendCustomCommands(commands,
gt->Target->GetPostBuildCommands(),
gt->GetPostBuildCommands(),
gt,
cmLocalGenerator::START_OUTPUT);
std::string targetName = gt->GetName();

37
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -266,21 +266,21 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
// depend only on the previous rule.
if ((target->GetType() == cmState::UTILITY ||
target->GetType() == cmState::GLOBAL_TARGET) &&
(!target->Target->GetPreBuildCommands().empty() ||
!target->Target->GetPostBuildCommands().empty()))
(!target->GetPreBuildCommands().empty() ||
!target->GetPostBuildCommands().empty()))
{
// Accumulate the dependencies of all the commands.
std::vector<std::string> depends;
for (std::vector<cmCustomCommand>::const_iterator cr =
target->Target->GetPreBuildCommands().begin();
cr != target->Target->GetPreBuildCommands().end(); ++cr)
target->GetPreBuildCommands().begin();
cr != target->GetPreBuildCommands().end(); ++cr)
{
depends.insert(depends.end(),
cr->GetDepends().begin(), cr->GetDepends().end());
}
for (std::vector<cmCustomCommand>::const_iterator cr =
target->Target->GetPostBuildCommands().begin();
cr != target->Target->GetPostBuildCommands().end(); ++cr)
target->GetPostBuildCommands().begin();
cr != target->GetPostBuildCommands().end(); ++cr)
{
depends.insert(depends.end(),
cr->GetDepends().begin(), cr->GetDepends().end());
@ -289,14 +289,14 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
// Add the pre- and post-build commands in order.
int count = 1;
for (std::vector<cmCustomCommand>::const_iterator cr =
target->Target->GetPreBuildCommands().begin();
cr != target->Target->GetPreBuildCommands().end(); ++cr)
target->GetPreBuildCommands().begin();
cr != target->GetPreBuildCommands().end(); ++cr)
{
this->AddUtilityCommandHack(target, count++, depends, *cr);
}
for (std::vector<cmCustomCommand>::const_iterator cr =
target->Target->GetPostBuildCommands().begin();
cr != target->Target->GetPostBuildCommands().end(); ++cr)
target->GetPostBuildCommands().begin();
cr != target->GetPostBuildCommands().end(); ++cr)
{
this->AddUtilityCommandHack(target, count++, depends, *cr);
}
@ -838,8 +838,8 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmGeneratorTarget *target,
// Write the pre-build and pre-link together (VS6 does not support both).
event.Start("PreLink");
event.Write(target->Target->GetPreBuildCommands());
event.Write(target->Target->GetPreLinkCommands());
event.Write(target->GetPreBuildCommands());
event.Write(target->GetPreLinkCommands());
cmsys::auto_ptr<cmCustomCommand> pcc(
this->MaybeCreateImplibDir(target, configName, false));
if(pcc.get())
@ -855,7 +855,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmGeneratorTarget *target,
// Write the post-build rules.
event.Start("PostBuild");
event.Write(target->Target->GetPostBuildCommands());
event.Write(target->GetPostBuildCommands());
event.Finish();
customRuleCode += "# End Special Build Tool\n";
@ -1052,7 +1052,7 @@ void cmLocalVisualStudio6Generator
}
std::vector<std::string>::const_iterator i;
const std::vector<std::string>& libdirs =
target->Target->GetLinkDirectories();
target->GetLinkDirectories();
for(i = libdirs.begin(); i != libdirs.end(); ++i)
{
std::string path = *i;
@ -1112,15 +1112,14 @@ void cmLocalVisualStudio6Generator
// Compute the proper name to use to link this library.
std::string lib;
std::string libDebug;
cmTarget* tgt = this->GlobalGenerator->FindTarget(j->first.c_str());
cmGeneratorTarget* tgt =
this->GlobalGenerator->FindGeneratorTarget(j->first.c_str());
if(tgt)
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(tgt);
lib = cmSystemTools::GetFilenameWithoutExtension
(gt->GetFullName().c_str());
(tgt->GetFullName().c_str());
libDebug = cmSystemTools::GetFilenameWithoutExtension
(gt->GetFullName("Debug").c_str());
(tgt->GetFullName("Debug").c_str());
lib += ".lib";
libDebug += ".lib";
}

27
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -783,10 +783,10 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
intermediateDir += "/";
intermediateDir += configName;
if (target->Target->GetType() < cmState::UTILITY)
if (target->GetType() < cmState::UTILITY)
{
std::string const& outDir =
target->Target->GetType() == cmState::OBJECT_LIBRARY?
target->GetType() == cmState::OBJECT_LIBRARY?
intermediateDir : target->GetDirectory(configName);
fout << "\t\t\tOutputDirectory=\""
<< this->ConvertToXMLOutputPathSingle(outDir.c_str()) << "\"\n";
@ -837,7 +837,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
if(this->FortranProject)
{
const char* target_mod_dir =
target->Target->GetProperty("Fortran_MODULE_DIRECTORY");
target->GetProperty("Fortran_MODULE_DIRECTORY");
std::string modDir;
if(target_mod_dir)
{
@ -877,7 +877,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
targetOptions.OutputFlagMap(fout, "\t\t\t\t");
targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n", "CXX");
fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n";
if(target->Target->GetType() <= cmState::OBJECT_LIBRARY)
if(target->GetType() <= cmState::OBJECT_LIBRARY)
{
// Specify the compiler program database file if configured.
std::string pdb = target->GetCompilePDBPath(configName);
@ -2021,7 +2021,7 @@ void cmLocalVisualStudio7Generator
const char* tool =
this->FortranProject? "VFPreBuildEventTool":"VCPreBuildEventTool";
event.Start(tool);
event.Write(target->Target->GetPreBuildCommands());
event.Write(target->GetPreBuildCommands());
event.Finish();
// Add pre-link event.
@ -2035,7 +2035,7 @@ void cmLocalVisualStudio7Generator
{
addedPrelink = true;
std::vector<cmCustomCommand> commands =
target->Target->GetPreLinkCommands();
target->GetPreLinkCommands();
cmGlobalVisualStudioGenerator* gg
= static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
gg->AddSymbolExportCommand(
@ -2045,7 +2045,7 @@ void cmLocalVisualStudio7Generator
}
if (!addedPrelink)
{
event.Write(target->Target->GetPreLinkCommands());
event.Write(target->GetPreLinkCommands());
}
cmsys::auto_ptr<cmCustomCommand> pcc(
this->MaybeCreateImplibDir(target,
@ -2059,7 +2059,7 @@ void cmLocalVisualStudio7Generator
// Add post-build event.
tool = this->FortranProject? "VFPostBuildEventTool":"VCPostBuildEventTool";
event.Start(tool);
event.Write(target->Target->GetPostBuildCommands());
event.Write(target->GetPostBuildCommands());
event.Finish();
}
@ -2219,17 +2219,18 @@ void cmLocalVisualStudio7Generator::WriteVCProjFooter(
{
fout << "\t<Globals>\n";
cmPropertyMap const& props = target->Target->GetProperties();
for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i)
std::vector<std::string> const& props = target->GetPropertyKeys();
for(std::vector<std::string>::const_iterator i = props.begin();
i != props.end(); ++i)
{
if(i->first.find("VS_GLOBAL_") == 0)
if(i->find("VS_GLOBAL_") == 0)
{
std::string name = i->first.substr(10);
std::string name = i->substr(10);
if(name != "")
{
fout << "\t\t<Global\n"
<< "\t\t\tName=\"" << name << "\"\n"
<< "\t\t\tValue=\"" << i->second.GetValue() << "\"\n"
<< "\t\t\tValue=\"" << target->GetProperty(*i) << "\"\n"
<< "\t\t/>\n";
}
}

16
Source/cmLocalXCodeGenerator.cxx
View File

@ -51,13 +51,11 @@ void cmLocalXCodeGenerator::Generate()
{
cmLocalGenerator::Generate();
cmTargets& targets = this->Makefile->GetTargets();
for(cmTargets::iterator iter = targets.begin();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin();
iter != targets.end(); ++iter)
{
cmTarget* t = &iter->second;
cmGeneratorTarget* gt = this->GlobalGenerator->GetGeneratorTarget(t);
gt->HasMacOSXRpathInstallNameDir("");
(*iter)->HasMacOSXRpathInstallNameDir("");
}
}
@ -66,13 +64,11 @@ void cmLocalXCodeGenerator::GenerateInstallRules()
{
cmLocalGenerator::GenerateInstallRules();
cmTargets& targets = this->Makefile->GetTargets();
for(cmTargets::iterator iter = targets.begin();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin();
iter != targets.end(); ++iter)
{
cmTarget* t = &iter->second;
cmGeneratorTarget* gt = this->GlobalGenerator->GetGeneratorTarget(t);
gt->HasMacOSXRpathInstallNameDir("");
(*iter)->HasMacOSXRpathInstallNameDir("");
}
}

78
Source/cmMakefile.cxx
View File

@ -57,31 +57,6 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator,
// Setup the default include complaint regular expression (match nothing).
this->ComplainFileRegularExpression = "^$";
// Source and header file extensions that we can handle
// Set up a list of source and header extensions
// these are used to find files when the extension
// is not given
// The "c" extension MUST precede the "C" extension.
this->SourceFileExtensions.push_back( "c" );
this->SourceFileExtensions.push_back( "C" );
this->SourceFileExtensions.push_back( "c++" );
this->SourceFileExtensions.push_back( "cc" );
this->SourceFileExtensions.push_back( "cpp" );
this->SourceFileExtensions.push_back( "cxx" );
this->SourceFileExtensions.push_back( "m" );
this->SourceFileExtensions.push_back( "M" );
this->SourceFileExtensions.push_back( "mm" );
this->HeaderFileExtensions.push_back( "h" );
this->HeaderFileExtensions.push_back( "hh" );
this->HeaderFileExtensions.push_back( "h++" );
this->HeaderFileExtensions.push_back( "hm" );
this->HeaderFileExtensions.push_back( "hpp" );
this->HeaderFileExtensions.push_back( "hxx" );
this->HeaderFileExtensions.push_back( "in" );
this->HeaderFileExtensions.push_back( "txx" );
this->DefineFlags = " ";
@ -756,15 +731,26 @@ void cmMakefile::ConfigureFinalPass()
"with CMake 2.4 or later. For compatibility with older versions please "
"use any CMake 2.8.x release or lower.");
}
for (cmTargets::iterator l = this->Targets.begin();
l != this->Targets.end(); l++)
#if defined(_WIN32) && !defined(__CYGWIN__)
// Do old-style link dependency analysis only for CM_USE_OLD_VS6.
if(this->GetGlobalGenerator()->IsForVS6())
{
if (l->second.GetType() == cmState::INTERFACE_LIBRARY)
for (cmTargets::iterator l = this->Targets.begin();
l != this->Targets.end(); l++)
{
continue;
if (l->second.GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
// Erase any cached link information that might have been comptued
// on-demand during the configuration. This ensures that build
// system generation uses up-to-date information even if other cache
// invalidation code in this source file is buggy.
l->second.AnalyzeLibDependenciesForVS6(*this);
}
l->second.FinishConfigure();
}
#endif
}
//----------------------------------------------------------------------------
@ -1780,6 +1766,18 @@ const char* cmMakefile::GetCurrentBinaryDirectory() const
return this->StateSnapshot.GetDirectory().GetCurrentBinary();
}
std::vector<cmTarget*> cmMakefile::GetImportedTargets() const
{
std::vector<cmTarget*> tgts;
tgts.reserve(this->ImportedTargets.size());
for (TargetMap::const_iterator it = this->ImportedTargets.begin();
it != this->ImportedTargets.end(); ++it)
{
tgts.push_back(it->second);
}
return tgts;
}
//----------------------------------------------------------------------------
void cmMakefile::AddIncludeDirectories(const std::vector<std::string> &incs,
bool before)
@ -2050,10 +2048,11 @@ void cmMakefile::AddGlobalLinkInformation(const std::string& name,
}
void cmMakefile::AddAlias(const std::string& lname, cmTarget *tgt)
void cmMakefile::AddAlias(const std::string& lname,
std::string const& tgtName)
{
this->AliasTargets[lname] = tgt;
this->GetGlobalGenerator()->AddAlias(lname, tgt);
this->AliasTargets[lname] = tgtName;
this->GetGlobalGenerator()->AddAlias(lname, tgtName);
}
cmTarget* cmMakefile::AddLibrary(const std::string& lname,
@ -2110,7 +2109,6 @@ cmMakefile::AddNewTarget(cmState::TargetType type, const std::string& name)
cmTarget& target = it->second;
target.SetType(type, name);
target.SetMakefile(this);
this->GetGlobalGenerator()->AddTarget(&it->second);
return &it->second;
}
@ -4039,10 +4037,12 @@ cmTarget* cmMakefile::FindTarget(const std::string& name,
{
if (!excludeAliases)
{
TargetMap::const_iterator i = this->AliasTargets.find(name);
std::map<std::string, std::string>::const_iterator i =
this->AliasTargets.find(name);
if (i != this->AliasTargets.end())
{
return i->second;
cmTargets::iterator ai = this->Targets.find(i->second);
return &ai->second;
}
}
cmTargets::iterator i = this->Targets.find( name );
@ -4197,15 +4197,11 @@ cmMakefile::AddImportedTarget(const std::string& name,
// Create the target.
cmsys::auto_ptr<cmTarget> target(new cmTarget);
target->SetType(type, name);
target->MarkAsImported();
target->MarkAsImported(global);
target->SetMakefile(this);
// Add to the set of available imported targets.
this->ImportedTargets[name] = target.get();
if(global)
{
this->GetGlobalGenerator()->AddTarget(target.get());
}
// Transfer ownership to this cmMakefile object.
this->ImportedTargetsOwned.push_back(target.get());

23
Source/cmMakefile.h
View File

@ -283,7 +283,7 @@ public:
cmTarget* AddLibrary(const std::string& libname, cmState::TargetType type,
const std::vector<std::string> &srcs,
bool excludeFromAll = false);
void AddAlias(const std::string& libname, cmTarget *tgt);
void AddAlias(const std::string& libname, const std::string& tgt);
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
@ -390,6 +390,7 @@ public:
{
return this->ImportedTargetsOwned;
}
std::vector<cmTarget*> GetImportedTargets() const;
cmTarget* FindTarget(const std::string& name,
bool excludeAliases = false) const;
@ -400,6 +401,11 @@ public:
bool excludeAliases = false) const;
bool IsAlias(const std::string& name) const;
std::map<std::string, std::string> GetAliasTargets() const
{
return this->AliasTargets;
}
/**
* Mark include directories as system directories.
*/
@ -425,17 +431,6 @@ public:
cmSourceFile* GetOrCreateSource(const std::string& sourceName,
bool generated = false);
//@{
/**
* Return a list of extensions associated with source and header
* files
*/
const std::vector<std::string>& GetSourceExtensions() const
{return this->SourceFileExtensions;}
const std::vector<std::string>& GetHeaderExtensions() const
{return this->HeaderFileExtensions;}
//@}
/**
* Given a variable name, return its value (as a string).
* If the variable is not found in this makefile instance, the
@ -801,7 +796,7 @@ protected:
#else
typedef std::map<std::string, cmTarget*> TargetMap;
#endif
TargetMap AliasTargets;
std::map<std::string, std::string> AliasTargets;
std::vector<cmSourceFile*> SourceFiles;
// Tests
@ -823,8 +818,6 @@ protected:
std::vector<cmTestGenerator*> TestGenerators;
std::string ComplainFileRegularExpression;
std::vector<std::string> SourceFileExtensions;
std::vector<std::string> HeaderFileExtensions;
std::string DefineFlags;
// Track the value of the computed DEFINITIONS property.

6
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@ -279,11 +279,11 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
{
this->LocalGenerator
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreBuildCommands(),
this->GeneratorTarget->GetPreBuildCommands(),
this->GeneratorTarget);
this->LocalGenerator
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreLinkCommands(),
this->GeneratorTarget->GetPreLinkCommands(),
this->GeneratorTarget);
}
@ -450,7 +450,7 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
{
this->LocalGenerator->
AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
}

8
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -114,7 +114,7 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules()
// Add post-build rules.
this->LocalGenerator->
AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
// Depend on the object files.
@ -458,11 +458,11 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
{
this->LocalGenerator
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreBuildCommands(),
this->GeneratorTarget->GetPreBuildCommands(),
this->GeneratorTarget);
this->LocalGenerator
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreLinkCommands(),
this->GeneratorTarget->GetPreLinkCommands(),
this->GeneratorTarget);
}
@ -814,7 +814,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
{
this->LocalGenerator->
AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
}

8
Source/cmMakefileUtilityTargetGenerator.cxx
View File

@ -67,20 +67,20 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
// Utility targets store their rules in pre- and post-build commands.
this->LocalGenerator->AppendCustomDepends
(depends, this->GeneratorTarget->Target->GetPreBuildCommands());
(depends, this->GeneratorTarget->GetPreBuildCommands());
this->LocalGenerator->AppendCustomDepends
(depends, this->GeneratorTarget->Target->GetPostBuildCommands());
(depends, this->GeneratorTarget->GetPostBuildCommands());
this->LocalGenerator->AppendCustomCommands
(commands, this->GeneratorTarget->Target->GetPreBuildCommands(),
(commands, this->GeneratorTarget->GetPreBuildCommands(),
this->GeneratorTarget);
// Depend on all custom command outputs for sources
this->DriveCustomCommands(depends);
this->LocalGenerator->AppendCustomCommands
(commands, this->GeneratorTarget->Target->GetPostBuildCommands(),
(commands, this->GeneratorTarget->GetPostBuildCommands(),
this->GeneratorTarget);
// Add dependencies on targets that must be built first.

6
Source/cmNinjaNormalTargetGenerator.cxx
View File

@ -598,9 +598,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
}
const std::vector<cmCustomCommand> *cmdLists[3] = {
&gt.Target->GetPreBuildCommands(),
&gt.Target->GetPreLinkCommands(),
&gt.Target->GetPostBuildCommands()
&gt.GetPreBuildCommands(),
&gt.GetPreLinkCommands(),
&gt.GetPostBuildCommands()
};
std::vector<std::string> preLinkCmdLines, postBuildCmdLines;

4
Source/cmNinjaUtilityTargetGenerator.cxx
View File

@ -33,8 +33,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
cmNinjaDeps deps, outputs, util_outputs(1, utilCommandName);
const std::vector<cmCustomCommand> *cmdLists[2] = {
&this->GetGeneratorTarget()->Target->GetPreBuildCommands(),
&this->GetGeneratorTarget()->Target->GetPostBuildCommands()
&this->GetGeneratorTarget()->GetPreBuildCommands(),
&this->GetGeneratorTarget()->GetPostBuildCommands()
};
bool uses_terminal = false;

2
Source/cmOSXBundleGenerator.cxx
View File

@ -83,7 +83,7 @@ void cmOSXBundleGenerator::CreateFramework(
std::string newoutpath = outpath + "/" +
this->GT->GetFrameworkDirectory(this->ConfigName, false);
std::string frameworkVersion = this->GT->Target->GetFrameworkVersion();
std::string frameworkVersion = this->GT->GetFrameworkVersion();
// Configure the Info.plist file into the Resources directory.
this->MacContentFolders->insert("Resources");

1
Source/cmQtAutoGeneratorInitializer.cxx
View File

@ -896,7 +896,6 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
lg->AddGeneratorTarget(gt);
lg->GetGlobalGenerator()->AddGeneratorTarget(autogenTarget, gt);
// Set target folder
const char* autogenFolder = makefile->GetState()

2
Source/cmQtAutoGenerators.cxx
View File

@ -528,7 +528,7 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
cmSystemTools::ExpandListArgument(this->Sources, sourceFiles);
const std::vector<std::string>& headerExtensions =
makefile->GetHeaderExtensions();
makefile->GetCMakeInstance()->GetHeaderExtensions();
std::map<std::string, std::vector<std::string> > includedUis;
std::map<std::string, std::vector<std::string> > skippedUis;

6
Source/cmSourceFile.cxx
View File

@ -167,8 +167,10 @@ bool cmSourceFile::FindFullPath(std::string* error)
{
tryDirs[0] = "";
}
const std::vector<std::string>& srcExts = mf->GetSourceExtensions();
const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions();
const std::vector<std::string>& srcExts =
mf->GetCMakeInstance()->GetSourceExtensions();
std::vector<std::string> hdrExts =
mf->GetCMakeInstance()->GetHeaderExtensions();
for(const char* const* di = tryDirs; *di; ++di)
{
std::string tryPath = this->Location.GetDirectory();

12
Source/cmSourceFileLocation.cxx
View File

@ -121,8 +121,10 @@ void cmSourceFileLocation::UpdateExtension(const std::string& name)
// The global generator checks extensions of enabled languages.
cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
cmMakefile const* mf = this->Makefile;
const std::vector<std::string>& srcExts = mf->GetSourceExtensions();
const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions();
const std::vector<std::string>& srcExts =
mf->GetCMakeInstance()->GetSourceExtensions();
const std::vector<std::string>& hdrExts =
mf->GetCMakeInstance()->GetHeaderExtensions();
if(!gg->GetLanguageFromExtension(ext.c_str()).empty() ||
std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
@ -193,12 +195,14 @@ cmSourceFileLocation
// disk. One of these must match if loc refers to this source file.
std::string const& ext = this->Name.substr(loc.Name.size()+1);
cmMakefile const* mf = this->Makefile;
const std::vector<std::string>& srcExts = mf->GetSourceExtensions();
const std::vector<std::string>& srcExts =
mf->GetCMakeInstance()->GetSourceExtensions();
if(std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end())
{
return true;
}
const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions();
std::vector<std::string> hdrExts =
mf->GetCMakeInstance()->GetHeaderExtensions();
if(std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
{
return true;

46
Source/cmTarget.cxx
View File

@ -63,6 +63,7 @@ cmTarget::cmTarget()
this->IsAndroid = false;
this->IsApple = false;
this->IsImportedTarget = false;
this->ImportedGloballyVisible = false;
this->BuildInterfaceIncludesAppended = false;
}
@ -314,23 +315,6 @@ cmListFileBacktrace const* cmTarget::GetUtilityBacktrace(
return &i->second;
}
//----------------------------------------------------------------------------
void cmTarget::FinishConfigure()
{
// Erase any cached link information that might have been comptued
// on-demand during the configuration. This ensures that build
// system generation uses up-to-date information even if other cache
// invalidation code in this source file is buggy.
#if defined(_WIN32) && !defined(__CYGWIN__)
// Do old-style link dependency analysis only for CM_USE_OLD_VS6.
if(this->Makefile->GetGlobalGenerator()->IsForVS6())
{
this->AnalyzeLibDependenciesForVS6(*this->Makefile);
}
#endif
}
//----------------------------------------------------------------------------
cmListFileBacktrace const& cmTarget::GetBacktrace() const
{
@ -1522,9 +1506,10 @@ void cmTarget::CheckProperty(const std::string& prop,
}
//----------------------------------------------------------------------------
void cmTarget::MarkAsImported()
void cmTarget::MarkAsImported(bool global)
{
this->IsImportedTarget = true;
this->ImportedGloballyVisible = global;
}
//----------------------------------------------------------------------------
@ -1617,7 +1602,7 @@ const char *cmTarget::GetProperty(const std::string& prop,
// CMake time.
cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
gg->CreateGenerationObjects();
cmGeneratorTarget* gt = gg->GetGeneratorTarget(this);
cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName());
this->Properties.SetProperty(propLOCATION,
gt->GetLocationForBuild());
}
@ -1642,7 +1627,7 @@ const char *cmTarget::GetProperty(const std::string& prop,
{
cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
gg->CreateGenerationObjects();
cmGeneratorTarget* gt = gg->GetGeneratorTarget(this);
cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName());
this->Properties.SetProperty(
prop, gt->GetFullPath(configName, false).c_str());
}
@ -1666,7 +1651,7 @@ const char *cmTarget::GetProperty(const std::string& prop,
{
cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
gg->CreateGenerationObjects();
cmGeneratorTarget* gt = gg->GetGeneratorTarget(this);
cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName());
this->Properties.SetProperty(
prop, gt->GetFullPath(configName, false).c_str());
}
@ -2048,25 +2033,6 @@ void cmTarget::SetPropertyDefault(const std::string& property,
}
}
//----------------------------------------------------------------------------
std::string cmTarget::GetFrameworkVersion() const
{
assert(this->GetType() != cmState::INTERFACE_LIBRARY);
if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION"))
{
return fversion;
}
else if(const char* tversion = this->GetProperty("VERSION"))
{
return tversion;
}
else
{
return "A";
}
}
bool cmTarget::GetMappedConfig(std::string const& desired_config,
const char** loc,
const char** imp,

20
Source/cmTarget.h
View File

@ -75,7 +75,7 @@ public:
*/
void SetType(cmState::TargetType f, const std::string& name);
void MarkAsImported();
void MarkAsImported(bool global = false);
///! Set/Get the name of the target
const std::string& GetName() const {return this->Name;}
@ -176,9 +176,6 @@ public:
std::set<std::string>const& GetUtilities() const { return this->Utilities; }
cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
/** Finalize the target at the end of the Configure step. */
void FinishConfigure();
///! Set/Get a property of this target file
void SetProperty(const std::string& prop, const char *value);
void AppendProperty(const std::string& prop, const char* value,
@ -189,6 +186,8 @@ public:
void CheckProperty(const std::string& prop, cmMakefile* context) const;
bool IsImported() const {return this->IsImportedTarget;}
bool IsImportedGloballyVisible() const
{ return this->ImportedGloballyVisible; }
// Get the properties
cmPropertyMap &GetProperties() const { return this->Properties; }
@ -209,10 +208,6 @@ public:
/** Return whether this target is an executable Bundle on Apple. */
bool IsAppBundleOnApple() const;
/** Return the framework version string. Undefined if
IsFrameworkOnApple returns false. */
std::string GetFrameworkVersion() const;
/** Get a backtrace from the creation of the target. */
cmListFileBacktrace const& GetBacktrace() const;
@ -234,9 +229,6 @@ public:
std::set<std::string> const & GetSystemIncludeDirectories() const
{ return this->SystemIncludeDirectories; }
bool LinkLanguagePropagatesToDependents() const
{ return this->TargetTypeValue == cmState::STATIC_LIBRARY; }
cmStringRange GetIncludeDirectoriesEntries() const;
cmBacktraceRange GetIncludeDirectoriesBacktraces() const;
@ -254,10 +246,11 @@ public:
cmStringRange GetLinkImplementationEntries() const;
cmBacktraceRange GetLinkImplementationBacktraces() const;
#if defined(_WIN32) && !defined(__CYGWIN__)
const LinkLibraryVectorType &GetLinkLibrariesForVS6() const {
return this->LinkLibrariesForVS6;}
void AnalyzeLibDependenciesForVS6( const cmMakefile& mf );
#endif
struct StrictTargetComparison {
@ -316,8 +309,6 @@ private:
void GatherDependenciesForVS6( const cmMakefile& mf,
const LibraryID& lib,
DependencyMap& dep_map);
void AnalyzeLibDependenciesForVS6( const cmMakefile& mf );
#endif
const char* GetSuffixVariableInternal(bool implib) const;
@ -360,6 +351,7 @@ private:
bool IsAndroid;
bool IsApple;
bool IsImportedTarget;
bool ImportedGloballyVisible;
bool BuildInterfaceIncludesAppended;
#if defined(_WIN32) && !defined(__CYGWIN__)
bool LinkLibrariesForVS6Analyzed;

8
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -2814,7 +2814,7 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName)
{
addedPrelink = true;
std::vector<cmCustomCommand> commands =
this->GeneratorTarget->Target->GetPreLinkCommands();
this->GeneratorTarget->GetPreLinkCommands();
this->GlobalGenerator->AddSymbolExportCommand(
this->GeneratorTarget, commands, configName);
this->WriteEvent("PreLinkEvent", commands, configName);
@ -2823,12 +2823,12 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName)
if (!addedPrelink)
{
this->WriteEvent("PreLinkEvent",
this->GeneratorTarget->Target->GetPreLinkCommands(), configName);
this->GeneratorTarget->GetPreLinkCommands(), configName);
}
this->WriteEvent("PreBuildEvent",
this->GeneratorTarget->Target->GetPreBuildCommands(), configName);
this->GeneratorTarget->GetPreBuildCommands(), configName);
this->WriteEvent("PostBuildEvent",
this->GeneratorTarget->Target->GetPostBuildCommands(), configName);
this->GeneratorTarget->GetPostBuildCommands(), configName);
}
void cmVisualStudio10TargetGenerator::WriteEvent(

35
Source/cmake.cxx
View File

@ -165,6 +165,30 @@ cmake::cmake()
// Make sure we can capture the build tool output.
cmSystemTools::EnableVSConsoleOutput();
// Set up a list of source and header extensions
// these are used to find files when the extension
// is not given
// The "c" extension MUST precede the "C" extension.
this->SourceFileExtensions.push_back( "c" );
this->SourceFileExtensions.push_back( "C" );
this->SourceFileExtensions.push_back( "c++" );
this->SourceFileExtensions.push_back( "cc" );
this->SourceFileExtensions.push_back( "cpp" );
this->SourceFileExtensions.push_back( "cxx" );
this->SourceFileExtensions.push_back( "m" );
this->SourceFileExtensions.push_back( "M" );
this->SourceFileExtensions.push_back( "mm" );
this->HeaderFileExtensions.push_back( "h" );
this->HeaderFileExtensions.push_back( "hh" );
this->HeaderFileExtensions.push_back( "h++" );
this->HeaderFileExtensions.push_back( "hm" );
this->HeaderFileExtensions.push_back( "hpp" );
this->HeaderFileExtensions.push_back( "hxx" );
this->HeaderFileExtensions.push_back( "in" );
this->HeaderFileExtensions.push_back( "txx" );
}
cmake::~cmake()
@ -423,8 +447,8 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
(cmSystemTools::GetCurrentWorkingDirectory());
// read in the list file to fill the cache
snapshot.SetDefaultDefinitions();
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot));
cmsys::auto_ptr<cmLocalGenerator> lg(gg->CreateLocalGenerator(mf.get()));
cmMakefile* mf = new cmMakefile(gg, snapshot);
gg->AddMakefile(mf);
mf->SetArgcArgv(args);
@ -457,6 +481,8 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
std::vector<std::string> includeDirs;
cmSystemTools::ExpandListArgument(includes, includeDirs);
gg->CreateGenerationObjects();
cmLocalGenerator* lg = gg->LocalGenerators[0];
std::string includeFlags = lg->GetIncludeFlags(includeDirs, 0, language);
std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS");
@ -486,8 +512,9 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
std::string linkPath;
std::string flags;
std::string linkFlags;
gg->CreateGeneratorTargets(cmGlobalGenerator::AllTargets, lg.get());
cmGeneratorTarget *gtgt = gg->GetGeneratorTarget(tgt);
gg->CreateGenerationObjects();
cmGeneratorTarget *gtgt = gg->FindGeneratorTarget(tgt->GetName());
cmLocalGenerator* lg = gtgt->GetLocalGenerator();
lg->GetTargetFlags(linkLibs, frameworkPath, linkPath, flags, linkFlags,
gtgt, false);
linkLibs = frameworkPath + linkPath + linkLibs;

7
Source/cmake.h
View File

@ -182,6 +182,11 @@ class cmake
///! get the cmCachemManager used by this invocation of cmake
cmCacheManager *GetCacheManager() { return this->CacheManager; }
const std::vector<std::string>& GetSourceExtensions() const
{return this->SourceFileExtensions;}
const std::vector<std::string>& GetHeaderExtensions() const
{return this->HeaderFileExtensions;}
/**
* Given a variable name, return its value (as a string).
*/
@ -391,6 +396,8 @@ private:
std::string CheckStampFile;
std::string CheckStampList;
std::string VSSolutionFile;
std::vector<std::string> SourceFileExtensions;
std::vector<std::string> HeaderFileExtensions;
bool ClearBuildSystem;
bool DebugTryCompile;
cmFileTimeComparison* FileComparison;