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

ENH: add the IMPORT keyword to ADD_EXECUTABLE(), which generates an 

"imported" executable target. This can then be used e.g. with
ADD_CUSTOM_COMMAND() to generate stuff. It adds a second container for
"imported" targets, and FindTarget() now takes an additional argument bool
useImportedTargets to specify whether you also want to search in the
imported targets or only in the "normal" targets.

Alex
This commit is contained in:
Alexander Neundorf 2007-05-22 10:24:59 -04:00
parent 6be930f0cf
commit 4878c00905
24 changed files with 485 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmAddDependenciesCommand.cxx
View File

@ -32,7 +32,7 @@ bool cmAddDependenciesCommand::InitialPass(
cmTarget* target =
this->GetMakefile()->GetLocalGenerator()->
GetGlobalGenerator()->FindTarget(0, target_name.c_str());
GetGlobalGenerator()->FindTarget(0, target_name.c_str(), false);
if(target)
{
std::vector<std::string>::const_iterator s = args.begin();

12
Source/cmAddExecutableCommand.cxx
View File

@ -32,6 +32,7 @@ bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args)
bool use_win32 = false;
bool use_macbundle = false;
bool excludeFromAll = false;
bool importTarget = false;
while ( s != args.end() )
{
if (*s == "WIN32")
@ -49,12 +50,23 @@ bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args)
++s;
excludeFromAll = true;
}
else if(*s == "IMPORT")
{
++s;
importTarget = true;
}
else
{
break;
}
}
if (importTarget)
{
cmTarget* target = this->Makefile->AddNewTarget(cmTarget::EXECUTABLE, exename.c_str(), true);
return true;
}
if (s == args.end())
{
this->SetError

2
Source/cmGetTargetPropertyCommand.cxx
View File

@ -29,7 +29,7 @@ bool cmGetTargetPropertyCommand::InitialPass(
const char* targetName = args[1].c_str();
cmTarget *tgt = this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
->FindTarget(0,targetName);
->FindTarget(0, targetName, true);
if (tgt)
{
cmTarget& target = *tgt;

43
Source/cmGlobalGenerator.cxx
View File

@ -625,6 +625,7 @@ void cmGlobalGenerator::Configure()
this->LocalGenerators.clear();
this->TargetDependencies.clear();
this->TotalTargets.clear();
this->ImportedTotalTargets.clear();
this->ProjectToTargetMap.clear();
this->ProjectMap.clear();
@ -1179,7 +1180,8 @@ cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(const char* start_dir)
cmTarget* cmGlobalGenerator::FindTarget(const char* project,
const char* name)
const char* name,
bool useImportedTargets)
{
// if project specific
if(project)
@ -1187,7 +1189,8 @@ cmTarget* cmGlobalGenerator::FindTarget(const char* project,
std::vector<cmLocalGenerator*>* gens = &this->ProjectMap[project];
for(unsigned int i = 0; i < gens->size(); ++i)
{
cmTarget* ret = (*gens)[i]->GetMakefile()->FindTarget(name);
cmTarget* ret = (*gens)[i]->GetMakefile()->FindTarget(name,
useImportedTargets);
if(ret)
{
return ret;
@ -1198,13 +1201,22 @@ cmTarget* cmGlobalGenerator::FindTarget(const char* project,
else
{
std::map<cmStdString,cmTarget *>::iterator i =
this->TotalTargets.find(name);
if (i == this->TotalTargets.end())
this->TotalTargets.find ( name );
if ( i != this->TotalTargets.end() )
{
return 0;
}
return i->second;
}
if ( useImportedTargets )
{
std::map<cmStdString,cmTarget *>::iterator importedTarget =
this->ImportedTotalTargets.find ( name );
if ( importedTarget != this->ImportedTotalTargets.end() )
{
return importedTarget->second;
}
}
}
return 0;
}
@ -1549,12 +1561,12 @@ std::vector<cmTarget *>& cmGlobalGenerator
if(emitted.insert(lib->first).second)
{
cmTarget *target2 =
target.GetMakefile()->FindTarget(lib->first.c_str());
target.GetMakefile()->FindTarget(lib->first.c_str(), false);
// search each local generator until a match is found
if (!target2)
{
target2 = this->FindTarget(0,lib->first.c_str());
target2 = this->FindTarget(0,lib->first.c_str(), false);
}
// if a match was found then ...
@ -1575,12 +1587,12 @@ std::vector<cmTarget *>& cmGlobalGenerator
// Don't emit the same utility twice for this target.
if(emitted.insert(*util).second)
{
cmTarget *target2 = target.GetMakefile()->FindTarget(util->c_str());
cmTarget *target2 = target.GetMakefile()->FindTarget(util->c_str(), false);
// search each local generator until a match is found
if (!target2)
{
target2 = this->FindTarget(0,util->c_str());
target2 = this->FindTarget(0,util->c_str(), false);
}
// if a match was found then ...
@ -1594,3 +1606,14 @@ std::vector<cmTarget *>& cmGlobalGenerator
return result;
}
void cmGlobalGenerator::AddTarget(cmTargets::value_type &v)
{
if (v.second.IsImported())
{
this->ImportedTotalTargets[v.first] = &v.second;
}
else
{
this->TotalTargets[v.first] = &v.second;
}
}

6
Source/cmGlobalGenerator.h
View File

@ -157,7 +157,7 @@ public:
void FindMakeProgram(cmMakefile*);
///! Find a target by name by searching the local generators.
cmTarget* FindTarget(const char* project, const char* name);
cmTarget* FindTarget(const char* project, const char* name, bool useImportedTargets);
/** If check to see if the target is linked to by any other
target in the project */
@ -177,8 +177,7 @@ public:
configuration. This is valid during generation only. */
cmTargetManifest const& GetTargetManifest() { return this->TargetManifest; }
void AddTarget(cmTargets::value_type &v) {
this->TotalTargets[v.first] = &v.second;};
void AddTarget(cmTargets::value_type &v);
/** Support for multiple custom command outputs. */
virtual void CheckMultipleOutputs(cmMakefile* mf, bool verbose);
@ -240,6 +239,7 @@ private:
// this is used to improve performance
std::map<cmStdString,cmTarget *> TotalTargets;
std::map<cmStdString,cmTarget *> ImportedTotalTargets;
std::map<cmStdString, std::vector<cmTarget *> > TargetDependencies;
};

27
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -641,15 +641,14 @@ cmGlobalUnixMakefileGenerator3
// simple name)
if(t->second.GetName() &&
strlen(t->second.GetName()) &&
emitted.insert(t->second.GetName()).second)
{
emitted.insert(t->second.GetName()).second &&
// Handle user targets here. Global targets are handled in
// the local generator on a per-directory basis.
if((t->second.GetType() == cmTarget::EXECUTABLE) ||
((t->second.GetType() == cmTarget::EXECUTABLE) ||
(t->second.GetType() == cmTarget::STATIC_LIBRARY) ||
(t->second.GetType() == cmTarget::SHARED_LIBRARY) ||
(t->second.GetType() == cmTarget::MODULE_LIBRARY) ||
(t->second.GetType() == cmTarget::UTILITY))
(t->second.GetType() == cmTarget::UTILITY)))
{
// Add a rule to build the target by name.
lg->WriteDivider(ruleFileStream);
@ -688,7 +687,6 @@ cmGlobalUnixMakefileGenerator3
}
}
}
}
}
@ -714,7 +712,13 @@ cmGlobalUnixMakefileGenerator3
cmTargets& targets = lg->GetMakefile()->GetTargets();
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
{
if (t->second.GetName() && strlen(t->second.GetName()))
if (t->second.GetName()
&& strlen(t->second.GetName())
&& ((t->second.GetType() == cmTarget::EXECUTABLE)
|| (t->second.GetType() == cmTarget::STATIC_LIBRARY)
|| (t->second.GetType() == cmTarget::SHARED_LIBRARY)
|| (t->second.GetType() == cmTarget::MODULE_LIBRARY)
|| (t->second.GetType() == cmTarget::UTILITY)))
{
std::string makefileName;
// Add a rule to build the target by name.
@ -722,12 +726,6 @@ cmGlobalUnixMakefileGenerator3
makefileName = localName;
makefileName += "/build.make";
if (((t->second.GetType() == cmTarget::EXECUTABLE) ||
(t->second.GetType() == cmTarget::STATIC_LIBRARY) ||
(t->second.GetType() == cmTarget::SHARED_LIBRARY) ||
(t->second.GetType() == cmTarget::MODULE_LIBRARY) ||
(t->second.GetType() == cmTarget::UTILITY)))
{
bool needRequiresStep =
this->NeedRequiresStep(lg,t->second.GetName());
@ -882,7 +880,6 @@ cmGlobalUnixMakefileGenerator3
"clean", depends, commands, true);
}
}
}
}
//----------------------------------------------------------------------------
@ -1060,12 +1057,12 @@ cmGlobalUnixMakefileGenerator3
// first check the same dir as the current target
lg3 = static_cast<cmLocalUnixMakefileGenerator3 *>
(target.GetMakefile()->GetLocalGenerator());
result = target.GetMakefile()->FindTarget(name);
result = target.GetMakefile()->FindTarget(name, false);
// search each local generator until a match is found
if (!result)
{
result = this->FindTarget(0,name);
result = this->FindTarget(0, name, false);
if (result)
{
lg3 = static_cast<cmLocalUnixMakefileGenerator3 *>

2
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -401,7 +401,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
if(j->first != dspname)
{
// is the library part of this DSW ? If so add dependency
if(this->FindTarget(0, j->first.c_str()))
if(this->FindTarget(0, j->first.c_str()), false)
{
fout << "Begin Project Dependency\n";
fout << "Project_Dep_Name " << j->first.c_str() << "\n";

4
Source/cmGlobalVisualStudio71Generator.cxx
View File

@ -333,7 +333,9 @@ cmGlobalVisualStudio71Generator
if(j->first != dspname)
{
// is the library part of this SLN ? If so add dependency
if(this->FindTarget(this->CurrentProject.c_str(), j->first.c_str()))
if(this->FindTarget(this->CurrentProject.c_str(),
j->first.c_str()),
false)
{
fout << "\t\t{" << this->GetGUID(j->first.c_str()) << "} = {"
<< this->GetGUID(j->first.c_str()) << "}\n";

4
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -588,7 +588,9 @@ cmGlobalVisualStudio7Generator
if(j->first != dspname)
{
// is the library part of this SLN ? If so add dependency
if(this->FindTarget(this->CurrentProject.c_str(), j->first.c_str()))
if(this->FindTarget(this->CurrentProject.c_str(),
j->first.c_str()),
false)
{
std::string guid = this->GetGUID(j->first.c_str());
if(guid.size() == 0)

2
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -94,7 +94,7 @@ void cmGlobalVisualStudio8Generator::Generate()
mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false,
no_working_directory, no_depends,
noCommandLines);
cmTarget* tgt = mf->FindTarget(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
cmTarget* tgt = mf->FindTarget(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false);
if(!tgt)
{
cmSystemTools::Error("Error adding target "

6
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -104,7 +104,7 @@ cmGlobalVisualStudioGenerator::FixUtilityDependsForTarget(cmTarget& target)
target.GetUtilities().begin();
ui != target.GetUtilities().end(); ++ui)
{
if(cmTarget* depTarget = this->FindTarget(0, ui->c_str()))
if(cmTarget* depTarget = this->FindTarget(0, ui->c_str(), false))
{
if(depTarget->GetType() == cmTarget::STATIC_LIBRARY ||
depTarget->GetType() == cmTarget::SHARED_LIBRARY ||
@ -149,7 +149,7 @@ cmGlobalVisualStudioGenerator::CreateUtilityDependTarget(cmTarget& target)
this->CreateGUID(altNameStr.c_str());
// The intermediate target should depend on the original target.
if(cmTarget* alt = this->FindTarget(0, altNameStr.c_str()))
if(cmTarget* alt = this->FindTarget(0, altNameStr.c_str(), false))
{
alt->AddUtility(target.GetName());
}
@ -205,7 +205,7 @@ cmGlobalVisualStudioGenerator::GetUtilityForTarget(cmTarget& target,
{
// The depender is a target that links. Lookup the dependee to
// see if it provides an alternative dependency name.
if(cmTarget* depTarget = this->FindTarget(0, name))
if(cmTarget* depTarget = this->FindTarget(0, name, false))
{
// Check for an alternative name created by FixUtilityDepends.
if(const char* altName =

9
Source/cmGlobalXCodeGenerator.cxx
View File

@ -272,7 +272,7 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
no_working_directory,
"echo", "Build all projects");
cmTarget* allbuild = mf->FindTarget("ALL_BUILD");
cmTarget* allbuild = mf->FindTarget("ALL_BUILD", false);
// Add XCODE depend helper
std::string dir = mf->GetCurrentOutputDirectory();
@ -1035,8 +1035,7 @@ void cmGlobalXCodeGenerator
cc.GetDepends().begin();
d != cc.GetDepends().end(); ++d)
{
if(!this->FindTarget(this->CurrentProject.c_str(),
d->c_str()))
if(!this->FindTarget(this->CurrentProject.c_str(), d->c_str(), false))
{
// if the depend is not a target but
// is a full path then use it, if not then
@ -1860,7 +1859,7 @@ void cmGlobalXCodeGenerator
{
// Add this dependency.
cmTarget* t = this->FindTarget(this->CurrentProject.c_str(),
lib->first.c_str());
lib->first.c_str(), false);
cmXCodeObject* dptarget = this->FindXCodeTarget(t);
if(dptarget)
{
@ -1876,7 +1875,7 @@ void cmGlobalXCodeGenerator
i != cmtarget->GetUtilities().end(); ++i)
{
cmTarget* t = this->FindTarget(this->CurrentProject.c_str(),
i->c_str());
i->c_str(), false);
// if the target is in this project then make target depend
// on it. It may not be in this project if this is a sub
// project from the top.

14
Source/cmIncludeExternalMSProjectCommand.cxx
View File

@ -50,10 +50,8 @@ bool cmIncludeExternalMSProjectCommand
cmSystemTools::ConvertToUnixSlashes(path);
// Create a target instance for this utility.
cmTarget target;
target.SetType(cmTarget::UTILITY, utility_name.c_str());
target.SetProperty("EXCLUDE_FROM_ALL","FALSE");
target.SetMakefile(this->Makefile);
cmTarget* target=this->Makefile->AddNewTarget(cmTarget::UTILITY, utility_name.c_str());
target->SetProperty("EXCLUDE_FROM_ALL","FALSE");
std::vector<std::string> no_outputs;
cmCustomCommandLines commandLines;
cmCustomCommandLine commandLine;
@ -61,13 +59,7 @@ bool cmIncludeExternalMSProjectCommand
commandLine.push_back(path);
commandLines.push_back(commandLine);
cmCustomCommand cc(no_outputs, depends, commandLines, 0, 0);
target.GetPostBuildCommands().push_back(cc);
// Add the target to the set of targets.
cmTargets::iterator it =
this->Makefile->GetTargets()
.insert(cmTargets::value_type(utility_name.c_str(),target)).first;
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()->AddTarget(*it);
target->GetPostBuildCommands().push_back(cc);
}
#endif
return true;

2
Source/cmInstallCommand.cxx
View File

@ -252,7 +252,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
else if(doing_targets)
{
// Lookup this target in the current directory.
if(cmTarget* target = this->Makefile->FindTarget(args[i].c_str()))
if(cmTarget* target = this->Makefile->FindTarget(args[i].c_str(), false))
{
// Found the target. Check its type.
if(target->GetType() != cmTarget::EXECUTABLE &&

2
Source/cmInstallTargetGenerator.cxx
View File

@ -376,7 +376,7 @@ void cmInstallTargetGenerator
{
if(cmTarget* tgt = this->Target->GetMakefile()->
GetLocalGenerator()->GetGlobalGenerator()->
FindTarget(0, lib.c_str()))
FindTarget(0, lib.c_str(), false))
{
if(tgt->GetType() == cmTarget::SHARED_LIBRARY)
{

11
Source/cmLocalGenerator.cxx
View File

@ -148,8 +148,7 @@ void cmLocalGenerator::TraceDependencies()
if ((t->second.GetType() != cmTarget::INSTALL_FILES)
&& (t->second.GetType() != cmTarget::INSTALL_PROGRAMS)
&& (t->second.GetType() != cmTarget::INSTALL_DIRECTORY)
&& (strncmp(t->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0)
&& (t->second.GetPropertyAsBool("IMPORTED") == false))
&& (strncmp(t->first.c_str(), "INCLUDE_EXTERNAL_MSPROJECT", 26) != 0))
{
std::string projectFilename;
if (this->IsMakefileGenerator == false) // only use of this variable
@ -1733,7 +1732,7 @@ void cmLocalGenerator
(j->second == cmTarget::GENERAL || j->second == linkType))
{
// Compute the proper name to use to link this library.
cmTarget* tgt = this->GlobalGenerator->FindTarget(0, lib.c_str());
cmTarget* tgt = this->GlobalGenerator->FindTarget(0, lib.c_str(), false);
bool impexe = (tgt &&
tgt->GetType() == cmTarget::EXECUTABLE &&
tgt->GetPropertyAsBool("ENABLE_EXPORTS"));
@ -1963,7 +1962,7 @@ std::string cmLocalGenerator::GetRealDependency(const char* inName,
}
// Look for a CMake target with the given name.
if(cmTarget* target = this->GlobalGenerator->FindTarget(0, name.c_str()))
if(cmTarget* target = this->GlobalGenerator->FindTarget(0,name.c_str(),false))
{
// make sure it is not just a coincidence that the target name
// found is part of the inName
@ -2029,8 +2028,8 @@ std::string cmLocalGenerator::GetRealLocation(const char* inName,
{
std::string outName=inName;
// Look for a CMake target with the given name.
cmTarget* target = this->GlobalGenerator->FindTarget(0, inName);
if ((target!=0) && (target->GetType()==cmTarget::EXECUTABLE))
cmTarget* target = this->GlobalGenerator->FindTarget(0, inName, true);
if ((target != 0) && (target->GetType() == cmTarget::EXECUTABLE))
{
outName = target->GetLocation( config );
}

1
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -114,7 +114,6 @@ void cmLocalUnixMakefileGenerator3::Generate()
if (tg)
{
this->TargetGenerators.push_back(tg);
// t->second.TraceVSDependencies(empty, this->Makefile);
tg->WriteRuleFiles();
}
}

3
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -1051,7 +1051,8 @@ void cmLocalVisualStudio6Generator
// Compute the proper name to use to link this library.
std::string lib;
std::string libDebug;
cmTarget* tgt = this->GlobalGenerator->FindTarget(0, j->first.c_str());
cmTarget* tgt = this->GlobalGenerator->FindTarget(0, j->first.c_str(),
false);
if(tgt)
{
lib = cmSystemTools::GetFilenameWithoutExtension

88
Source/cmMakefile.cxx
View File

@ -825,12 +825,10 @@ void cmMakefile::AddUtilityCommand(const char* utilityName,
bool escapeOldStyle, const char* comment)
{
// Create a target instance for this utility.
cmTarget target;
target.SetMakefile(this);
target.SetType(cmTarget::UTILITY, utilityName);
cmTarget* target = this->AddNewTarget(cmTarget::UTILITY, utilityName, false);
if (excludeFromAll)
{
target.SetProperty("EXCLUDE_FROM_ALL", "TRUE");
target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
}
if(!comment)
{
@ -850,7 +848,7 @@ void cmMakefile::AddUtilityCommand(const char* utilityName,
commandLines, comment,
workingDirectory, no_replace,
escapeOldStyle);
target.GetSourceLists().push_back(force);
target->GetSourceLists().push_back(force);
// The output is not actually created so mark it symbolic.
if(cmSourceFile* sf = this->GetSource(force.c_str()))
@ -862,11 +860,6 @@ void cmMakefile::AddUtilityCommand(const char* utilityName,
cmSystemTools::Error("Could not get source file entry for ",
force.c_str());
}
// Add the target to the set of targets.
cmTargets::iterator it =
this->Targets.insert(cmTargets::value_type(utilityName,target)).first;
this->LocalGenerator->GetGlobalGenerator()->AddTarget(*it);
}
void cmMakefile::AddDefineFlag(const char* flag)
@ -940,7 +933,7 @@ void cmMakefile::AddLinkLibraryForTarget(const char *target,
if ( i != this->Targets.end())
{
cmTarget* tgt =
this->GetCMakeInstance()->GetGlobalGenerator()->FindTarget(0, lib);
this->GetCMakeInstance()->GetGlobalGenerator()->FindTarget(0, lib, false);
if(tgt)
{
bool allowModules = true;
@ -1343,53 +1336,64 @@ void cmMakefile::AddLibrary(const char* lname, int shared,
const std::vector<std::string> &srcs,
bool excludeFromAll)
{
cmTarget target;
cmTarget* target=0;
switch (shared)
{
case 0:
target.SetType(cmTarget::STATIC_LIBRARY, lname);
target=this->AddNewTarget(cmTarget::STATIC_LIBRARY, lname, false);
break;
case 1:
target.SetType(cmTarget::SHARED_LIBRARY, lname);
target=this->AddNewTarget(cmTarget::SHARED_LIBRARY, lname, false);
break;
case 2:
target.SetType(cmTarget::MODULE_LIBRARY, lname);
target=this->AddNewTarget(cmTarget::MODULE_LIBRARY, lname, false);
break;
default:
target.SetType(cmTarget::STATIC_LIBRARY, lname);
target=this->AddNewTarget(cmTarget::STATIC_LIBRARY, lname, false);
}
target.SetMakefile(this);
// Clear its dependencies. Otherwise, dependencies might persist
// over changes in CMakeLists.txt, making the information stale and
// hence useless.
target.ClearDependencyInformation( *this, lname );
target->ClearDependencyInformation( *this, lname );
if(excludeFromAll)
{
target.SetProperty("EXCLUDE_FROM_ALL", "TRUE");
target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
}
target.GetSourceLists() = srcs;
this->AddGlobalLinkInformation(lname, target);
cmTargets::iterator it =
this->Targets.insert(cmTargets::value_type(lname,target)).first;
this->LocalGenerator->GetGlobalGenerator()->AddTarget(*it);
target->GetSourceLists() = srcs;
this->AddGlobalLinkInformation(lname, *target);
}
cmTarget* cmMakefile::AddExecutable(const char *exeName,
const std::vector<std::string> &srcs,
bool excludeFromAll)
{
cmTarget target;
target.SetType(cmTarget::EXECUTABLE, exeName);
target.SetMakefile(this);
cmTarget* target = this->AddNewTarget(cmTarget::EXECUTABLE, exeName, false);
if(excludeFromAll)
{
target.SetProperty("EXCLUDE_FROM_ALL", "TRUE");
target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
}
target->GetSourceLists() = srcs;
this->AddGlobalLinkInformation(exeName, *target);
return target;
}
cmTarget* cmMakefile::AddNewTarget(cmTarget::TargetType type, const char* name, bool isImported)
{
cmTargets::iterator it;
cmTarget target;
target.SetType(type, name);
target.SetMakefile(this);
if (isImported)
{
target.MarkAsImported();
it=this->ImportedTargets.insert(cmTargets::value_type(target.GetName(), target)).first;
}
else
{
it=this->Targets.insert(cmTargets::value_type(target.GetName(), target)).first;
}
target.GetSourceLists() = srcs;
this->AddGlobalLinkInformation(exeName, target);
cmTargets::iterator it =
this->Targets.insert(cmTargets::value_type(exeName,target)).first;
this->LocalGenerator->GetGlobalGenerator()->AddTarget(*it);
return &it->second;
}
@ -2718,16 +2722,26 @@ bool cmMakefile::GetPropertyAsBool(const char* prop)
}
cmTarget* cmMakefile::FindTarget(const char* name)
cmTarget* cmMakefile::FindTarget(const char* name, bool useImportedTargets)
{
cmTargets& tgts = this->GetTargets();
cmTargets::iterator i = tgts.find(name);
if (i == tgts.end())
cmTargets::iterator i = tgts.find ( name );
if ( i != tgts.end() )
{
return 0;
}
return &i->second;
}
if (useImportedTargets)
{
cmTargets::iterator impTarget = this->ImportedTargets.find(name);
if (impTarget != this->ImportedTargets.end())
{
return &impTarget->second;
}
}
return 0;
}
cmTest* cmMakefile::CreateTest(const char* testName)

6
Source/cmMakefile.h
View File

@ -167,6 +167,8 @@ public:
void AddDefineFlag(const char* definition);
void RemoveDefineFlag(const char* definition);
cmTarget* AddNewTarget(cmTarget::TargetType type, const char* name, bool isImported);
/**
* Add an executable to the build.
*/
@ -416,8 +418,9 @@ public:
* Get the list of targets
*/
cmTargets &GetTargets() { return this->Targets; }
const cmTargets &GetImportedTargets() const { return this->ImportedTargets; }
cmTarget* FindTarget(const char* name);
cmTarget* FindTarget(const char* name, bool useImportedTargets);
/**
@ -741,6 +744,7 @@ protected:
// libraries, classes, and executables
cmTargets Targets;
cmTargets ImportedTargets;
std::vector<cmSourceFile*> SourceFiles;
// Tests

2
Source/cmMakefileTargetGenerator.cxx
View File

@ -1194,7 +1194,7 @@ void cmMakefileTargetGenerator
{
// Depend on other CMake targets.
if(cmTarget* tgt =
this->GlobalGenerator->FindTarget(0, lib->first.c_str()))
this->GlobalGenerator->FindTarget(0, lib->first.c_str(), false))
{
if(const char* location =
tgt->GetLocation(this->LocalGenerator->ConfigurationName.c_str()))

2
Source/cmSetTargetPropertiesCommand.cxx
View File

@ -96,7 +96,7 @@ bool cmSetTargetPropertiesCommand
cmMakefile *mf)
{
cmTarget* target =
mf->GetLocalGenerator()->GetGlobalGenerator()->FindTarget(0, tname);
mf->GetLocalGenerator()->GetGlobalGenerator()->FindTarget(0, tname, true);
if ( target)
{
// now loop through all the props and set them

116
Source/cmTarget.cxx
View File

@ -38,7 +38,7 @@ cmTarget::cmTarget()
this->LinkDirectoriesComputed = false;
this->HaveInstallRule = false;
this->DLLPlatform = false;
this->IsImportedTarget = false;
}
// define properties
@ -90,7 +90,7 @@ void cmTarget::DefineProperties(cmake *cm)
cm->DefineProperty
("EchoString", cmProperty::TARGET,
"A message to be displayed when the target it built.",
"A message to be displayed when the target is built.",
"A message to display on some generaters (such as makefiles) when "
"the target is built.");
@ -425,7 +425,7 @@ cmTarget
std::string command = *cit->begin();
// see if we can find a target with this name
cmTarget* t = this->Makefile->GetLocalGenerator()->
GetGlobalGenerator()->FindTarget ( 0, command.c_str() );
GetGlobalGenerator()->FindTarget(0, command.c_str(), false);
if ( ( t ) && ( t->GetType() ==cmTarget::EXECUTABLE ) )
{
this->AddUtility ( command.c_str() );
@ -577,7 +577,7 @@ void cmTarget::TraceVSDependencies(std::string projFile,
const std::string& currentCommand = (*it)[0];
// see if we can find a target with this name
cmTarget* t = this->Makefile->GetLocalGenerator()->
GetGlobalGenerator()->FindTarget(0, currentCommand.c_str());
GetGlobalGenerator()->FindTarget(0, currentCommand.c_str(), false);
if (( t) && (t->GetType()==cmTarget::EXECUTABLE))
{
automaticTargetDepends.push_back(currentCommand);
@ -600,7 +600,7 @@ void cmTarget::TraceVSDependencies(std::string projFile,
bool isUtility = false;
// see if we can find a target with this name
cmTarget* t = this->Makefile->GetLocalGenerator()->
GetGlobalGenerator()->FindTarget(0, dep.c_str());
GetGlobalGenerator()->FindTarget(0, dep.c_str(), false);
if(t)
{
// if we find the target and the dep was given as a full
@ -783,7 +783,7 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories()
this->Makefile->GetLocalGenerator()->GetGlobalGenerator())
{
tgt = (this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
->FindTarget(0, lib.c_str()));
->FindTarget(0, lib.c_str(), false));
}
if(tgt)
{
@ -1220,7 +1220,31 @@ void cmTarget::SetProperty(const char* prop, const char* value)
this->Properties.SetProperty(prop, value, cmProperty::TARGET);
}
void cmTarget::MarkAsImported()
{
this->IsImportedTarget = true;
}
const char* cmTarget::GetDirectory(const char* config, bool implib)
{
if (this->IsImported())
{
return this->ImportedGetDirectory(config, implib);
}
else
{
return this->NormalGetDirectory(config, implib);
}
}
const char* cmTarget::ImportedGetDirectory(const char* config, bool implib)
{
const char* location=this->GetLocation(config);
std::string directory=cmSystemTools::GetFilenamePath(location);
return directory.c_str();
}
const char* cmTarget::NormalGetDirectory(const char* config, bool implib)
{
if(config && *config)
{
@ -1237,6 +1261,34 @@ const char* cmTarget::GetDirectory(const char* config, bool implib)
}
const char* cmTarget::GetLocation(const char* config)
{
if (this->IsImported())
{
return this->ImportedGetLocation(config);
}
else
{
return this->NormalGetLocation(config);
}
}
const char* cmTarget::ImportedGetLocation(const char* config)
{
if ((config) && (strlen(config)))
{
std::string propertyName=config;
propertyName+="_LOCATION";
const char* configLocation=this->GetProperty(propertyName.c_str());
if ((configLocation) && (strlen(configLocation)))
{
return configLocation;
}
}
return this->GetProperty("LOCATION");
}
const char* cmTarget::NormalGetLocation(const char* config)
{
this->Location = this->GetDirectory();
if(!this->Location.empty())
@ -1283,6 +1335,11 @@ const char *cmTarget::GetProperty(const char* prop)
void cmTarget::ComputeObjectFiles()
{
if (this->IsImported())
{
return;
}
// Force the SourceFiles vector to be populated
this->GenerateSourceFilesFromSourceLists(*this->Makefile);
std::vector<std::string> dirs;
@ -1336,6 +1393,10 @@ const char *cmTarget::GetProperty(const char* prop,
return 0;
}
// don't use GetLocation() for imported targets, because there this
// calls GetProperty() to get the location...
if (!this->IsImported())
{
// watch for special "computed" properties that are dependent on other
// properties or variables, always recompute them
if (!strcmp(prop,"LOCATION"))
@ -1364,6 +1425,12 @@ const char *cmTarget::GetProperty(const char* prop,
{
this->ComputeObjectFiles();
}
}
if (strcmp(prop,"IMPORTED") == 0)
{
return this->IsImported()?"TRUE":"FALSE";
}
// the type property returns what type the target is
if (!strcmp(prop,"TYPE"))
@ -1607,13 +1674,48 @@ std::string cmTarget::GetFullNameInternal(TargetType type, const char* config,
return prefix+base+suffix;
}
//----------------------------------------------------------------------------
void cmTarget::GetFullNameInternal(TargetType type,
const char* config,
bool implib,
std::string& outPrefix,
std::string& outBase,
std::string& outSuffix)
{
if (this->IsImported())
{
this->ImportedGetFullNameInternal(type, config, implib,
outPrefix, outBase, outSuffix);
}
else
{
this->NormalGetFullNameInternal(type, config, implib,
outPrefix, outBase, outSuffix);
}
}
void cmTarget::ImportedGetFullNameInternal(TargetType type,
const char* config,
bool implib,
std::string& outPrefix,
std::string& outBase,
std::string& outSuffix)
{
// find the basename, suffix and prefix from getLocation()
// implib ?
std::string location=this->GetLocation(config);
outBase=cmSystemTools::GetFilenameWithoutExtension(location);
outSuffix = cmSystemTools::GetFilenameExtension(location);
outPrefix.clear();
}
//----------------------------------------------------------------------------
void cmTarget::NormalGetFullNameInternal(TargetType type,
const char* config,
bool implib,
std::string& outPrefix,
std::string& outBase,
std::string& outSuffix)
{
// Use just the target name for non-main target types.
if(type != cmTarget::STATIC_LIBRARY &&

21
Source/cmTarget.h
View File

@ -44,7 +44,7 @@ public:
/**
* Return the type of target.
*/
TargetType GetType()
TargetType GetType() const
{
return this->TargetTypeValue;
}
@ -54,6 +54,8 @@ public:
*/
void SetType(TargetType f, const char* name);
void MarkAsImported();
///! Set/Get the name of the target
const char* GetName() const {return this->Name.c_str();}
@ -162,6 +164,8 @@ public:
const char *GetProperty(const char *prop, cmProperty::ScopeType scope);
bool GetPropertyAsBool(const char *prop);
bool IsImported() const {return this->IsImportedTarget;}
/** Get the directory in which this target will be built. If the
configuration name is given then the generator will add its
subdirectory for that configuration. Otherwise just the canonical
@ -327,6 +331,7 @@ private:
void GetFullNameInternal(TargetType type, const char* config, bool implib,
std::string& outPrefix, std::string& outBase,
std::string& outSuffix);
void GetLibraryNamesInternal(std::string& name,
std::string& soName,
std::string& realName,
@ -348,6 +353,19 @@ private:
// Get the full path to the target output directory.
const char* GetOutputDir(bool implib);
const char* ImportedGetLocation(const char* config);
const char* NormalGetLocation(const char* config);
void NormalGetFullNameInternal(TargetType type, const char* config, bool implib,
std::string& outPrefix, std::string& outBase,
std::string& outSuffix);
void ImportedGetFullNameInternal(TargetType type, const char* config, bool implib,
std::string& outPrefix, std::string& outBase,
std::string& outSuffix);
const char* ImportedGetDirectory(const char* config, bool implib);
const char* NormalGetDirectory(const char* config, bool implib);
private:
std::string Name;
std::vector<cmCustomCommand> PreBuildCommands;
@ -376,6 +394,7 @@ private:
cmPropertyMap Properties;
LinkLibraryVectorType OriginalLinkLibraries;
bool DLLPlatform;
bool IsImportedTarget;
// The cmMakefile instance that owns this target. This should
// always be set.