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

Merge topic 'GetTargetDirectory-cmGeneratorTarget' 

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
parent 2f1c3401ec 7f5ec9f109
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();
std::string di = mf->GetCurrentBinaryDirectory();
di += "/";
di += lg->GetTargetDirectory(*linkee->Target);
di += lg->GetTargetDirectory(linkee);
dirs.push_back(di);
}
}

25
Source/cmExtraCodeBlocksGenerator.cxx
View File

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

5
Source/cmExtraCodeBlocksGenerator.h
View File

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

4
Source/cmExtraEclipseCDT4Generator.cxx
View File

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

4
Source/cmGlobalNinjaGenerator.cxx
View File

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

24
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

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

2
Source/cmGlobalVisualStudioGenerator.cxx
View File

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

2
Source/cmLocalGenerator.cxx
View File

@ -2908,7 +2908,7 @@ const char* cmLocalGenerator::GetCurrentSourceDirectory() const
//----------------------------------------------------------------------------
std::string
cmLocalGenerator::GetTargetDirectory(cmTarget const&) const
cmLocalGenerator::GetTargetDirectory(const cmGeneratorTarget*) const
{
cmSystemTools::Error("GetTargetDirectory"
" 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
* 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

4
Source/cmLocalNinjaGenerator.cxx
View File

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

3
Source/cmLocalNinjaGenerator.h
View File

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

26
Source/cmLocalUnixMakefileGenerator3.cxx
View File

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

11
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -106,7 +106,8 @@ public:
/** Get whether the makefile is to have color. */
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
void CreateCDCommand(std::vector<std::string>& commands,
@ -131,7 +132,7 @@ public:
void WriteSpecialTargetsTop(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
// is the depender and the value is the explicit dependee.
@ -226,7 +227,7 @@ protected:
std::ostream* content = 0);
void AppendCleanCommand(std::vector<std::string>& commands,
const std::vector<std::string>& files,
cmTarget& target, const char* filename =0);
cmGeneratorTarget* target, const char* filename =0);
// Helper methods for dependeny updates.
bool ScanDependencies(const char* targetDir,
@ -254,10 +255,10 @@ private:
struct LocalObjectEntry
{
cmTarget* Target;
cmGeneratorTarget* Target;
std::string Language;
LocalObjectEntry(): Target(0), Language() {}
LocalObjectEntry(cmTarget* t, const std::string& lang):
LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang):
Target(t), Language(lang) {}
};
struct LocalObjectInfo: public std::vector<LocalObjectEntry>

2
Source/cmLocalVisualStudio6Generator.cxx
View File

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

3
Source/cmLocalVisualStudio6Generator.h
View File

@ -49,7 +49,8 @@ public:
*/
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;
private:
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
// target and a subdirectory for the configuration name.
std::string intermediateDir = this->GetTargetDirectory(target);
std::string intermediateDir = this->GetTargetDirectory(gt);
intermediateDir += "/";
intermediateDir += configName;
@ -1113,7 +1113,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
break;
case cmTarget::OBJECT_LIBRARY:
{
std::string libpath = this->GetTargetDirectory(target);
std::string libpath = this->GetTargetDirectory(gt);
libpath += "/";
libpath += configName;
libpath += "/";
@ -1725,7 +1725,9 @@ cmLocalVisualStudio7Generator
std::string dir_max;
dir_max += this->GetCurrentBinaryDirectory();
dir_max += "/";
dir_max += this->GetTargetDirectory(target);
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
dir_max += this->GetTargetDirectory(gt);
dir_max += "/";
dir_max += config_max;
dir_max += "/";
@ -2369,10 +2371,10 @@ void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID(
//----------------------------------------------------------------------------
std::string cmLocalVisualStudio7Generator
::GetTargetDirectory(cmTarget const& target) const
::GetTargetDirectory(cmGeneratorTarget const* target) const
{
std::string dir;
dir += target.GetName();
dir += target->GetName();
dir += ".dir";
return dir;
}

3
Source/cmLocalVisualStudio7Generator.h
View File

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

2
Source/cmLocalXCodeGenerator.cxx
View File

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

3
Source/cmLocalXCodeGenerator.h
View File

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

2
Source/cmMakefileLibraryTargetGenerator.cxx
View File

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

20
Source/cmMakefileTargetGenerator.cxx
View File

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

2
Source/cmNinjaTargetGenerator.cxx
View File

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

16
Source/cmVisualStudio10TargetGenerator.cxx
View File

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