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

Merge topic 'GetTargetDirectory-cmGeneratorTarget'

Browse Source 
7f5ec9f1 cmLocalGenerator: Port GetTargetDirectory to cmGeneratorTarget.
06f56d3b cmLocalUnixMakefileGenerator3: Port AppendCleanCommand to cmGeneratorTarget.
c8f8f165 cmLocalUnixMakefileGenerator3: Port another API to cmGeneratorTarget.
9f299a12 cmLocalUnixMakefileGenerator3: Port API to cmGenertorTarget.
This commit is contained in:
Brad King 2015-10-16 09:35:32 -04:00 committed by CMake Topic Stage
commit a4f0b01939
23 changed files with 93 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmCommonTargetGenerator.cxx
View File

@ -403,7 +403,7 @@ cmCommonTargetGenerator::GetLinkedTargetDirectories() const
cmMakefile* mf = linkee->Target->GetMakefile(); cmMakefile* mf = linkee->Target->GetMakefile();
std::string di = mf->GetCurrentBinaryDirectory(); std::string di = mf->GetCurrentBinaryDirectory();
di += "/"; di += "/";
di += lg->GetTargetDirectory(*linkee->Target); di += lg->GetTargetDirectory(linkee);
dirs.push_back(di); dirs.push_back(di);
} }
} }

25
Source/cmExtraCodeBlocksGenerator.cxx
View File

@ -358,11 +358,13 @@ void cmExtraCodeBlocksGenerator
case cmTarget::MODULE_LIBRARY: case cmTarget::MODULE_LIBRARY:
case cmTarget::OBJECT_LIBRARY: case cmTarget::OBJECT_LIBRARY:
{ {
this->AppendTarget(fout, ti->first, &ti->second, cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
this->AppendTarget(fout, ti->first, gt,
make.c_str(), *lg, compiler.c_str()); make.c_str(), *lg, compiler.c_str());
std::string fastTarget = ti->first; std::string fastTarget = ti->first;
fastTarget += "/fast"; fastTarget += "/fast";
this->AppendTarget(fout, fastTarget, &ti->second, this->AppendTarget(fout, fastTarget, gt,
make.c_str(), *lg, compiler.c_str()); make.c_str(), *lg, compiler.c_str());
} }
break; break;
@ -521,14 +523,14 @@ void cmExtraCodeBlocksGenerator
// Write a dummy file for OBJECT libraries, so C::B can reference some file // Write a dummy file for OBJECT libraries, so C::B can reference some file
std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile( std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile(
cmLocalGenerator* lg, cmLocalGenerator* lg,
cmTarget* target) const cmGeneratorTarget* target) const
{ {
// this file doesn't seem to be used by C::B in custom makefile mode, // this file doesn't seem to be used by C::B in custom makefile mode,
// but we generate a unique file for each OBJECT library so in case // but we generate a unique file for each OBJECT library so in case
// C::B uses it in some way, the targets don't interfere with each other. // C::B uses it in some way, the targets don't interfere with each other.
std::string filename = lg->GetCurrentBinaryDirectory(); std::string filename = lg->GetCurrentBinaryDirectory();
filename += "/"; filename += "/";
filename += lg->GetTargetDirectory(*target); filename += lg->GetTargetDirectory(target);
filename += "/"; filename += "/";
filename += target->GetName(); filename += target->GetName();
filename += ".objlib"; filename += ".objlib";
@ -547,7 +549,7 @@ std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile(
// Generate the xml code for one target. // Generate the xml code for one target.
void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout, void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
const std::string& targetName, const std::string& targetName,
cmTarget* target, cmGeneratorTarget* target,
const char* make, const char* make,
const cmLocalGenerator* lg, const cmLocalGenerator* lg,
const char* compiler) const char* compiler)
@ -559,7 +561,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
fout<<" <Target title=\"" << targetName << "\">\n"; fout<<" <Target title=\"" << targetName << "\">\n";
if (target!=0) if (target!=0)
{ {
int cbTargetType = this->GetCBTargetType(target); int cbTargetType = this->GetCBTargetType(target->Target);
std::string workingDir = lg->GetCurrentBinaryDirectory(); std::string workingDir = lg->GetCurrentBinaryDirectory();
if ( target->GetType()==cmTarget::EXECUTABLE) if ( target->GetType()==cmTarget::EXECUTABLE)
{ {
@ -591,9 +593,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
} }
else else
{ {
cmGeneratorTarget* gt = location = target->GetLocation(buildType);
this->GlobalGenerator->GetGeneratorTarget(target);
location = gt->GetLocation(buildType);
} }
fout<<" <Option output=\"" << location fout<<" <Option output=\"" << location
@ -604,12 +604,9 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
" <Option compiler=\"" << compiler << "\" />\n" " <Option compiler=\"" << compiler << "\" />\n"
" <Compiler>\n"; " <Compiler>\n";
cmGeneratorTarget *gtgt = this->GlobalGenerator
->GetGeneratorTarget(target);
// the compilerdefines for this target // the compilerdefines for this target
std::vector<std::string> cdefs; std::vector<std::string> cdefs;
gtgt->GetCompileDefinitions(cdefs, buildType, "C"); target->GetCompileDefinitions(cdefs, buildType, "C");
// Expand the list. // Expand the list.
for(std::vector<std::string>::const_iterator di = cdefs.begin(); for(std::vector<std::string>::const_iterator di = cdefs.begin();
@ -623,7 +620,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
std::set<std::string> uniqIncludeDirs; std::set<std::string> uniqIncludeDirs;
std::vector<std::string> includes; std::vector<std::string> includes;
lg->GetIncludeDirectories(includes, gtgt, "C", buildType); lg->GetIncludeDirectories(includes, target, "C", buildType);
uniqIncludeDirs.insert(includes.begin(), includes.end()); uniqIncludeDirs.insert(includes.begin(), includes.end());

5
Source/cmExtraCodeBlocksGenerator.h
View File

@ -17,6 +17,7 @@
class cmLocalGenerator; class cmLocalGenerator;
class cmMakefile; class cmMakefile;
class cmGeneratorTarget;
class cmTarget; class cmTarget;
class cmGeneratedFileStream; class cmGeneratedFileStream;
@ -49,7 +50,7 @@ private:
void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs, void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
const std::string& filename); const std::string& filename);
std::string CreateDummyTargetFile(cmLocalGenerator* lg, std::string CreateDummyTargetFile(cmLocalGenerator* lg,
cmTarget* target) const; cmGeneratorTarget* target) const;
std::string GetCBCompilerId(const cmMakefile* mf); std::string GetCBCompilerId(const cmMakefile* mf);
int GetCBTargetType(cmTarget* target); int GetCBTargetType(cmTarget* target);
@ -57,7 +58,7 @@ private:
const std::string& target); const std::string& target);
void AppendTarget(cmGeneratedFileStream& fout, void AppendTarget(cmGeneratedFileStream& fout,
const std::string& targetName, const std::string& targetName,
cmTarget* target, cmGeneratorTarget* target,
const char* make, const char* make,
const cmLocalGenerator* lg, const cmLocalGenerator* lg,
const char* compiler); const char* compiler);

4
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -1100,7 +1100,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
cleanArgs += "\" \""; cleanArgs += "\" \"";
cleanArgs += cmSystemTools::GetCMakeCommand(); cleanArgs += cmSystemTools::GetCMakeCommand();
cleanArgs += "\" -P \""; cleanArgs += "\" -P \"";
cleanArgs += (*it)->GetTargetDirectory(ti->second); cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
cleanArgs += (*it)->GetTargetDirectory(gt);
cleanArgs += "/cmake_clean.cmake\""; cleanArgs += "/cmake_clean.cmake\"";
this->AppendTarget(fout, "Clean", cmSystemTools::GetCMakeCommand(), this->AppendTarget(fout, "Clean", cmSystemTools::GetCMakeCommand(),
cleanArgs, virtDir, "", ""); cleanArgs, virtDir, "", "");

4
Source/cmGlobalNinjaGenerator.cxx
View File

@ -717,13 +717,11 @@ std::string cmGlobalNinjaGenerator::GetEditCacheCommand() const
void cmGlobalNinjaGenerator void cmGlobalNinjaGenerator
::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
{ {
cmTarget* target = gt->Target;
// Compute full path to object file directory for this target. // Compute full path to object file directory for this target.
std::string dir; std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory(); dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += "/"; dir += "/";
dir += gt->LocalGenerator->GetTargetDirectory(*target); dir += gt->LocalGenerator->GetTargetDirectory(gt);
dir += "/"; dir += "/";
gt->ObjectDirectory = dir; gt->ObjectDirectory = dir;
} }

24
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -114,13 +114,11 @@ void
cmGlobalUnixMakefileGenerator3 cmGlobalUnixMakefileGenerator3
::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const ::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
{ {
cmTarget* target = gt->Target;
// Compute full path to object file directory for this target. // Compute full path to object file directory for this target.
std::string dir; std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory(); dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += "/"; dir += "/";
dir += gt->LocalGenerator->GetTargetDirectory(*target); dir += gt->LocalGenerator->GetTargetDirectory(gt);
dir += "/"; dir += "/";
gt->ObjectDirectory = dir; gt->ObjectDirectory = dir;
} }
@ -435,7 +433,8 @@ void cmGlobalUnixMakefileGenerator3
(l->second.GetType() == cmTarget::OBJECT_LIBRARY) || (l->second.GetType() == cmTarget::OBJECT_LIBRARY) ||
(l->second.GetType() == cmTarget::UTILITY)) (l->second.GetType() == cmTarget::UTILITY))
{ {
std::string tname = lg->GetRelativeTargetDirectory(l->second); cmGeneratorTarget* gt = this->GetGeneratorTarget(&l->second);
std::string tname = lg->GetRelativeTargetDirectory(gt);
tname += "/DependInfo.cmake"; tname += "/DependInfo.cmake";
cmSystemTools::ConvertToUnixSlashes(tname); cmSystemTools::ConvertToUnixSlashes(tname);
cmakefileStream << " \"" << tname << "\"\n"; cmakefileStream << " \"" << tname << "\"\n";
@ -484,7 +483,7 @@ cmGlobalUnixMakefileGenerator3
gtarget gtarget
->NeedRelinkBeforeInstall(lg->GetConfigName()))) ->NeedRelinkBeforeInstall(lg->GetConfigName())))
{ {
std::string tname = lg->GetRelativeTargetDirectory(*gtarget->Target); std::string tname = lg->GetRelativeTargetDirectory(gtarget);
tname += "/"; tname += "/";
tname += pass; tname += pass;
depends.push_back(tname); depends.push_back(tname);
@ -673,7 +672,7 @@ cmGlobalUnixMakefileGenerator3
// Add a fast rule to build the target // Add a fast rule to build the target
std::string localName = std::string localName =
lg->GetRelativeTargetDirectory(*gtarget->Target); lg->GetRelativeTargetDirectory(gtarget);
std::string makefileName; std::string makefileName;
makefileName = localName; makefileName = localName;
makefileName += "/build.make"; makefileName += "/build.make";
@ -693,7 +692,7 @@ cmGlobalUnixMakefileGenerator3
if(gtarget if(gtarget
->NeedRelinkBeforeInstall(lg->GetConfigName())) ->NeedRelinkBeforeInstall(lg->GetConfigName()))
{ {
makeTargetName = lg->GetRelativeTargetDirectory(*gtarget->Target); makeTargetName = lg->GetRelativeTargetDirectory(gtarget);
makeTargetName += "/preinstall"; makeTargetName += "/preinstall";
localName = name; localName = name;
localName += "/preinstall"; localName += "/preinstall";
@ -750,7 +749,7 @@ cmGlobalUnixMakefileGenerator3
{ {
std::string makefileName; std::string makefileName;
// Add a rule to build the target by name. // Add a rule to build the target by name.
localName = lg->GetRelativeTargetDirectory(*gtarget->Target); localName = lg->GetRelativeTargetDirectory(gtarget);
makefileName = localName; makefileName = localName;
makefileName += "/build.make"; makefileName += "/build.make";
@ -861,7 +860,7 @@ cmGlobalUnixMakefileGenerator3
} }
depends.clear(); depends.clear();
depends.push_back("cmake_check_build_system"); depends.push_back("cmake_check_build_system");
localName = lg->GetRelativeTargetDirectory(*gtarget->Target); localName = lg->GetRelativeTargetDirectory(gtarget);
localName += "/rule"; localName += "/rule";
lg->WriteMakeRule(ruleFileStream, lg->WriteMakeRule(ruleFileStream,
"Build rule for subdir invocation for target.", "Build rule for subdir invocation for target.",
@ -878,7 +877,7 @@ cmGlobalUnixMakefileGenerator3
if(gtarget if(gtarget
->NeedRelinkBeforeInstall(lg->GetConfigName())) ->NeedRelinkBeforeInstall(lg->GetConfigName()))
{ {
localName = lg->GetRelativeTargetDirectory(*gtarget->Target); localName = lg->GetRelativeTargetDirectory(gtarget);
localName += "/preinstall"; localName += "/preinstall";
depends.clear(); depends.clear();
commands.clear(); commands.clear();
@ -899,7 +898,7 @@ cmGlobalUnixMakefileGenerator3
} }
// add the clean rule // add the clean rule
localName = lg->GetRelativeTargetDirectory(*gtarget->Target); localName = lg->GetRelativeTargetDirectory(gtarget);
makeTargetName = localName; makeTargetName = localName;
makeTargetName += "/clean"; makeTargetName += "/clean";
depends.clear(); depends.clear();
@ -1066,7 +1065,8 @@ cmGlobalUnixMakefileGenerator3
} }
cmLocalUnixMakefileGenerator3* lg3 = cmLocalUnixMakefileGenerator3* lg3 =
static_cast<cmLocalUnixMakefileGenerator3*>(dep->GetLocalGenerator()); static_cast<cmLocalUnixMakefileGenerator3*>(dep->GetLocalGenerator());
std::string tgtName = lg3->GetRelativeTargetDirectory(*(*dep).Target); std::string tgtName =
lg3->GetRelativeTargetDirectory(const_cast<cmGeneratorTarget*>(dep));
tgtName += "/all"; tgtName += "/all";
depends.push_back(tgtName); depends.push_back(tgtName);
} }

2
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -147,7 +147,7 @@ void cmGlobalVisualStudioGenerator
{ {
std::string dir = gt->Makefile->GetCurrentBinaryDirectory(); std::string dir = gt->Makefile->GetCurrentBinaryDirectory();
dir += "/"; dir += "/";
std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(*gt->Target); std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(gt);
if(!tgtDir.empty()) if(!tgtDir.empty())
{ {
dir += tgtDir; dir += tgtDir;

2
Source/cmLocalGenerator.cxx
View File

@ -2908,7 +2908,7 @@ const char* cmLocalGenerator::GetCurrentSourceDirectory() const
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
std::string std::string
cmLocalGenerator::GetTargetDirectory(cmTarget const&) const cmLocalGenerator::GetTargetDirectory(const cmGeneratorTarget*) const
{ {
cmSystemTools::Error("GetTargetDirectory" cmSystemTools::Error("GetTargetDirectory"
" called on cmLocalGenerator"); " called on cmLocalGenerator");

3
Source/cmLocalGenerator.h
View File

@ -247,7 +247,8 @@ public:
* Get the relative path from the generator output directory to a * Get the relative path from the generator output directory to a
* per-target support directory. * per-target support directory.
*/ */
virtual std::string GetTargetDirectory(cmTarget const& target) const; virtual std::string
GetTargetDirectory(cmGeneratorTarget const* target) const;
/** /**
* Get the level of backwards compatibility requested by the project * Get the level of backwards compatibility requested by the project

4
Source/cmLocalNinjaGenerator.cxx
View File

@ -100,10 +100,10 @@ void cmLocalNinjaGenerator::Generate()
// TODO: Picked up from cmLocalUnixMakefileGenerator3. Refactor it. // TODO: Picked up from cmLocalUnixMakefileGenerator3. Refactor it.
std::string cmLocalNinjaGenerator std::string cmLocalNinjaGenerator
::GetTargetDirectory(cmTarget const& target) const ::GetTargetDirectory(cmGeneratorTarget const* target) const
{ {
std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
dir += target.GetName(); dir += target->GetName();
#if defined(__VMS) #if defined(__VMS)
dir += "_dir"; dir += "_dir";
#else #else

3
Source/cmLocalNinjaGenerator.h
View File

@ -37,7 +37,8 @@ public:
virtual void Generate(); virtual void Generate();
virtual std::string GetTargetDirectory(cmTarget const& target) const; virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const; const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const;
cmGlobalNinjaGenerator* GetGlobalNinjaGenerator(); cmGlobalNinjaGenerator* GetGlobalNinjaGenerator();

26
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -191,7 +191,7 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
std::string dir; std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory(); dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += "/"; dir += "/";
dir += this->GetTargetDirectory(*gt->Target); dir += this->GetTargetDirectory(gt);
dir += "/"; dir += "/";
// Compute the name of each object file. // Compute the name of each object file.
for(std::vector<cmSourceFile const*>::iterator for(std::vector<cmSourceFile const*>::iterator
@ -209,7 +209,7 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
} }
LocalObjectInfo& info = localObjectFiles[objectName]; LocalObjectInfo& info = localObjectFiles[objectName];
info.HasSourceExtension = hasSourceExtension; info.HasSourceExtension = hasSourceExtension;
info.push_back(LocalObjectEntry(gt->Target, sf->GetLanguage())); info.push_back(LocalObjectEntry(gt, sf->GetLanguage()));
} }
} }
} }
@ -389,7 +389,7 @@ cmLocalUnixMakefileGenerator3
t != info.end(); ++t) t != info.end(); ++t)
{ {
std::string tgtMakefileName = std::string tgtMakefileName =
this->GetRelativeTargetDirectory(*(t->Target)); this->GetRelativeTargetDirectory(t->Target);
std::string targetName = tgtMakefileName; std::string targetName = tgtMakefileName;
tgtMakefileName += "/build.make"; tgtMakefileName += "/build.make";
targetName += "/"; targetName += "/";
@ -438,7 +438,7 @@ void cmLocalUnixMakefileGenerator3
emitted.insert(t->second->GetName()); emitted.insert(t->second->GetName());
// for subdirs add a rule to build this specific target by name. // for subdirs add a rule to build this specific target by name.
localName = this->GetRelativeTargetDirectory(*t->second->Target); localName = this->GetRelativeTargetDirectory(t->second);
localName += "/rule"; localName += "/rule";
commands.clear(); commands.clear();
depends.clear(); depends.clear();
@ -465,11 +465,11 @@ void cmLocalUnixMakefileGenerator3
// Add a fast rule to build the target // Add a fast rule to build the target
std::string makefileName = std::string makefileName =
this->GetRelativeTargetDirectory(*t->second->Target); this->GetRelativeTargetDirectory(t->second);
makefileName += "/build.make"; makefileName += "/build.make";
// make sure the makefile name is suitable for a makefile // make sure the makefile name is suitable for a makefile
std::string makeTargetName = std::string makeTargetName =
this->GetRelativeTargetDirectory(*t->second->Target); this->GetRelativeTargetDirectory(t->second);
makeTargetName += "/build"; makeTargetName += "/build";
localName = t->second->GetName(); localName = t->second->GetName();
localName += "/fast"; localName += "/fast";
@ -487,7 +487,7 @@ void cmLocalUnixMakefileGenerator3
// installation. // installation.
if(t->second->NeedRelinkBeforeInstall(this->ConfigName)) if(t->second->NeedRelinkBeforeInstall(this->ConfigName))
{ {
makeTargetName = this->GetRelativeTargetDirectory(*t->second->Target); makeTargetName = this->GetRelativeTargetDirectory(t->second);
makeTargetName += "/preinstall"; makeTargetName += "/preinstall";
localName = t->second->GetName(); localName = t->second->GetName();
localName += "/preinstall"; localName += "/preinstall";
@ -933,7 +933,7 @@ cmLocalUnixMakefileGenerator3
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
std::string std::string
cmLocalUnixMakefileGenerator3 cmLocalUnixMakefileGenerator3
::GetRelativeTargetDirectory(cmTarget const& target) ::GetRelativeTargetDirectory(cmGeneratorTarget* target)
{ {
std::string dir = this->HomeRelativeOutputPath; std::string dir = this->HomeRelativeOutputPath;
dir += this->GetTargetDirectory(target); dir += this->GetTargetDirectory(target);
@ -1218,7 +1218,7 @@ void
cmLocalUnixMakefileGenerator3 cmLocalUnixMakefileGenerator3
::AppendCleanCommand(std::vector<std::string>& commands, ::AppendCleanCommand(std::vector<std::string>& commands,
const std::vector<std::string>& files, const std::vector<std::string>& files,
cmTarget& target, const char* filename) cmGeneratorTarget* target, const char* filename)
{ {
std::string cleanfile = this->Makefile->GetCurrentBinaryDirectory(); std::string cleanfile = this->Makefile->GetCurrentBinaryDirectory();
cleanfile += "/"; cleanfile += "/";
@ -1256,9 +1256,7 @@ cmLocalUnixMakefileGenerator3
{ {
// Get the set of source languages in the target. // Get the set of source languages in the target.
std::set<std::string> languages; std::set<std::string> languages;
cmGeneratorTarget *gtgt = target->GetLanguages(languages,
this->GlobalGenerator->GetGeneratorTarget(&target);
gtgt->GetLanguages(languages,
this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
fout << "\n" fout << "\n"
<< "# Per-language clean rules from dependency scanning.\n" << "# Per-language clean rules from dependency scanning.\n"
@ -2284,10 +2282,10 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p,
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
std::string std::string
cmLocalUnixMakefileGenerator3 cmLocalUnixMakefileGenerator3
::GetTargetDirectory(cmTarget const& target) const ::GetTargetDirectory(cmGeneratorTarget const* target) const
{ {
std::string dir = cmake::GetCMakeFilesDirectoryPostSlash(); std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
dir += target.GetName(); dir += target->GetName();
#if defined(__VMS) #if defined(__VMS)
dir += "_dir"; dir += "_dir";
#else #else

11
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -106,7 +106,8 @@ public:
/** Get whether the makefile is to have color. */ /** Get whether the makefile is to have color. */
bool GetColorMakefile() const { return this->ColorMakefile; } bool GetColorMakefile() const { return this->ColorMakefile; }
virtual std::string GetTargetDirectory(cmTarget const& target) const; virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
// create a command that cds to the start dir then runs the commands // create a command that cds to the start dir then runs the commands
void CreateCDCommand(std::vector<std::string>& commands, void CreateCDCommand(std::vector<std::string>& commands,
@ -131,7 +132,7 @@ public:
void WriteSpecialTargetsTop(std::ostream& makefileStream); void WriteSpecialTargetsTop(std::ostream& makefileStream);
void WriteSpecialTargetsBottom(std::ostream& makefileStream); void WriteSpecialTargetsBottom(std::ostream& makefileStream);
std::string GetRelativeTargetDirectory(cmTarget const& target); std::string GetRelativeTargetDirectory(cmGeneratorTarget* target);
// File pairs for implicit dependency scanning. The key of the map // File pairs for implicit dependency scanning. The key of the map
// is the depender and the value is the explicit dependee. // is the depender and the value is the explicit dependee.
@ -226,7 +227,7 @@ protected:
std::ostream* content = 0); std::ostream* content = 0);
void AppendCleanCommand(std::vector<std::string>& commands, void AppendCleanCommand(std::vector<std::string>& commands,
const std::vector<std::string>& files, const std::vector<std::string>& files,
cmTarget& target, const char* filename =0); cmGeneratorTarget* target, const char* filename =0);
// Helper methods for dependeny updates. // Helper methods for dependeny updates.
bool ScanDependencies(const char* targetDir, bool ScanDependencies(const char* targetDir,
@ -254,10 +255,10 @@ private:
struct LocalObjectEntry struct LocalObjectEntry
{ {
cmTarget* Target; cmGeneratorTarget* Target;
std::string Language; std::string Language;
LocalObjectEntry(): Target(0), Language() {} LocalObjectEntry(): Target(0), Language() {}
LocalObjectEntry(cmTarget* t, const std::string& lang): LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang):
Target(t), Language(lang) {} Target(t), Language(lang) {}
}; };
struct LocalObjectInfo: public std::vector<LocalObjectEntry> struct LocalObjectInfo: public std::vector<LocalObjectEntry>

2
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -1939,7 +1939,7 @@ void cmLocalVisualStudio6Generator
std::string std::string
cmLocalVisualStudio6Generator cmLocalVisualStudio6Generator
::GetTargetDirectory(cmTarget const&) const ::GetTargetDirectory(cmGeneratorTarget const*) const
{ {
// No per-target directory for this generator (yet). // No per-target directory for this generator (yet).
return ""; return "";

3
Source/cmLocalVisualStudio6Generator.h
View File

@ -49,7 +49,8 @@ public:
*/ */
void SetBuildType(BuildType, const std::string& libName, cmTarget&); void SetBuildType(BuildType, const std::string& libName, cmTarget&);
virtual std::string GetTargetDirectory(cmTarget const& target) const; virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
virtual std::string ComputeLongestObjectDirectory(cmTarget&) const; virtual std::string ComputeLongestObjectDirectory(cmTarget&) const;
private: private:
std::string DSPHeaderTemplate; std::string DSPHeaderTemplate;

12
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -784,7 +784,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
// The intermediate directory name consists of a directory for the // The intermediate directory name consists of a directory for the
// target and a subdirectory for the configuration name. // target and a subdirectory for the configuration name.
std::string intermediateDir = this->GetTargetDirectory(target); std::string intermediateDir = this->GetTargetDirectory(gt);
intermediateDir += "/"; intermediateDir += "/";
intermediateDir += configName; intermediateDir += configName;
@ -1113,7 +1113,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
break; break;
case cmTarget::OBJECT_LIBRARY: case cmTarget::OBJECT_LIBRARY:
{ {
std::string libpath = this->GetTargetDirectory(target); std::string libpath = this->GetTargetDirectory(gt);
libpath += "/"; libpath += "/";
libpath += configName; libpath += configName;
libpath += "/"; libpath += "/";
@ -1725,7 +1725,9 @@ cmLocalVisualStudio7Generator
std::string dir_max; std::string dir_max;
dir_max += this->GetCurrentBinaryDirectory(); dir_max += this->GetCurrentBinaryDirectory();
dir_max += "/"; dir_max += "/";
dir_max += this->GetTargetDirectory(target); cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
dir_max += this->GetTargetDirectory(gt);
dir_max += "/"; dir_max += "/";
dir_max += config_max; dir_max += config_max;
dir_max += "/"; dir_max += "/";
@ -2369,10 +2371,10 @@ void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID(
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
std::string cmLocalVisualStudio7Generator std::string cmLocalVisualStudio7Generator
::GetTargetDirectory(cmTarget const& target) const ::GetTargetDirectory(cmGeneratorTarget const* target) const
{ {
std::string dir; std::string dir;
dir += target.GetName(); dir += target->GetName();
dir += ".dir"; dir += ".dir";
return dir; return dir;
} }

3
Source/cmLocalVisualStudio7Generator.h
View File

@ -53,7 +53,8 @@ public:
*/ */
void SetBuildType(BuildType,const std::string& name); void SetBuildType(BuildType,const std::string& name);
virtual std::string GetTargetDirectory(cmTarget const&) const; virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
cmSourceFile* CreateVCProjBuildRule(); cmSourceFile* CreateVCProjBuildRule();
void WriteStampFiles(); void WriteStampFiles();
virtual std::string ComputeLongestObjectDirectory(cmTarget&) const; virtual std::string ComputeLongestObjectDirectory(cmTarget&) const;

2
Source/cmLocalXCodeGenerator.cxx
View File

@ -31,7 +31,7 @@ cmLocalXCodeGenerator::~cmLocalXCodeGenerator()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
std::string std::string
cmLocalXCodeGenerator::GetTargetDirectory(cmTarget const&) const cmLocalXCodeGenerator::GetTargetDirectory(cmGeneratorTarget const*) const
{ {
// No per-target directory for this generator (yet). // No per-target directory for this generator (yet).
return ""; return "";

3
Source/cmLocalXCodeGenerator.h
View File

@ -28,7 +28,8 @@ public:
cmMakefile* mf); cmMakefile* mf);
virtual ~cmLocalXCodeGenerator(); virtual ~cmLocalXCodeGenerator();
virtual std::string GetTargetDirectory(cmTarget const& target) const; virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
virtual void AppendFlagEscape(std::string& flags, virtual void AppendFlagEscape(std::string& flags,
const std::string& rawFlag); const std::string& rawFlag);
virtual void Generate(); virtual void Generate();

2
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -444,7 +444,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
if(this->Target->GetType() == cmTarget::STATIC_LIBRARY) if(this->Target->GetType() == cmTarget::STATIC_LIBRARY)
{ {
this->LocalGenerator->AppendCleanCommand(commands1, libCleanFiles, this->LocalGenerator->AppendCleanCommand(commands1, libCleanFiles,
*this->Target, "target"); this->GeneratorTarget, "target");
this->LocalGenerator->CreateCDCommand this->LocalGenerator->CreateCDCommand
(commands1, (commands1,
this->Makefile->GetCurrentBinaryDirectory(), this->Makefile->GetCurrentBinaryDirectory(),

20
Source/cmMakefileTargetGenerator.cxx
View File

@ -92,7 +92,7 @@ void cmMakefileTargetGenerator::CreateRuleFile()
{ {
// Create a directory for this target. // Create a directory for this target.
this->TargetBuildDirectory = this->TargetBuildDirectory =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->TargetBuildDirectoryFull = this->TargetBuildDirectoryFull =
this->LocalGenerator->ConvertToFullPath(this->TargetBuildDirectory); this->LocalGenerator->ConvertToFullPath(this->TargetBuildDirectory);
cmSystemTools::MakeDirectory(this->TargetBuildDirectoryFull.c_str()); cmSystemTools::MakeDirectory(this->TargetBuildDirectoryFull.c_str());
@ -378,7 +378,8 @@ void cmMakefileTargetGenerator
// Get the full path name of the object file. // Get the full path name of the object file.
std::string const& objectName = this->GeneratorTarget std::string const& objectName = this->GeneratorTarget
->GetObjectName(&source); ->GetObjectName(&source);
std::string obj = this->LocalGenerator->GetTargetDirectory(*this->Target); std::string obj =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
obj += "/"; obj += "/";
obj += objectName; obj += objectName;
@ -870,7 +871,7 @@ cmMakefileTargetGenerator
temp += ".provides.build"; temp += ".provides.build";
std::vector<std::string> r_commands; std::vector<std::string> r_commands;
std::string tgtMakefileName = std::string tgtMakefileName =
this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
tgtMakefileName += "/build.make"; tgtMakefileName += "/build.make";
r_commands.push_back r_commands.push_back
(this->LocalGenerator->GetRecursiveMakeCall(tgtMakefileName.c_str(), (this->LocalGenerator->GetRecursiveMakeCall(tgtMakefileName.c_str(),
@ -898,7 +899,7 @@ void cmMakefileTargetGenerator::WriteTargetRequiresRules()
// Construct the name of the dependency generation target. // Construct the name of the dependency generation target.
std::string depTarget = std::string depTarget =
this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
depTarget += "/requires"; depTarget += "/requires";
// This target drives dependency generation for all object files. // This target drives dependency generation for all object files.
@ -927,12 +928,12 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules()
// Construct the clean target name. // Construct the clean target name.
std::string cleanTarget = std::string cleanTarget =
this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
cleanTarget += "/clean"; cleanTarget += "/clean";
// Construct the clean command. // Construct the clean command.
this->LocalGenerator->AppendCleanCommand(commands, this->CleanFiles, this->LocalGenerator->AppendCleanCommand(commands, this->CleanFiles,
*this->Target); this->GeneratorTarget);
this->LocalGenerator->CreateCDCommand this->LocalGenerator->CreateCDCommand
(commands, (commands,
this->LocalGenerator->GetCurrentBinaryDirectory(), this->LocalGenerator->GetCurrentBinaryDirectory(),
@ -1024,7 +1025,8 @@ bool cmMakefileTargetGenerator::WriteMakeRule(
void cmMakefileTargetGenerator::WriteTargetDependRules() void cmMakefileTargetGenerator::WriteTargetDependRules()
{ {
// must write the targets depend info file // must write the targets depend info file
std::string dir = this->LocalGenerator->GetTargetDirectory(*this->Target); std::string dir =
this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->InfoFileNameFull = dir; this->InfoFileNameFull = dir;
this->InfoFileNameFull += "/DependInfo.cmake"; this->InfoFileNameFull += "/DependInfo.cmake";
this->InfoFileNameFull = this->InfoFileNameFull =
@ -1086,7 +1088,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
// Construct the name of the dependency generation target. // Construct the name of the dependency generation target.
std::string depTarget = std::string depTarget =
this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
depTarget += "/depend"; depTarget += "/depend";
// Add a command to call CMake to scan dependencies. CMake will // Add a command to call CMake to scan dependencies. CMake will
@ -1400,7 +1402,7 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule(
{ {
// Compute the name of the driver target. // Compute the name of the driver target.
std::string dir = std::string dir =
this->LocalGenerator->GetRelativeTargetDirectory(*this->Target); this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
std::string buildTargetRuleName = dir; std::string buildTargetRuleName = dir;
buildTargetRuleName += relink?"/preinstall":"/build"; buildTargetRuleName += relink?"/preinstall":"/build";
buildTargetRuleName = this->Convert(buildTargetRuleName, buildTargetRuleName = this->Convert(buildTargetRuleName,

2
Source/cmNinjaTargetGenerator.cxx
View File

@ -245,7 +245,7 @@ cmNinjaTargetGenerator
path += "/"; path += "/";
std::string const& objectName = this->GeneratorTarget std::string const& objectName = this->GeneratorTarget
->GetObjectName(source); ->GetObjectName(source);
path += this->LocalGenerator->GetTargetDirectory(*this->Target); path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
path += "/"; path += "/";
path += objectName; path += objectName;
return path; return path;

16
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -196,7 +196,7 @@ cmVisualStudio10TargetGenerator(cmTarget* target,
this->IsMissingFiles = false; this->IsMissingFiles = false;
this->DefaultArtifactDir = this->DefaultArtifactDir =
this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/") + this->LocalGenerator->GetCurrentBinaryDirectory() + std::string("/") +
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
} }
cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator() cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator()
@ -1765,7 +1765,7 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
else else
{ {
std::string intermediateDir = this->LocalGenerator-> std::string intermediateDir = this->LocalGenerator->
GetTargetDirectory(*this->Target); GetTargetDirectory(this->GeneratorTarget);
intermediateDir += "/"; intermediateDir += "/";
intermediateDir += *config; intermediateDir += *config;
intermediateDir += "/"; intermediateDir += "/";
@ -3021,7 +3021,7 @@ void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile()
{ {
// Move the manifest to a project directory to avoid clashes // Move the manifest to a project directory to avoid clashes
std::string artifactDir = std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir); this->ConvertToWindowsSlash(artifactDir);
this->WriteString("<PropertyGroup>\n", 1); this->WriteString("<PropertyGroup>\n", 1);
this->WriteString("<AppxPackageArtifactsDir>", 2); this->WriteString("<AppxPackageArtifactsDir>", 2);
@ -3320,7 +3320,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
this->LocalGenerator->GetCurrentBinaryDirectory() + this->LocalGenerator->GetCurrentBinaryDirectory() +
std::string("/WMAppManifest.xml"); std::string("/WMAppManifest.xml");
std::string artifactDir = std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir); this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
@ -3403,7 +3403,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81()
std::string manifestFile = std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest"; this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir = std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir); this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
@ -3463,7 +3463,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80()
std::string manifestFile = std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest"; this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir = std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir); this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
@ -3515,7 +3515,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81()
std::string manifestFile = std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest"; this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir = std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir); this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());
@ -3572,7 +3572,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
std::string manifestFile = std::string manifestFile =
this->DefaultArtifactDir + "/package.appxManifest"; this->DefaultArtifactDir + "/package.appxManifest";
std::string artifactDir = std::string artifactDir =
this->LocalGenerator->GetTargetDirectory(*this->Target); this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
this->ConvertToWindowsSlash(artifactDir); this->ConvertToWindowsSlash(artifactDir);
std::string artifactDirXML = cmVS10EscapeXML(artifactDir); std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName()); std::string targetNameXML = cmVS10EscapeXML(this->Target->GetName());