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

Merge topic 'use-generator-target'

Browse Source 
6cac952b VS: Port interface to cmGeneratorTarget
97b37688 VS: Port WriteUtilityDepends to cmGeneratorTarget
600af01d VS: Port utility depends to cmGeneratorTarget
330bfa83 VS: Port target depends to cmGeneratorTarget
b13e26e2 VS: Port ProjectDepends to cmGeneratorTarget.
8ac8739b VS: Port TargetIsFortranOnly to cmGeneratorTarget
84fb579f VS: Port WriteProject to cmGeneratorTarget
1eff421a VS: Port loop to cmGeneratorTarget
94fd5a5a VS: Port ImplibDir to cmGeneratorTarget
ce9e9a92 VS: Port LinkClosure to cmGeneratorTarget
26e23e84 VS: Port ComputeLongestObjectDirectory to cmGeneratorTarget
01c26986 VS7: Port to cmGeneratorTarget
459c8910 VS10: Port to cmGeneratorTarget.
7f8bb857 VS6: Port to cmGeneratorTarget.
a0ebd69b Graphviz: Port to cmGeneratorTarget.
bcee21ce C::B: Port API to cmGeneratorTarget.
...
This commit is contained in:
Brad King 2015-10-26 13:13:04 -04:00 committed by CMake Topic Stage
commit d288b216af
69 changed files with 1197 additions and 1193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/cmCommonTargetGenerator.cxx
View File

@ -18,7 +18,6 @@
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
cmCommonTargetGenerator::cmCommonTargetGenerator(
cmOutputConverter::RelativeRoot wd,
@ -26,7 +25,6 @@ cmCommonTargetGenerator::cmCommonTargetGenerator(
)
: WorkingDirectory(wd)
, GeneratorTarget(gt)
, Target(gt->Target)
, Makefile(gt->Makefile)
, LocalGenerator(static_cast<cmLocalCommonGenerator*>(gt->LocalGenerator))
, GlobalGenerator(static_cast<cmGlobalCommonGenerator*>(
@ -123,7 +121,7 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const
else
{
// Interpret relative to the current output directory.
mod_dir = this->Makefile->GetCurrentBinaryDirectory();
mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory();
mod_dir += "/";
mod_dir += target_mod_dir;
}

2
Source/cmCommonTargetGenerator.h
View File

@ -21,7 +21,6 @@ class cmGlobalCommonGenerator;
class cmLocalCommonGenerator;
class cmMakefile;
class cmSourceFile;
class cmTarget;
/** \class cmCommonTargetGenerator
* \brief Common infrastructure for Makefile and Ninja per-target generators
@ -49,7 +48,6 @@ protected:
cmOutputConverter::RelativeRoot WorkingDirectory;
cmGeneratorTarget* GeneratorTarget;
cmTarget* Target;
cmMakefile* Makefile;
cmLocalCommonGenerator* LocalGenerator;
cmGlobalCommonGenerator* GlobalGenerator;

9
Source/cmComputeTargetDepends.cxx
View File

@ -175,13 +175,12 @@ void cmComputeTargetDepends::CollectTargets()
this->GlobalGenerator->GetLocalGenerators();
for(unsigned int i = 0; i < lgens.size(); ++i)
{
const cmTargets& targets = lgens[i]->GetMakefile()->GetTargets();
for(cmTargets::const_iterator ti = targets.begin();
const std::vector<cmGeneratorTarget*> targets =
lgens[i]->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
cmTarget const* target = &ti->second;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(target);
cmGeneratorTarget* gt = *ti;
int index = static_cast<int>(this->Targets.size());
this->TargetIndex[gt] = index;
this->Targets.push_back(gt);

12
Source/cmExportFileGenerator.cxx
View File

@ -456,13 +456,13 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
if (cge->GetHadContextSensitiveCondition())
{
cmMakefile* mf = target->Target->GetMakefile();
cmLocalGenerator* lg = target->GetLocalGenerator();
std::ostringstream e;
e << "Target \"" << target->GetName() << "\" is installed with "
"INCLUDES DESTINATION set to a context sensitive path. Paths which "
"depend on the configuration, policy values or the link interface are "
"not supported. Consider using target_include_directories instead.";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
lg->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}
@ -535,11 +535,11 @@ void getCompatibleInterfaceProperties(cmGeneratorTarget *target,
if (!info)
{
cmMakefile* mf = target->Target->GetMakefile();
cmLocalGenerator* lg = target->GetLocalGenerator();
std::ostringstream e;
e << "Exporting the target \"" << target->GetName() << "\" is not "
"allowed since its linker language cannot be determined";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
lg->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}
@ -835,13 +835,13 @@ cmExportFileGenerator
if(newCMP0022Behavior && !this->ExportOld)
{
cmMakefile *mf = target->Target->GetMakefile();
cmLocalGenerator *lg = target->GetLocalGenerator();
std::ostringstream e;
e << "Target \"" << target->GetName() << "\" has policy CMP0022 enabled, "
"but also has old-style LINK_INTERFACE_LIBRARIES properties "
"populated, but it was exported without the "
"EXPORT_LINK_INTERFACE_LIBRARIES to export the old-style properties";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
lg->IssueMessage(cmake::FATAL_ERROR, e.str());
return;
}

49
Source/cmExtraCodeBlocksGenerator.cxx
View File

@ -17,7 +17,6 @@
#include "cmake.h"
#include "cmSourceFile.h"
#include "cmGeneratedFileStream.h"
#include "cmTarget.h"
#include "cmSystemTools.h"
#include "cmXMLSafe.h"
@ -319,12 +318,12 @@ void cmExtraCodeBlocksGenerator
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
lg!=lgs.end(); lg++)
{
cmMakefile* makefile=(*lg)->GetMakefile();
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
switch(ti->second.GetType())
std::string targetName = (*ti)->GetName();
switch((*ti)->GetType())
{
case cmState::GLOBAL_TARGET:
{
@ -333,7 +332,7 @@ void cmExtraCodeBlocksGenerator
if (strcmp((*lg)->GetCurrentBinaryDirectory(),
(*lg)->GetBinaryDirectory())==0)
{
this->AppendTarget(fout, ti->first, 0,
this->AppendTarget(fout, targetName, 0,
make.c_str(), *lg, compiler.c_str());
}
}
@ -341,15 +340,16 @@ void cmExtraCodeBlocksGenerator
case cmState::UTILITY:
// Add all utility targets, except the Nightly/Continuous/
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
if (((targetName.find("Nightly")==0) &&(targetName!="Nightly"))
|| ((targetName.find("Continuous")==0)
&&(targetName!="Continuous"))
|| ((targetName.find("Experimental")==0)
&& (targetName!="Experimental")))
{
break;
}
this->AppendTarget(fout, ti->first, 0,
this->AppendTarget(fout, targetName, 0,
make.c_str(), *lg, compiler.c_str());
break;
case cmState::EXECUTABLE:
@ -358,11 +358,10 @@ void cmExtraCodeBlocksGenerator
case cmState::MODULE_LIBRARY:
case cmState::OBJECT_LIBRARY:
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
this->AppendTarget(fout, ti->first, gt,
cmGeneratorTarget* gt = *ti;
this->AppendTarget(fout, targetName, gt,
make.c_str(), *lg, compiler.c_str());
std::string fastTarget = ti->first;
std::string fastTarget = targetName;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget, gt,
make.c_str(), *lg, compiler.c_str());
@ -388,11 +387,11 @@ void cmExtraCodeBlocksGenerator
lg!=lgs.end(); lg++)
{
cmMakefile* makefile=(*lg)->GetMakefile();
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
switch(ti->second.GetType())
switch((*ti)->GetType())
{
case cmState::EXECUTABLE:
case cmState::STATIC_LIBRARY:
@ -402,8 +401,7 @@ void cmExtraCodeBlocksGenerator
case cmState::UTILITY: // can have sources since 2.6.3
{
std::vector<cmSourceFile*> sources;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
cmGeneratorTarget* gt = *ti;
gt->GetSourceFiles(sources,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
@ -442,7 +440,7 @@ void cmExtraCodeBlocksGenerator
}
CbpUnit &cbpUnit = allFiles[fullPath];
cbpUnit.Targets.push_back(&(ti->second));
cbpUnit.Targets.push_back(*ti);
}
}
default: // intended fallthrough
@ -502,8 +500,9 @@ void cmExtraCodeBlocksGenerator
fout<<" <Unit filename=\""<< cmXMLSafe(unitFilename) <<"\">\n";
for(std::vector<const cmTarget*>::const_iterator ti = unit.Targets.begin();
ti != unit.Targets.end(); ++ti)
for(std::vector<const cmGeneratorTarget*>::const_iterator ti =
unit.Targets.begin();
ti != unit.Targets.end(); ++ti)
{
std::string const& targetName = (*ti)->GetName();
fout<<" <Option target=\""<< cmXMLSafe(targetName) <<"\"/>\n";
@ -561,7 +560,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
fout<<" <Target title=\"" << targetName << "\">\n";
if (target!=0)
{
int cbTargetType = this->GetCBTargetType(target->Target);
int cbTargetType = this->GetCBTargetType(target);
std::string workingDir = lg->GetCurrentBinaryDirectory();
if ( target->GetType()==cmState::EXECUTABLE)
{
@ -719,7 +718,7 @@ std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf)
// Translate the cmake target type into the CodeBlocks target type id
int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target)
int cmExtraCodeBlocksGenerator::GetCBTargetType(cmGeneratorTarget* target)
{
if ( target->GetType()==cmState::EXECUTABLE)
{

5
Source/cmExtraCodeBlocksGenerator.h
View File

@ -18,7 +18,6 @@
class cmLocalGenerator;
class cmMakefile;
class cmGeneratorTarget;
class cmTarget;
class cmGeneratedFileStream;
/** \class cmExtraCodeBlocksGenerator
@ -42,7 +41,7 @@ public:
private:
struct CbpUnit
{
std::vector<const cmTarget*> Targets;
std::vector<const cmGeneratorTarget*> Targets;
};
void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
@ -53,7 +52,7 @@ private:
cmGeneratorTarget* target) const;
std::string GetCBCompilerId(const cmMakefile* mf);
int GetCBTargetType(cmTarget* target);
int GetCBTargetType(cmGeneratorTarget* target);
std::string BuildMakeCommand(const std::string& make, const char* makefile,
const std::string& target);
void AppendTarget(cmGeneratedFileStream& fout,

11
Source/cmExtraCodeLiteGenerator.cxx
View File

@ -155,12 +155,12 @@ void cmExtraCodeLiteGenerator
lg!=lgs.end(); lg++)
{
cmMakefile* makefile=(*lg)->GetMakefile();
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
switch(ti->second.GetType())
switch((*ti)->GetType())
{
case cmState::EXECUTABLE:
{
@ -186,7 +186,7 @@ void cmExtraCodeLiteGenerator
break;
}
switch(ti->second.GetType())
switch((*ti)->GetType())
{
case cmState::EXECUTABLE:
case cmState::STATIC_LIBRARY:
@ -194,8 +194,7 @@ void cmExtraCodeLiteGenerator
case cmState::MODULE_LIBRARY:
{
std::vector<cmSourceFile*> sources;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
cmGeneratorTarget* gt = *ti;
gt->GetSourceFiles(sources,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();

56
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -536,13 +536,15 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
++lgIt)
{
cmMakefile* makefile = (*lgIt)->GetMakefile();
const cmTargets& targets = makefile->GetTargets();
const std::vector<cmGeneratorTarget*> targets =
(*lgIt)->GetGeneratorTargets();
for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end();++ti)
for(std::vector<cmGeneratorTarget*>::const_iterator ti=targets.begin();
ti!=targets.end();++ti)
{
std::string linkName2 = linkName;
linkName2 += "/";
switch(ti->second.GetType())
switch((*ti)->GetType())
{
case cmState::EXECUTABLE:
case cmState::STATIC_LIBRARY:
@ -550,10 +552,10 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
case cmState::MODULE_LIBRARY:
case cmState::OBJECT_LIBRARY:
{
const char* prefix = (ti->second.GetType()==cmState::EXECUTABLE ?
const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ?
"[exe] " : "[lib] ");
linkName2 += prefix;
linkName2 += ti->first;
linkName2 += (*ti)->GetName();
this->AppendLinkedResource(fout, linkName2, "virtual:/virtual",
VirtualFolder);
if (!this->GenerateLinkedResources)
@ -562,10 +564,8 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
}
std::vector<cmSourceGroup> sourceGroups=makefile->GetSourceGroups();
// get the files from the source lists then add them to the groups
cmTarget* tgt = const_cast<cmTarget*>(&ti->second);
cmGeneratorTarget* gt = const_cast<cmGeneratorTarget*>(*ti);
std::vector<cmSourceFile*> files;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(tgt);
gt->GetSourceFiles(files,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for(std::vector<cmSourceFile*>::const_iterator sfIt = files.begin();
@ -965,13 +965,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
it != this->GlobalGenerator->GetLocalGenerators().end();
++it)
{
cmGeneratorTargetsType targets = (*it)->GetGeneratorTargets();
for (cmGeneratorTargetsType::iterator l = targets.begin();
std::vector<cmGeneratorTarget*> targets = (*it)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator l = targets.begin();
l != targets.end(); ++l)
{
std::vector<std::string> includeDirs;
std::string config = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
(*it)->GetIncludeDirectories(includeDirs, l->second, "C", config);
(*it)->GetIncludeDirectories(includeDirs, *l, "C", config);
this->AppendIncludeDirectories(fout, includeDirs, emmited);
}
}
@ -1030,7 +1030,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
it != this->GlobalGenerator->GetLocalGenerators().end();
++it)
{
const cmTargets& targets = (*it)->GetMakefile()->GetTargets();
const std::vector<cmGeneratorTarget*> targets =
(*it)->GetGeneratorTargets();
std::string subdir = (*it)->Convert((*it)->GetCurrentBinaryDirectory(),
cmLocalGenerator::HOME_OUTPUT);
if (subdir == ".")
@ -1038,9 +1039,11 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
subdir = "";
}
for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end(); ++ti)
for(std::vector<cmGeneratorTarget*>::const_iterator ti =
targets.begin(); ti!=targets.end(); ++ti)
{
switch(ti->second.GetType())
std::string targetName = (*ti)->GetName();
switch((*ti)->GetType())
{
case cmState::GLOBAL_TARGET:
{
@ -1048,22 +1051,22 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// not from the subdirs
if (subdir.empty())
{
this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": ");
this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": ");
}
}
break;
case cmState::UTILITY:
// Add all utility targets, except the Nightly/Continuous/
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
if (((targetName.find("Nightly")==0) &&(targetName!="Nightly"))
|| ((targetName.find("Continuous")==0)&&(targetName!="Continuous"))
|| ((targetName.find("Experimental")==0)
&& (targetName!="Experimental")))
{
break;
}
this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": ");
this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": ");
break;
case cmState::EXECUTABLE:
case cmState::STATIC_LIBRARY:
@ -1071,10 +1074,10 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
case cmState::MODULE_LIBRARY:
case cmState::OBJECT_LIBRARY:
{
const char* prefix = (ti->second.GetType()==cmState::EXECUTABLE ?
const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ?
"[exe] " : "[lib] ");
this->AppendTarget(fout, ti->first, make, makeArgs, subdir, prefix);
std::string fastTarget = ti->first;
this->AppendTarget(fout, targetName, make, makeArgs, subdir, prefix);
std::string fastTarget = targetName;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget, make, makeArgs, subdir, prefix);
@ -1083,21 +1086,20 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
{
std::string virtDir = "[Targets]/";
virtDir += prefix;
virtDir += ti->first;
virtDir += targetName;
std::string buildArgs = "-C \"";
buildArgs += (*it)->GetBinaryDirectory();
buildArgs += "\" ";
buildArgs += makeArgs;
this->AppendTarget(fout, "Build", make, buildArgs, virtDir, "",
ti->first.c_str());
targetName.c_str());
std::string cleanArgs = "-E chdir \"";
cleanArgs += (*it)->GetCurrentBinaryDirectory();
cleanArgs += "\" \"";
cleanArgs += cmSystemTools::GetCMakeCommand();
cleanArgs += "\" -P \"";
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
cmGeneratorTarget* gt = *ti;
cleanArgs += (*it)->GetTargetDirectory(gt);
cleanArgs += "/cmake_clean.cmake\"";
this->AppendTarget(fout, "Clean", cmSystemTools::GetCMakeCommand(),

31
Source/cmExtraKateGenerator.cxx
View File

@ -119,14 +119,16 @@ cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
it != this->GlobalGenerator->GetLocalGenerators().end();
++it)
{
const cmTargets& targets = (*it)->GetMakefile()->GetTargets();
cmMakefile* makefile=(*it)->GetMakefile();
const std::vector<cmGeneratorTarget*> targets =
(*it)->GetGeneratorTargets();
std::string currentDir = (*it)->GetCurrentBinaryDirectory();
bool topLevel = (currentDir == (*it)->GetBinaryDirectory());
for(cmTargets::const_iterator ti=targets.begin(); ti!=targets.end(); ++ti)
for(std::vector<cmGeneratorTarget*>::const_iterator ti =
targets.begin(); ti!=targets.end(); ++ti)
{
switch(ti->second.GetType())
std::string targetName = (*ti)->GetName();
switch((*ti)->GetType())
{
case cmState::GLOBAL_TARGET:
{
@ -138,9 +140,9 @@ cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
insertTarget = true;
// only add the "edit_cache" target if it's not ccmake, because
// this will not work within the IDE
if (ti->first == "edit_cache")
if (targetName == "edit_cache")
{
const char* editCommand = makefile->GetDefinition
const char* editCommand = (*it)->GetMakefile()->GetDefinition
("CMAKE_EDIT_COMMAND");
if (editCommand == 0)
{
@ -154,7 +156,7 @@ cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
}
if (insertTarget)
{
this->AppendTarget(fout, ti->first, make, makeArgs,
this->AppendTarget(fout, targetName, make, makeArgs,
currentDir, homeOutputDir);
}
}
@ -162,15 +164,16 @@ cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
case cmState::UTILITY:
// Add all utility targets, except the Nightly/Continuous/
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
if (((targetName.find("Nightly")==0) &&(targetName!="Nightly"))
|| ((targetName.find("Continuous")==0)
&&(targetName!="Continuous"))
|| ((targetName.find("Experimental")==0)
&& (targetName!="Experimental")))
{
break;
}
this->AppendTarget(fout, ti->first, make, makeArgs,
this->AppendTarget(fout, targetName, make, makeArgs,
currentDir, homeOutputDir);
break;
case cmState::EXECUTABLE:
@ -179,9 +182,9 @@ cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
case cmState::MODULE_LIBRARY:
case cmState::OBJECT_LIBRARY:
{
this->AppendTarget(fout, ti->first, make, makeArgs,
this->AppendTarget(fout, targetName, make, makeArgs,
currentDir, homeOutputDir);
std::string fastTarget = ti->first;
std::string fastTarget = targetName;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget, make, makeArgs,
currentDir, homeOutputDir);

37
Source/cmExtraSublimeTextGenerator.cxx
View File

@ -20,7 +20,6 @@
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include <cmsys/SystemTools.hxx>
@ -162,11 +161,12 @@ void cmExtraSublimeTextGenerator::
lg!=lgs.end(); lg++)
{
cmMakefile* makefile=(*lg)->GetMakefile();
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
switch(ti->second.GetType())
std::string targetName = (*ti)->GetName();
switch((*ti)->GetType())
{
case cmState::GLOBAL_TARGET:
{
@ -175,7 +175,7 @@ void cmExtraSublimeTextGenerator::
if (strcmp((*lg)->GetCurrentBinaryDirectory(),
(*lg)->GetBinaryDirectory())==0)
{
this->AppendTarget(fout, ti->first, *lg, 0,
this->AppendTarget(fout, targetName, *lg, 0,
make.c_str(), makefile, compiler.c_str(),
sourceFileFlags, false);
}
@ -184,15 +184,16 @@ void cmExtraSublimeTextGenerator::
case cmState::UTILITY:
// Add all utility targets, except the Nightly/Continuous/
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
if (((targetName.find("Nightly")==0) &&(targetName!="Nightly"))
|| ((targetName.find("Continuous")==0)
&&(targetName!="Continuous"))
|| ((targetName.find("Experimental")==0)
&& (targetName!="Experimental")))
{
break;
}
this->AppendTarget(fout, ti->first, *lg, 0,
this->AppendTarget(fout, targetName, *lg, 0,
make.c_str(), makefile, compiler.c_str(),
sourceFileFlags, false);
break;
@ -202,12 +203,12 @@ void cmExtraSublimeTextGenerator::
case cmState::MODULE_LIBRARY:
case cmState::OBJECT_LIBRARY:
{
this->AppendTarget(fout, ti->first, *lg, &ti->second,
this->AppendTarget(fout, targetName, *lg, *ti,
make.c_str(), makefile, compiler.c_str(),
sourceFileFlags, false);
std::string fastTarget = ti->first;
std::string fastTarget = targetName;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget, *lg, &ti->second,
this->AppendTarget(fout, fastTarget, *lg, *ti,
make.c_str(), makefile, compiler.c_str(),
sourceFileFlags, false);
}
@ -223,7 +224,7 @@ void cmExtraSublimeTextGenerator::
AppendTarget(cmGeneratedFileStream& fout,
const std::string& targetName,
cmLocalGenerator* lg,
cmTarget* target,
cmGeneratorTarget* target,
const char* make,
const cmMakefile* makefile,
const char*, //compiler
@ -233,10 +234,8 @@ void cmExtraSublimeTextGenerator::
if (target != 0)
{
cmGeneratorTarget *gtgt = this->GlobalGenerator
->GetGeneratorTarget(target);
std::vector<cmSourceFile*> sourceFiles;
gtgt->GetSourceFiles(sourceFiles,
target->GetSourceFiles(sourceFiles,
makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
std::vector<cmSourceFile*>::const_iterator sourceFilesEnd =
sourceFiles.end();
@ -254,9 +253,9 @@ void cmExtraSublimeTextGenerator::
}
std::vector<std::string>& flags = sourceFileFlagsIter->second;
std::string flagsString =
this->ComputeFlagsForObject(*iter, lg, gtgt);
this->ComputeFlagsForObject(*iter, lg, target);
std::string definesString =
this->ComputeDefines(*iter, lg, gtgt);
this->ComputeDefines(*iter, lg, target);
flags.clear();
cmsys::RegularExpression flagRegex;
// Regular expression to extract compiler flags from a string

3
Source/cmExtraSublimeTextGenerator.h
View File

@ -18,7 +18,6 @@
class cmLocalGenerator;
class cmMakefile;
class cmTarget;
class cmGeneratedFileStream;
class cmGeneratorTarget;
@ -67,7 +66,7 @@ private:
void AppendTarget(cmGeneratedFileStream& fout,
const std::string& targetName,
cmLocalGenerator* lg,
cmTarget* target,
cmGeneratorTarget* target,
const char* make,
const cmMakefile* makefile,
const char* compiler,

8
Source/cmGeneratorTarget.cxx
View File

@ -3607,14 +3607,14 @@ std::string cmGeneratorTarget::GetPDBName(const std::string& config) const
return prefix+base+".pdb";
}
bool cmStrictTargetComparison::operator()(cmTarget const* t1,
cmTarget const* t2) const
bool cmGeneratorTarget::StrictTargetComparison::operator()(
cmGeneratorTarget const* t1, cmGeneratorTarget const* t2) const
{
int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str());
if (nameResult == 0)
{
return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(),
t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0;
return strcmp(t1->GetLocalGenerator()->GetCurrentBinaryDirectory(),
t2->GetLocalGenerator()->GetCurrentBinaryDirectory()) < 0;
}
return nameResult < 0;
}

11
Source/cmGeneratorTarget.h
View File

@ -673,14 +673,11 @@ public:
{
return this->MaxLanguageStandards;
}
};
struct cmStrictTargetComparison {
bool operator()(cmTarget const* t1, cmTarget const* t2) const;
struct StrictTargetComparison {
bool operator()(cmGeneratorTarget const* t1,
cmGeneratorTarget const* t2) const;
};
};
typedef std::map<cmTarget const*,
cmGeneratorTarget*,
cmStrictTargetComparison> cmGeneratorTargetsType;
#endif

56
Source/cmGhsMultiTargetGenerator.cxx
View File

@ -22,23 +22,22 @@
std::string const cmGhsMultiTargetGenerator::DDOption("-dynamic");
cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget *target)
: Target(target->Target)
, GeneratorTarget(target)
: GeneratorTarget(target)
, LocalGenerator(static_cast<cmLocalGhsMultiGenerator *>(
target->GetLocalGenerator()))
, Makefile(target->Target->GetMakefile())
, TargetGroup(DetermineIfTargetGroup(target))
, DynamicDownload(false)
{
this->RelBuildFilePath = this->GetRelBuildFilePath(target->Target);
this->RelBuildFilePath = this->GetRelBuildFilePath(target);
this->RelOutputFileName =
this->RelBuildFilePath + this->Target->GetName() + ".a";
this->RelBuildFilePath + target->GetName() + ".a";
this->RelBuildFileName = this->RelBuildFilePath;
this->RelBuildFileName += this->GetBuildFileName(target->Target);
this->RelBuildFileName += this->GetBuildFileName(target);
std::string absPathToRoot = this->GetAbsPathToRoot(target->Target);
std::string absPathToRoot = this->GetAbsPathToRoot(target);
absPathToRoot = this->AddSlashIfNeededToPath(absPathToRoot);
this->AbsBuildFilePath = absPathToRoot + this->RelBuildFilePath;
this->AbsBuildFileName = absPathToRoot + this->RelBuildFileName;
@ -51,7 +50,8 @@ cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator()
}
std::string
cmGhsMultiTargetGenerator::GetRelBuildFilePath(const cmTarget *target)
cmGhsMultiTargetGenerator::GetRelBuildFilePath(
const cmGeneratorTarget *target)
{
std::string output;
char const *folderProp = target->GetProperty("FOLDER");
@ -66,15 +66,13 @@ cmGhsMultiTargetGenerator::GetRelBuildFilePath(const cmTarget *target)
}
std::string
cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmTarget *target)
cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmGeneratorTarget *target)
{
cmGeneratorTarget* gt = target->GetMakefile()->GetGlobalGenerator()
->GetGeneratorTarget(target);
return gt->GetLocalGenerator()->GetBinaryDirectory();
return target->GetLocalGenerator()->GetBinaryDirectory();
}
std::string
cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmTarget *target)
cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmGeneratorTarget *target)
{
std::string output;
output = cmGhsMultiTargetGenerator::GetAbsPathToRoot(target);
@ -84,7 +82,7 @@ cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmTarget *target)
}
std::string
cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmTarget *target)
cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmGeneratorTarget *target)
{
std::string output;
output = cmGhsMultiTargetGenerator::GetRelBuildFilePath(target);
@ -93,7 +91,8 @@ cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmTarget *target)
return output;
}
std::string cmGhsMultiTargetGenerator::GetBuildFileName(const cmTarget *target)
std::string
cmGhsMultiTargetGenerator::GetBuildFileName(const cmGeneratorTarget *target)
{
std::string output;
output = target->GetName();
@ -161,7 +160,8 @@ void cmGhsMultiTargetGenerator::Generate()
bool cmGhsMultiTargetGenerator::IncludeThisTarget()
{
bool output = true;
char const *excludeFromAll = this->Target->GetProperty("EXCLUDE_FROM_ALL");
char const *excludeFromAll =
this->GeneratorTarget->GetProperty("EXCLUDE_FROM_ALL");
if (NULL != excludeFromAll && '1' == excludeFromAll[0] &&
'\0' == excludeFromAll[1])
{
@ -367,13 +367,13 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries()
for (cmTargetDependSet::iterator tdsI = tds.begin(); tdsI != tds.end();
++tdsI)
{
const cmTarget *tg = (*tdsI)->Target;
const cmGeneratorTarget *tg = *tdsI;
*this->GetFolderBuildStreams() << " -L\"" << GetAbsBuildFilePath(tg)
<< "\"" << std::endl;
}
// library targets
cmTarget::LinkLibraryVectorType llv =
this->Target->GetOriginalLinkLibraries();
this->GeneratorTarget->Target->GetOriginalLinkLibraries();
for (cmTarget::LinkLibraryVectorType::const_iterator llvI = llv.begin();
llvI != llv.end(); ++llvI)
{
@ -391,10 +391,12 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries()
void cmGhsMultiTargetGenerator::WriteCustomCommands()
{
WriteCustomCommandsHelper(this->Target->GetPreBuildCommands(),
cmTarget::PRE_BUILD);
WriteCustomCommandsHelper(this->Target->GetPostBuildCommands(),
cmTarget::POST_BUILD);
WriteCustomCommandsHelper(
this->GeneratorTarget->Target->GetPreBuildCommands(),
cmTarget::PRE_BUILD);
WriteCustomCommandsHelper(
this->GeneratorTarget->Target->GetPostBuildCommands(),
cmTarget::POST_BUILD);
}
void cmGhsMultiTargetGenerator::WriteCustomCommandsHelper(
@ -518,7 +520,7 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const
std::string outputDir(AbsBuildFilePath);
const char *runtimeOutputProp =
this->Target->GetProperty("RUNTIME_OUTPUT_DIRECTORY");
this->GeneratorTarget->GetProperty("RUNTIME_OUTPUT_DIRECTORY");
if (NULL != runtimeOutputProp)
{
outputDir = runtimeOutputProp;
@ -526,7 +528,8 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const
std::string configCapped(cmSystemTools::UpperCase(config));
const char *runtimeOutputSProp =
this->Target->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped);
this->GeneratorTarget
->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped);
if (NULL != runtimeOutputSProp)
{
outputDir = runtimeOutputSProp;
@ -544,9 +547,10 @@ cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const
std::string
cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const
{
std::string outputFilename(this->Target->GetName());
std::string outputFilename(this->GeneratorTarget->GetName());
const char *outputNameProp = this->Target->GetProperty("OUTPUT_NAME");
const char *outputNameProp =
this->GeneratorTarget->GetProperty("OUTPUT_NAME");
if (NULL != outputNameProp)
{
outputFilename = outputNameProp;
@ -554,7 +558,7 @@ cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const
std::string configCapped(cmSystemTools::UpperCase(config));
const char *outputNameSProp =
this->Target->GetProperty(configCapped + "_OUTPUT_NAME");
this->GeneratorTarget->GetProperty(configCapped + "_OUTPUT_NAME");
if (NULL != outputNameSProp)
{
outputFilename = outputNameSProp;

11
Source/cmGhsMultiTargetGenerator.h
View File

@ -54,11 +54,11 @@ public:
return this->AbsOutputFileName.c_str();
}
static std::string GetRelBuildFilePath(const cmTarget *target);
static std::string GetAbsPathToRoot(const cmTarget *target);
static std::string GetAbsBuildFilePath(const cmTarget *target);
static std::string GetRelBuildFileName(const cmTarget *target);
static std::string GetBuildFileName(const cmTarget *target);
static std::string GetRelBuildFilePath(const cmGeneratorTarget *target);
static std::string GetAbsPathToRoot(const cmGeneratorTarget *target);
static std::string GetAbsBuildFilePath(const cmGeneratorTarget *target);
static std::string GetRelBuildFileName(const cmGeneratorTarget *target);
static std::string GetBuildFileName(const cmGeneratorTarget *target);
static std::string AddSlashIfNeededToPath(std::string const &input);
private:
@ -99,7 +99,6 @@ private:
bool DetermineIfDynamicDownload(std::string const &config,
const std::string &language);
cmTarget *Target;
cmGeneratorTarget* GeneratorTarget;
cmLocalGhsMultiGenerator *LocalGenerator;
cmMakefile *Makefile;

61
Source/cmGlobalGenerator.cxx
View File

@ -48,6 +48,18 @@
#include <assert.h>
bool cmTarget::StrictTargetComparison::operator()(cmTarget const* t1,
cmTarget const* t2) const
{
int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str());
if (nameResult == 0)
{
return strcmp(t1->GetMakefile()->GetCurrentBinaryDirectory(),
t2->GetMakefile()->GetCurrentBinaryDirectory()) < 0;
}
return nameResult < 0;
}
cmGlobalGenerator::cmGlobalGenerator(cmake* cm)
: CMakeInstance(cm)
{
@ -1456,34 +1468,34 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
#ifdef CMAKE_BUILD_WITH_CMAKE
for(unsigned int i=0; i < this->LocalGenerators.size(); ++i)
{
cmTargets& targets =
this->LocalGenerators[i]->GetMakefile()->GetTargets();
std::vector<cmGeneratorTarget*> targets =
this->LocalGenerators[i]->GetGeneratorTargets();
std::vector<cmGeneratorTarget*> filteredTargets;
filteredTargets.reserve(targets.size());
for(cmTargets::iterator ti = targets.begin();
for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
if (ti->second.GetType() == cmState::GLOBAL_TARGET)
if ((*ti)->GetType() == cmState::GLOBAL_TARGET)
{
continue;
}
if(ti->second.GetType() != cmState::EXECUTABLE &&
ti->second.GetType() != cmState::STATIC_LIBRARY &&
ti->second.GetType() != cmState::SHARED_LIBRARY &&
ti->second.GetType() != cmState::MODULE_LIBRARY &&
ti->second.GetType() != cmState::OBJECT_LIBRARY)
if((*ti)->GetType() != cmState::EXECUTABLE &&
(*ti)->GetType() != cmState::STATIC_LIBRARY &&
(*ti)->GetType() != cmState::SHARED_LIBRARY &&
(*ti)->GetType() != cmState::MODULE_LIBRARY &&
(*ti)->GetType() != cmState::OBJECT_LIBRARY)
{
continue;
}
if((!ti->second.GetPropertyAsBool("AUTOMOC")
&& !ti->second.GetPropertyAsBool("AUTOUIC")
&& !ti->second.GetPropertyAsBool("AUTORCC"))
|| ti->second.IsImported())
if((!(*ti)->GetPropertyAsBool("AUTOMOC")
&& !(*ti)->GetPropertyAsBool("AUTOUIC")
&& !(*ti)->GetPropertyAsBool("AUTORCC"))
|| (*ti)->IsImported())
{
continue;
}
// don't do anything if there is no Qt4 or Qt5Core (which contains moc):
cmMakefile* mf = ti->second.GetMakefile();
cmMakefile* mf = (*ti)->Target->GetMakefile();
std::string qtMajorVersion = mf->GetSafeDefinition("QT_VERSION_MAJOR");
if (qtMajorVersion == "")
{
@ -1494,7 +1506,7 @@ cmGlobalGenerator::CreateQtAutoGeneratorsTargets()
continue;
}
cmGeneratorTarget* gt = this->GetGeneratorTarget(&ti->second);
cmGeneratorTarget* gt = *ti;
cmQtAutoGeneratorInitializer::InitializeAutogenSources(gt);
filteredTargets.push_back(gt);
@ -1584,7 +1596,7 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes,
cmTarget* t = &ti->second;
cmGeneratorTarget* gt = new cmGeneratorTarget(t, lg);
this->GeneratorTargets[t] = gt;
lg->AddGeneratorTarget(t, gt);
lg->AddGeneratorTarget(gt);
}
}
@ -2694,23 +2706,22 @@ void cmGlobalGenerator::GetTargetSets(TargetDependSet& projectTargets,
{
continue;
}
cmMakefile* mf = (*i)->GetMakefile();
// Get the targets in the makefile
cmTargets &tgts = mf->GetTargets();
std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets();
// loop over all the targets
for (cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
cmTarget* target = &l->second;
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
if(this->IsRootOnlyTarget(gt) &&
target->GetMakefile() != root->GetMakefile())
cmGeneratorTarget* target = *l;
if(this->IsRootOnlyTarget(target) &&
target->GetLocalGenerator() != root)
{
continue;
}
// put the target in the set of original targets
originalTargets.insert(gt);
originalTargets.insert(target);
// Get the set of targets that depend on target
this->AddTargetDepends(gt, projectTargets);
this->AddTargetDepends(target, projectTargets);
}
}
}

4
Source/cmGlobalGenerator.h
View File

@ -42,6 +42,10 @@ class cmInstallTargetGenerator;
class cmInstallFilesGenerator;
class cmExportBuildFileGenerator;
typedef std::map<cmTarget const*,
cmGeneratorTarget*,
cmTarget::StrictTargetComparison> cmGeneratorTargetsType;
/** \class cmGlobalGenerator
* \brief Responsible for overseeing the generation process for the entire tree
*

23
Source/cmGlobalGhsMultiGenerator.cxx
View File

@ -287,8 +287,8 @@ void cmGlobalGhsMultiGenerator::Generate()
{
cmLocalGhsMultiGenerator *lg =
static_cast<cmLocalGhsMultiGenerator *>(this->LocalGenerators[i]);
cmGeneratorTargetsType tgts = lg->GetGeneratorTargets();
this->UpdateBuildFiles(&tgts);
std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets();
this->UpdateBuildFiles(tgts);
}
}
@ -481,15 +481,15 @@ cmGlobalGhsMultiGenerator::GetFileNameFromPath(std::string const &path)
}
void cmGlobalGhsMultiGenerator::UpdateBuildFiles(
cmGeneratorTargetsType *tgts)
std::vector<cmGeneratorTarget*> tgts)
{
for (cmGeneratorTargetsType::iterator tgtsI = tgts->begin();
tgtsI != tgts->end(); ++tgtsI)
for (std::vector<cmGeneratorTarget*>::iterator tgtsI = tgts.begin();
tgtsI != tgts.end(); ++tgtsI)
{
const cmTarget *tgt(tgtsI->first);
const cmGeneratorTarget *tgt = *tgtsI;
if (IsTgtForBuild(tgt))
{
char const *rawFolderName = tgtsI->first->GetProperty("FOLDER");
char const *rawFolderName = tgt->GetProperty("FOLDER");
if (NULL == rawFolderName)
{
rawFolderName = "";
@ -510,19 +510,18 @@ void cmGlobalGhsMultiGenerator::UpdateBuildFiles(
*this->TargetFolderBuildStreams[folderName] << foldNameRelBuildFile
<< " ";
GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag(
tgtsI->second),
tgt),
this->TargetFolderBuildStreams[folderName]);
}
}
}
bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmTarget *tgt)
bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmGeneratorTarget *tgt)
{
const std::string config =
tgt->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
tgt->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
std::vector<cmSourceFile *> tgtSources;
cmGeneratorTarget* gt = this->GetGeneratorTarget(tgt);
gt->GetSourceFiles(tgtSources, config);
tgt->GetSourceFiles(tgtSources, config);
bool tgtInBuild = true;
char const *excludeFromAll = tgt->GetProperty("EXCLUDE_FROM_ALL");
if (NULL != excludeFromAll && '1' == excludeFromAll[0] &&

4
Source/cmGlobalGhsMultiGenerator.h
View File

@ -110,8 +110,8 @@ private:
std::vector<cmsys::String>::const_iterator end,
GhsMultiGpj::Types projType);
static std::string GetFileNameFromPath(std::string const &path);
void UpdateBuildFiles(cmGeneratorTargetsType *tgts);
bool IsTgtForBuild(const cmTarget *tgt);
void UpdateBuildFiles(std::vector<cmGeneratorTarget*> tgts);
bool IsTgtForBuild(const cmGeneratorTarget *tgt);
std::vector<cmGeneratedFileStream *> TargetSubProjects;
std::map<std::string, cmGeneratedFileStream *> TargetFolderBuildStreams;

20
Source/cmGlobalKdevelopGenerator.cxx
View File

@ -68,13 +68,14 @@ void cmGlobalKdevelopGenerator::Generate()
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
lg!=lgs.end(); lg++)
{
cmGeneratorTargetsType const& targets = (*lg)->GetGeneratorTargets();
for (cmGeneratorTargetsType::const_iterator ti = targets.begin();
ti != targets.end(); ti++)
std::vector<cmGeneratorTarget*> const& targets =
(*lg)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::const_iterator ti =
targets.begin(); ti != targets.end(); ti++)
{
if (ti->second->GetType()==cmState::EXECUTABLE)
if ((*ti)->GetType()==cmState::EXECUTABLE)
{
executable = ti->second->GetLocation("");
executable = (*ti)->GetLocation("");
break;
}
}
@ -132,14 +133,13 @@ bool cmGlobalKdevelopGenerator
}
//get all sources
cmTargets& targets=makefile->GetTargets();
for (cmTargets::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets=(*it)->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
std::vector<cmSourceFile*> sources;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&ti->second);
gt->GetSourceFiles(sources, ti->second.GetMakefile()
cmGeneratorTarget* gt = *ti;
gt->GetSourceFiles(sources, gt->Target->GetMakefile()
->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
si!=sources.end(); si++)

27
Source/cmGlobalNinjaGenerator.cxx
View File

@ -719,7 +719,7 @@ void cmGlobalNinjaGenerator
{
// Compute full path to object file directory for this target.
std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += gt->LocalGenerator->GetCurrentBinaryDirectory();
dir += "/";
dir += gt->LocalGenerator->GetTargetDirectory(gt);
dir += "/";
@ -886,7 +886,7 @@ void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os)
<< cmVersion::GetMinorVersion() << "\n\n";
}
void cmGlobalNinjaGenerator::AddDependencyToAll(cmTarget* target)
void cmGlobalNinjaGenerator::AddDependencyToAll(cmGeneratorTarget* target)
{
this->AppendTargetOutputs(target, this->AllDependencies);
}
@ -912,18 +912,16 @@ void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
void
cmGlobalNinjaGenerator
::AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs)
::AppendTargetOutputs(cmGeneratorTarget const* target, cmNinjaDeps& outputs)
{
std::string configName =
target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
cmGeneratorTarget *gtgt = this->GetGeneratorTarget(target);
target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
// for frameworks, we want the real name, not smple name
// frameworks always appear versioned, and the build.ninja
// will always attempt to manage symbolic links instead
// of letting cmOSXBundleGenerator do it.
bool realname = gtgt->IsFrameworkOnApple();
bool realname = target->IsFrameworkOnApple();
switch (target->GetType()) {
case cmState::EXECUTABLE:
@ -932,13 +930,13 @@ cmGlobalNinjaGenerator
case cmState::MODULE_LIBRARY:
{
outputs.push_back(this->ConvertToNinjaPath(
gtgt->GetFullPath(configName, false, realname)));
target->GetFullPath(configName, false, realname)));
break;
}
case cmState::OBJECT_LIBRARY:
case cmState::UTILITY: {
std::string path = this->ConvertToNinjaPath(
target->GetMakefile()->GetCurrentBinaryDirectory());
target->GetLocalGenerator()->GetCurrentBinaryDirectory());
if (path.empty() || path == ".")
outputs.push_back(target->GetName());
else {
@ -962,16 +960,15 @@ cmGlobalNinjaGenerator
void
cmGlobalNinjaGenerator
::AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs)
::AppendTargetDepends(cmGeneratorTarget const* target, cmNinjaDeps& outputs)
{
if (target->GetType() == cmState::GLOBAL_TARGET) {
// Global targets only depend on other utilities, which may not appear in
// the TargetDepends set (e.g. "all").
std::set<std::string> const& utils = target->GetUtilities();
std::set<std::string> const& utils = target->Target->GetUtilities();
std::copy(utils.begin(), utils.end(), std::back_inserter(outputs));
} else {
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(gt);
cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);
for (cmTargetDependSet::const_iterator i = targetDeps.begin();
i != targetDeps.end(); ++i)
{
@ -979,13 +976,13 @@ cmGlobalNinjaGenerator
{
continue;
}
this->AppendTargetOutputs((*i)->Target, outputs);
this->AppendTargetOutputs(*i, outputs);
}
}
}
void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
cmTarget* target) {
cmGeneratorTarget* target) {
cmNinjaDeps outputs;
this->AppendTargetOutputs(target, outputs);
// Mark the target's outputs as ambiguous to ensure that no other target uses

12
Source/cmGlobalNinjaGenerator.h
View File

@ -285,9 +285,11 @@ public:
ASD.insert(deps.begin(), deps.end());
}
void AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs);
void AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs);
void AddDependencyToAll(cmTarget* target);
void AppendTargetOutputs(cmGeneratorTarget const* target,
cmNinjaDeps& outputs);
void AppendTargetDepends(cmGeneratorTarget const* target,
cmNinjaDeps& outputs);
void AddDependencyToAll(cmGeneratorTarget* target);
void AddDependencyToAll(const std::string& input);
const std::vector<cmLocalGenerator*>& GetLocalGenerators() const {
@ -299,7 +301,7 @@ public:
int GetRuleCmdLength(const std::string& name) {
return RuleCmdLength[name]; }
void AddTargetAlias(const std::string& alias, cmTarget* target);
void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target);
virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
@ -388,7 +390,7 @@ private:
/// The mapping from source file to assumed dependencies.
std::map<std::string, std::set<std::string> > AssumedSourceDependencies;
typedef std::map<std::string, cmTarget*> TargetAliasMap;
typedef std::map<std::string, cmGeneratorTarget*> TargetAliasMap;
TargetAliasMap TargetAliases;
};

79
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -16,7 +16,6 @@
#include "cmake.h"
#include "cmGeneratedFileStream.h"
#include "cmSourceFile.h"
#include "cmTarget.h"
#include "cmGeneratorTarget.h"
#include "cmAlgorithms.h"
@ -116,7 +115,7 @@ cmGlobalUnixMakefileGenerator3
{
// Compute full path to object file directory for this target.
std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += gt->LocalGenerator->GetCurrentBinaryDirectory();
dir += "/";
dir += gt->LocalGenerator->GetTargetDirectory(gt);
dir += "/";
@ -423,17 +422,18 @@ void cmGlobalUnixMakefileGenerator3
{
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(lGenerators[i]);
// for all of out targets
for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin();
l != lg->GetMakefile()->GetTargets().end(); l++)
std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets();
for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); l++)
{
if((l->second.GetType() == cmState::EXECUTABLE) ||
(l->second.GetType() == cmState::STATIC_LIBRARY) ||
(l->second.GetType() == cmState::SHARED_LIBRARY) ||
(l->second.GetType() == cmState::MODULE_LIBRARY) ||
(l->second.GetType() == cmState::OBJECT_LIBRARY) ||
(l->second.GetType() == cmState::UTILITY))
if(((*l)->GetType() == cmState::EXECUTABLE) ||
((*l)->GetType() == cmState::STATIC_LIBRARY) ||
((*l)->GetType() == cmState::SHARED_LIBRARY) ||
((*l)->GetType() == cmState::MODULE_LIBRARY) ||
((*l)->GetType() == cmState::OBJECT_LIBRARY) ||
((*l)->GetType() == cmState::UTILITY))
{
cmGeneratorTarget* gt = this->GetGeneratorTarget(&l->second);
cmGeneratorTarget* gt = *l;
std::string tname = lg->GetRelativeTargetDirectory(gt);
tname += "/DependInfo.cmake";
cmSystemTools::ConvertToUnixSlashes(tname);
@ -460,11 +460,11 @@ cmGlobalUnixMakefileGenerator3
// The directory-level rule should depend on the target-level rules
// for all targets in the directory.
std::vector<std::string> depends;
cmGeneratorTargetsType targets = lg->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator l = targets.begin();
std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = targets.begin();
l != targets.end(); ++l)
{
cmGeneratorTarget* gtarget = l->second;
cmGeneratorTarget* gtarget = *l;
int type = gtarget->GetType();
if((type == cmState::EXECUTABLE) ||
(type == cmState::STATIC_LIBRARY) ||
@ -623,11 +623,11 @@ cmGlobalUnixMakefileGenerator3
lg = static_cast<cmLocalUnixMakefileGenerator3 *>
(this->LocalGenerators[i]);
// for each target Generate the rule files for each target.
cmGeneratorTargetsType targets = lg->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
cmGeneratorTarget* gtarget = t->second;
cmGeneratorTarget* gtarget = *t;
// Don't emit the same rule twice (e.g. two targets with the same
// simple name)
int type = gtarget->GetType();
@ -720,11 +720,11 @@ cmGlobalUnixMakefileGenerator3
depends.push_back("cmake_check_build_system");
// for each target Generate the rule files for each target.
cmGeneratorTargetsType targets = lg->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
cmGeneratorTarget* gtarget = t->second;
cmGeneratorTarget* gtarget = *t;
int type = gtarget->GetType();
std::string name = gtarget->GetName();
if (!name.empty()
@ -741,7 +741,7 @@ cmGlobalUnixMakefileGenerator3
makefileName = localName;
makefileName += "/build.make";
bool needRequiresStep = this->NeedRequiresStep(*gtarget->Target);
bool needRequiresStep = this->NeedRequiresStep(gtarget);
lg->WriteDivider(ruleFileStream);
ruleFileStream
@ -778,7 +778,7 @@ cmGlobalUnixMakefileGenerator3
std::ostringstream progressArg;
const char* sep = "";
std::vector<unsigned long>& progFiles =
this->ProgressMap[gtarget->Target].Marks;
this->ProgressMap[gtarget].Marks;
for (std::vector<unsigned long>::iterator i = progFiles.begin();
i != progFiles.end(); ++i)
{
@ -914,13 +914,11 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
lgi != this->LocalGenerators.end(); ++lgi)
{
cmLocalGenerator* lg = *lgi;
cmMakefile* mf = lg->GetMakefile();
cmTargets const& targets = mf->GetTargets();
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t)
std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
t != targets.end(); ++t)
{
cmTarget const& target = t->second;
cmGeneratorTarget* gt = this->GetGeneratorTarget(&target);
cmGeneratorTarget* gt = *t;
cmLocalGenerator* tlg = gt->GetLocalGenerator();
@ -966,7 +964,7 @@ cmGlobalUnixMakefileGenerator3
size_t count = 0;
if(emitted.insert(target).second)
{
count = this->ProgressMap[target->Target].Marks.size();
count = this->ProgressMap[target].Marks.size();
TargetDependSet const& depends = this->GetTargetDirectDepends(target);
for(TargetDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
@ -1003,7 +1001,7 @@ void
cmGlobalUnixMakefileGenerator3::RecordTargetProgress(
cmMakefileTargetGenerator* tg)
{
TargetProgress& tp = this->ProgressMap[tg->GetTarget()];
TargetProgress& tp = this->ProgressMap[tg->GetGeneratorTarget()];
tp.NumberOfActions = tg->GetNumberOfProgressActions();
tp.VariableFile = tg->GetProgressFileNameFull();
}
@ -1089,11 +1087,12 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
if (lg2 == lg || lg->GetMakefile()->IsRootMakefile())
{
// for each target Generate the rule files for each target.
cmTargets& targets = lg2->GetMakefile()->GetTargets();
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
std::vector<cmGeneratorTarget*> targets = lg2->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
cmTarget const& target = t->second;
cmState::TargetType type = target.GetType();
cmGeneratorTarget* target = *t;
cmState::TargetType type = target->GetType();
if((type == cmState::EXECUTABLE) ||
(type == cmState::STATIC_LIBRARY) ||
(type == cmState::SHARED_LIBRARY) ||
@ -1102,7 +1101,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
(type == cmState::GLOBAL_TARGET) ||
(type == cmState::UTILITY))
{
std::string name = target.GetName();
std::string name = target->GetName();
if(emittedTargets.insert(name).second)
{
path = "... ";
@ -1129,19 +1128,19 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
bool cmGlobalUnixMakefileGenerator3
::NeedRequiresStep(cmTarget const& target)
::NeedRequiresStep(const cmGeneratorTarget* target)
{
std::set<std::string> languages;
cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&target);
gtgt->GetLanguages(languages,
target.GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
target->GetLanguages(languages,
target->Target->GetMakefile()
->GetSafeDefinition("CMAKE_BUILD_TYPE"));
for(std::set<std::string>::const_iterator l = languages.begin();
l != languages.end(); ++l)
{
std::string var = "CMAKE_NEEDS_REQUIRES_STEP_";
var += *l;
var += "_FLAG";
if(target.GetMakefile()->GetDefinition(var))
if(target->Target->GetMakefile()->GetDefinition(var))
{
return true;
}

6
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -154,7 +154,7 @@ protected:
cmGeneratorTarget* target);
// does this generator need a requires step for any of its targets
bool NeedRequiresStep(cmTarget const&);
bool NeedRequiresStep(cmGeneratorTarget const*);
// Target name hooks for superclass.
const char* GetAllTargetName() const { return "all"; }
@ -192,8 +192,8 @@ protected:
std::vector<unsigned long> Marks;
void WriteProgressVariables(unsigned long total, unsigned long& current);
};
typedef std::map<cmTarget const*, TargetProgress,
cmStrictTargetComparison> ProgressMapType;
typedef std::map<cmGeneratorTarget const*, TargetProgress,
cmGeneratorTarget::StrictTargetComparison> ProgressMapType;
ProgressMapType ProgressMap;
size_t CountProgressMarksInTarget(cmGeneratorTarget const* target,

12
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -331,7 +331,7 @@ void cmGlobalVisualStudio10Generator::Generate()
this->cmGlobalVisualStudio8Generator::Generate();
if(this->LongestSource.Length > 0)
{
cmMakefile* mf = this->LongestSource.Target->GetMakefile();
cmLocalGenerator* lg = this->LongestSource.Target->GetLocalGenerator();
std::ostringstream e;
e <<
"The binary and/or source directory paths may be too long to generate "
@ -346,13 +346,13 @@ void cmGlobalVisualStudio10Generator::Generate()
" " << this->LongestSource.SourceFile->GetFullPath() << "\n"
"This is because some Visual Studio tools would append the relative "
"path to the end of the referencing directory path, as in:\n"
" " << mf->GetCurrentBinaryDirectory() << "/"
" " << lg->GetCurrentBinaryDirectory() << "/"
<< this->LongestSource.SourceRel << "\n"
"and then incorrectly complain that the file does not exist because "
"the path length is too long for some internal buffer or API. "
"To avoid this problem CMake must use a full path for this file "
"which then triggers the VS 10 property dialog bug.";
mf->IssueMessage(cmake::WARNING, e.str().c_str());
lg->IssueMessage(cmake::WARNING, e.str().c_str());
}
}
@ -591,9 +591,11 @@ cmGlobalVisualStudio10Generator
//----------------------------------------------------------------------------
void cmGlobalVisualStudio10Generator::PathTooLong(
cmTarget* target, cmSourceFile const* sf, std::string const& sfRel)
cmGeneratorTarget *target, cmSourceFile const* sf,
std::string const& sfRel)
{
size_t len = (strlen(target->GetMakefile()->GetCurrentBinaryDirectory()) +
size_t len =
(strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) +
1 + sfRel.length());
if(len > this->LongestSource.Length)
{

4
Source/cmGlobalVisualStudio10Generator.h
View File

@ -95,7 +95,7 @@ public:
/** Generate an <output>.rule file path for a given command output. */
virtual std::string GenerateRuleFile(std::string const& output) const;
void PathTooLong(cmTarget* target, cmSourceFile const* sf,
void PathTooLong(cmGeneratorTarget* target, cmSourceFile const* sf,
std::string const& sfRel);
virtual const char* GetToolsVersion() { return "4.0"; }
@ -139,7 +139,7 @@ private:
{
LongestSourcePath(): Length(0), Target(0), SourceFile(0) {}
size_t Length;
cmTarget* Target;
cmGeneratorTarget* Target;
cmSourceFile const* SourceFile;
std::string SourceRel;
};

25
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -223,7 +223,7 @@ void cmGlobalVisualStudio6Generator
tt = orderedProjectTargets.begin();
tt != orderedProjectTargets.end(); ++tt)
{
cmTarget const* target = (*tt)->Target;
cmGeneratorTarget const* target = *tt;
if(target->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
@ -235,14 +235,15 @@ void cmGlobalVisualStudio6Generator
std::string project = target->GetName();
std::string location = expath;
this->WriteExternalProject(fout, project.c_str(),
location.c_str(), target->GetUtilities());
location.c_str(), target->Target->GetUtilities());
}
else
{
std::string dspname = GetVS6TargetName(target->GetName());
std::string dir = target->GetMakefile()->GetCurrentBinaryDirectory();
std::string dir =
target->GetLocalGenerator()->GetCurrentBinaryDirectory();
dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT);
this->WriteProject(fout, dspname.c_str(), dir.c_str(), *target);
this->WriteProject(fout, dspname.c_str(), dir.c_str(), target);
}
}
@ -287,9 +288,9 @@ void cmGlobalVisualStudio6Generator::OutputDSWFile()
// Note, that dependencies from executables to
// the libraries it uses are also done here
void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
const std::string& dspname,
const char* dir,
cmTarget const& target)
const std::string& dspname,
const char* dir,
const cmGeneratorTarget *target)
{
fout << "#########################################################"
"######################\n\n";
@ -298,7 +299,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
fout << "Package=<5>\n{{{\n}}}\n\n";
fout << "Package=<4>\n";
fout << "{{{\n";
VSDependSet const& depends = this->VSTargetDepends[&target];
VSDependSet const& depends = this->VSTargetDepends[target];
for(VSDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
@ -309,7 +310,7 @@ void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
}
fout << "}}}\n\n";
UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target);
UtilityDependsMap::iterator ui = this->UtilityDepends.find(target);
if(ui != this->UtilityDepends.end())
{
const char* uname = ui->second.c_str();
@ -382,12 +383,14 @@ void cmGlobalVisualStudio6Generator::WriteDSWHeader(std::ostream& fout)
//----------------------------------------------------------------------------
std::string
cmGlobalVisualStudio6Generator::WriteUtilityDepend(cmTarget const* target)
cmGlobalVisualStudio6Generator::WriteUtilityDepend(
const cmGeneratorTarget *target)
{
std::string pname = target->GetName();
pname += "_UTILITY";
pname = GetVS6TargetName(pname.c_str());
std::string fname = target->GetMakefile()->GetCurrentBinaryDirectory();
std::string fname =
target->GetLocalGenerator()->GetCurrentBinaryDirectory();
fname += "/";
fname += pname;
fname += ".dsp";

6
Source/cmGlobalVisualStudio6Generator.h
View File

@ -15,8 +15,6 @@
#include "cmGlobalVisualStudioGenerator.h"
#include "cmGlobalGeneratorFactory.h"
class cmTarget;
/** \class cmGlobalVisualStudio6Generator
* \brief Write a Unix makefiles.
*
@ -94,12 +92,12 @@ private:
void WriteDSWHeader(std::ostream& fout);
void WriteProject(std::ostream& fout,
const std::string& name, const char* path,
cmTarget const& t);
cmGeneratorTarget const* t);
void WriteExternalProject(std::ostream& fout,
const std::string& name, const char* path,
const std::set<std::string>& dependencies);
void WriteDSWFooter(std::ostream& fout);
virtual std::string WriteUtilityDepend(cmTarget const* target);
virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target);
std::string MSDevCommand;
bool MSDevCommandInitialized;
std::string const& GetMSDevCommand();

12
Source/cmGlobalVisualStudio71Generator.cxx
View File

@ -152,7 +152,7 @@ void
cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
const std::string& dspname,
const char* dir,
cmTarget const& t)
cmGeneratorTarget const* t)
{
// check to see if this is a fortran build
const char* ext = ".vcproj";
@ -163,7 +163,7 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
ext = ".vfproj";
project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \"";
}
const char* targetExt = t.GetProperty("GENERATOR_FILE_NAME_EXT");
const char* targetExt = t->GetProperty("GENERATOR_FILE_NAME_EXT");
if(targetExt)
{
ext = targetExt;
@ -180,7 +180,7 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
fout <<"EndProject\n";
UtilityDependsMap::iterator ui = this->UtilityDepends.find(&t);
UtilityDependsMap::iterator ui = this->UtilityDepends.find(t);
if(ui != this->UtilityDepends.end())
{
const char* uname = ui->second.c_str();
@ -204,9 +204,9 @@ void
cmGlobalVisualStudio71Generator
::WriteProjectDepends(std::ostream& fout,
const std::string&,
const char*, cmTarget const& target)
const char*, cmGeneratorTarget const* target)
{
VSDependSet const& depends = this->VSTargetDepends[&target];
VSDependSet const& depends = this->VSTargetDepends[target];
for(VSDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
@ -215,7 +215,7 @@ cmGlobalVisualStudio71Generator
if(guid.empty())
{
std::string m = "Target: ";
m += target.GetName();
m += target->GetName();
m += " depends on unknown target: ";
m += name;
cmSystemTools::Error(m.c_str());

4
Source/cmGlobalVisualStudio71Generator.h
View File

@ -59,10 +59,10 @@ protected:
std::ostream& fout, std::vector<std::string> const& configs);
virtual void WriteProject(std::ostream& fout,
const std::string& name, const char* path,
cmTarget const& t);
const cmGeneratorTarget *t);
virtual void WriteProjectDepends(std::ostream& fout,
const std::string& name, const char* path,
cmTarget const& t);
cmGeneratorTarget const* t);
virtual void WriteProjectConfigurations(
std::ostream& fout, const std::string& name, cmState::TargetType type,
std::vector<std::string> const& configs,

38
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -441,7 +441,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
for(OrderedTargetDependSet::const_iterator tt =
projectTargets.begin(); tt != projectTargets.end(); ++tt)
{
cmTarget const* target = (*tt)->Target;
cmGeneratorTarget const* target = *tt;
if(target->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
@ -459,7 +459,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
project.c_str(),
location.c_str(),
target->GetProperty("VS_PROJECT_TYPE"),
target->GetUtilities());
target->Target->GetUtilities());
written = true;
}
else
@ -468,9 +468,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
target->GetProperty("GENERATOR_FILE_NAME");
if(vcprojName)
{
cmLocalGenerator* lg =
root->GetGlobalGenerator()->GetGeneratorTarget(target)
->GetLocalGenerator();
cmLocalGenerator* lg = target->GetLocalGenerator();
std::string dir = lg->GetCurrentBinaryDirectory();
dir = root->Convert(dir.c_str(),
cmLocalGenerator::START_OUTPUT);
@ -479,7 +477,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
dir = ""; // msbuild cannot handle ".\" prefix
}
this->WriteProject(fout, vcprojName, dir.c_str(),
*target);
target);
written = true;
}
}
@ -535,19 +533,19 @@ void cmGlobalVisualStudio7Generator::WriteTargetDepends(
for(OrderedTargetDependSet::const_iterator tt =
projectTargets.begin(); tt != projectTargets.end(); ++tt)
{
cmTarget const* target = (*tt)->Target;
cmGeneratorTarget const* target = *tt;
if(target->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
cmMakefile* mf = target->GetMakefile();
const char *vcprojName =
target->GetProperty("GENERATOR_FILE_NAME");
if (vcprojName)
{
std::string dir = mf->GetCurrentSourceDirectory();
std::string dir = target->GetLocalGenerator()
->GetCurrentSourceDirectory();
this->WriteProjectDepends(fout, vcprojName,
dir.c_str(), *target);
dir.c_str(), target);
}
}
}
@ -687,7 +685,8 @@ cmGlobalVisualStudio7Generator::ConvertToSolutionPath(const char* path)
// the libraries it uses are also done here
void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout,
const std::string& dspname,
const char* dir, cmTarget const& target)
const char* dir,
cmGeneratorTarget const* target)
{
// check to see if this is a fortran build
const char* ext = ".vcproj";
@ -705,7 +704,7 @@ void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout,
<< dspname << ext << "\", \"{"
<< this->GetGUID(dspname) << "}\"\nEndProject\n";
UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target);
UtilityDependsMap::iterator ui = this->UtilityDepends.find(target);
if(ui != this->UtilityDepends.end())
{
const char* uname = ui->second.c_str();
@ -727,11 +726,11 @@ void
cmGlobalVisualStudio7Generator
::WriteProjectDepends(std::ostream& fout,
const std::string& dspname,
const char*, cmTarget const& target)
const char*, cmGeneratorTarget const* target)
{
int depcount = 0;
std::string dspguid = this->GetGUID(dspname);
VSDependSet const& depends = this->VSTargetDepends[&target];
VSDependSet const& depends = this->VSTargetDepends[target];
for(VSDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
@ -740,7 +739,7 @@ cmGlobalVisualStudio7Generator
if(guid.empty())
{
std::string m = "Target: ";
m += target.GetName();
m += target->GetName();
m += " depends on unknown target: ";
m += name;
cmSystemTools::Error(m.c_str());
@ -749,7 +748,7 @@ cmGlobalVisualStudio7Generator
depcount++;
}
UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target);
UtilityDependsMap::iterator ui = this->UtilityDepends.find(target);
if(ui != this->UtilityDepends.end())
{
const char* uname = ui->second.c_str();
@ -889,13 +888,14 @@ void cmGlobalVisualStudio7Generator::WriteSLNHeader(std::ostream& fout)
//----------------------------------------------------------------------------
std::string
cmGlobalVisualStudio7Generator::WriteUtilityDepend(cmTarget const* target)
cmGlobalVisualStudio7Generator::WriteUtilityDepend(
cmGeneratorTarget const* target)
{
std::vector<std::string> configs;
target->GetMakefile()->GetConfigurations(configs);
target->Target->GetMakefile()->GetConfigurations(configs);
std::string pname = target->GetName();
pname += "_UTILITY";
std::string fname = target->GetMakefile()->GetCurrentBinaryDirectory();
std::string fname = target->GetLocalGenerator()->GetCurrentBinaryDirectory();
fname += "/";
fname += pname;
fname += ".vcproj";

9
Source/cmGlobalVisualStudio7Generator.h
View File

@ -94,7 +94,8 @@ public:
/** Return true if the target project file should have the option
LinkLibraryDependencies and link to .sln dependencies. */
virtual bool NeedLinkLibraryDependencies(cmTarget&) { return false; }
virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget*)
{ return false; }
const char* GetIntelProjectVersion();
@ -123,10 +124,10 @@ protected:
std::vector<cmLocalGenerator*>& generators);
virtual void WriteProject(std::ostream& fout,
const std::string& name, const char* path,
cmTarget const& t);
const cmGeneratorTarget *t);
virtual void WriteProjectDepends(std::ostream& fout,
const std::string& name, const char* path,
cmTarget const&t);
cmGeneratorTarget const* t);
virtual void WriteProjectConfigurations(
std::ostream& fout, const std::string& name, cmState::TargetType type,
std::vector<std::string> const& configs,
@ -136,7 +137,7 @@ protected:
cmLocalGenerator* root);
virtual void WriteSLNFooter(std::ostream& fout);
virtual void WriteSLNHeader(std::ostream& fout);
virtual std::string WriteUtilityDepend(cmTarget const* target);
virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target);
virtual void WriteTargetsToSolution(
std::ostream& fout,

15
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -256,7 +256,7 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
noCommandLines);
cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg);
lg->AddGeneratorTarget(tgt, gt);
lg->AddGeneratorTarget(gt);
this->AddGeneratorTarget(tgt, gt);
// Organize in the "predefined targets" folder:
@ -441,9 +441,9 @@ bool cmGlobalVisualStudio8Generator::ComputeTargetDepends()
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator::WriteProjectDepends(
std::ostream& fout, const std::string&, const char*, cmTarget const& t)
std::ostream& fout, const std::string&, const char*,
cmGeneratorTarget const* gt)
{
cmGeneratorTarget* gt = this->GetGeneratorTarget(&t);
TargetDependSet const& unordered = this->GetTargetDirectDepends(gt);
OrderedTargetDependSet depends(unordered, std::string());
for(OrderedTargetDependSet::const_iterator i = depends.begin();
@ -460,14 +460,15 @@ void cmGlobalVisualStudio8Generator::WriteProjectDepends(
//----------------------------------------------------------------------------
bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies(
cmTarget& target)
cmGeneratorTarget *target)
{
// Look for utility dependencies that magically link.
for(std::set<std::string>::const_iterator ui =
target.GetUtilities().begin();
ui != target.GetUtilities().end(); ++ui)
target->Target->GetUtilities().begin();
ui != target->Target->GetUtilities().end(); ++ui)
{
if(cmTarget* depTarget = this->FindTarget(ui->c_str()))
if(cmGeneratorTarget* depTarget =
target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str()))
{
if(depTarget->GetType() != cmState::INTERFACE_LIBRARY
&& depTarget->GetProperty("EXTERNAL_MSPROJECT"))

5
Source/cmGlobalVisualStudio8Generator.h
View File

@ -60,7 +60,7 @@ public:
/** Return true if the target project file should have the option
LinkLibraryDependencies and link to .sln dependencies. */
virtual bool NeedLinkLibraryDependencies(cmTarget& target);
virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget* target);
/** Return true if building for Windows CE */
virtual bool TargetsWindowsCE() const {
@ -91,7 +91,8 @@ protected:
virtual bool ComputeTargetDepends();
virtual void WriteProjectDepends(std::ostream& fout,
const std::string& name,
const char* path, cmTarget const& t);
const char* path,
const cmGeneratorTarget *t);
std::string Name;
std::string WindowsCEVersion;

100
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -87,7 +87,7 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
"Build all projects");
cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]);
gen[0]->AddGeneratorTarget(allBuild, gt);
gen[0]->AddGeneratorTarget(gt);
this->AddGeneratorTarget(allBuild, gt);
#if 0
@ -108,19 +108,20 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
for(std::vector<cmLocalGenerator*>::iterator i = gen.begin();
i != gen.end(); ++i)
{
cmGeneratorTargetsType targets =
std::vector<cmGeneratorTarget*> targets =
(*i)->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
if (t->second->GetType() == cmState::GLOBAL_TARGET
|| t->first->IsImported())
cmGeneratorTarget* tgt = *t;
if (tgt->GetType() == cmState::GLOBAL_TARGET
|| tgt->IsImported())
{
continue;
}
if(!this->IsExcluded(gen[0], t->second))
if(!this->IsExcluded(gen[0], tgt))
{
allBuild->AddUtility(t->second->GetName());
allBuild->AddUtility(tgt->GetName());
}
}
}
@ -302,19 +303,20 @@ std::string cmGlobalVisualStudioGenerator::GetUserMacrosRegKeyBase()
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudioGenerator::FillLinkClosure(cmTarget const* target,
TargetSet& linked)
void cmGlobalVisualStudioGenerator::FillLinkClosure(
const cmGeneratorTarget *target,
TargetSet& linked)
{
if(linked.insert(target).second)
{
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
TargetDependSet const& depends = this->GetTargetDirectDepends(gt);
TargetDependSet const& depends =
this->GetTargetDirectDepends(target);
for(TargetDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
if(di->IsLink())
{
this->FillLinkClosure((*di)->Target, linked);
this->FillLinkClosure(*di, linked);
}
}
}
@ -322,7 +324,7 @@ void cmGlobalVisualStudioGenerator::FillLinkClosure(cmTarget const* target,
//----------------------------------------------------------------------------
cmGlobalVisualStudioGenerator::TargetSet const&
cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmTarget* target)
cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmGeneratorTarget* target)
{
TargetSetMap::iterator i = this->TargetLinkClosure.find(target);
if(i == this->TargetLinkClosure.end())
@ -336,7 +338,8 @@ cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmTarget* target)
//----------------------------------------------------------------------------
void cmGlobalVisualStudioGenerator::FollowLinkDepends(
cmTarget const* target, std::set<cmTarget const*>& linked)
const cmGeneratorTarget *target,
std::set<const cmGeneratorTarget *> &linked)
{
if(target->GetType() == cmState::INTERFACE_LIBRARY)
{
@ -347,14 +350,13 @@ void cmGlobalVisualStudioGenerator::FollowLinkDepends(
{
// Static library targets do not list their link dependencies so
// we must follow them transitively now.
cmGeneratorTarget* gt = this->GetGeneratorTarget(target);
TargetDependSet const& depends = this->GetTargetDirectDepends(gt);
TargetDependSet const& depends = this->GetTargetDirectDepends(target);
for(TargetDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
if(di->IsLink())
{
this->FollowLinkDepends((*di)->Target, linked);
this->FollowLinkDepends(*di, linked);
}
}
}
@ -374,11 +376,11 @@ bool cmGlobalVisualStudioGenerator::ComputeTargetDepends()
for(std::vector<cmLocalGenerator*>::iterator i = gen.begin();
i != gen.end(); ++i)
{
cmTargets& targets = (*i)->GetMakefile()->GetTargets();
for(cmTargets::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets = (*i)->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
this->ComputeVSTargetDepends(ti->second);
this->ComputeVSTargetDepends(*ti);
}
}
}
@ -392,13 +394,14 @@ static bool VSLinkable(cmGeneratorTarget const* t)
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target)
void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(
cmGeneratorTarget* target)
{
if(this->VSTargetDepends.find(&target) != this->VSTargetDepends.end())
if(this->VSTargetDepends.find(target) != this->VSTargetDepends.end())
{
return;
}
VSDependSet& vsTargetDepend = this->VSTargetDepends[&target];
VSDependSet& vsTargetDepend = this->VSTargetDepends[target];
// VS <= 7.1 has two behaviors that affect solution dependencies.
//
// (1) Solution-level dependencies between a linkable target and a
@ -418,19 +421,18 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target)
// leaving them out for the static library itself but following them
// transitively for other targets.
bool allowLinkable = (target.GetType() != cmState::STATIC_LIBRARY &&
target.GetType() != cmState::SHARED_LIBRARY &&
target.GetType() != cmState::MODULE_LIBRARY &&
target.GetType() != cmState::EXECUTABLE);
bool allowLinkable = (target->GetType() != cmState::STATIC_LIBRARY &&
target->GetType() != cmState::SHARED_LIBRARY &&
target->GetType() != cmState::MODULE_LIBRARY &&
target->GetType() != cmState::EXECUTABLE);
cmGeneratorTarget* gt = this->GetGeneratorTarget(&target);
TargetDependSet const& depends = this->GetTargetDirectDepends(gt);
TargetDependSet const& depends = this->GetTargetDirectDepends(target);
// Collect implicit link dependencies (target_link_libraries).
// Static libraries cannot depend on their link implementation
// due to behavior (2), but they do not really need to.
std::set<cmTarget const*> linkDepends;
if(target.GetType() != cmState::STATIC_LIBRARY)
std::set<cmGeneratorTarget const*> linkDepends;
if(target->GetType() != cmState::STATIC_LIBRARY)
{
for(TargetDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
@ -438,55 +440,54 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(cmTarget& target)
cmTargetDepend dep = *di;
if(dep.IsLink())
{
this->FollowLinkDepends(dep->Target, linkDepends);
this->FollowLinkDepends(*di, linkDepends);
}
}
}
// Collect explicit util dependencies (add_dependencies).
std::set<cmTarget const*> utilDepends;
std::set<cmGeneratorTarget const*> utilDepends;
for(TargetDependSet::const_iterator di = depends.begin();
di != depends.end(); ++di)
{
cmTargetDepend dep = *di;
if(dep.IsUtil())
{
this->FollowLinkDepends(dep->Target, utilDepends);
this->FollowLinkDepends(*di, utilDepends);
}
}
// Collect all targets linked by this target so we can avoid
// intermediate targets below.
TargetSet linked;
if(target.GetType() != cmState::STATIC_LIBRARY)
if(target->GetType() != cmState::STATIC_LIBRARY)
{
linked = this->GetTargetLinkClosure(&target);
linked = this->GetTargetLinkClosure(target);
}
// Emit link dependencies.
for(std::set<cmTarget const*>::iterator di = linkDepends.begin();
for(std::set<cmGeneratorTarget const*>::iterator di = linkDepends.begin();
di != linkDepends.end(); ++di)
{
cmTarget const* dep = *di;
cmGeneratorTarget const* dep = *di;
vsTargetDepend.insert(dep->GetName());
}
// Emit util dependencies. Possibly use intermediate targets.
for(std::set<cmTarget const*>::iterator di = utilDepends.begin();
for(std::set<cmGeneratorTarget const*>::iterator di = utilDepends.begin();
di != utilDepends.end(); ++di)
{
cmTarget const* dep = *di;
cmGeneratorTarget* dgt = this->GetGeneratorTarget(dep);
if(allowLinkable || !VSLinkable(dgt) || linked.count(dep))
cmGeneratorTarget const* dgt = *di;
if(allowLinkable || !VSLinkable(dgt) || linked.count(dgt))
{
// Direct dependency allowed.
vsTargetDepend.insert(dep->GetName());
vsTargetDepend.insert(dgt->GetName());
}
else
{
// Direct dependency on linkable target not allowed.
// Use an intermediate utility target.
vsTargetDepend.insert(this->GetUtilityDepend(dep));
vsTargetDepend.insert(this->GetUtilityDepend(dgt));
}
}
}
@ -506,7 +507,8 @@ void cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf)
//----------------------------------------------------------------------------
std::string
cmGlobalVisualStudioGenerator::GetUtilityDepend(cmTarget const* target)
cmGlobalVisualStudioGenerator::GetUtilityDepend(
cmGeneratorTarget const* target)
{
UtilityDependsMap::iterator i = this->UtilityDepends.find(target);
if(i == this->UtilityDepends.end())
@ -829,10 +831,8 @@ void RegisterVisualStudioMacros(const std::string& macrosFile,
}
}
bool
cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmTarget const& target)
cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmGeneratorTarget const* gt)
{
cmGeneratorTarget* gt = this->GetGeneratorTarget(&target);
// check to see if this is a fortran build
std::set<std::string> languages;
{
@ -891,9 +891,7 @@ cmGlobalVisualStudioGenerator::OrderedTargetDependSet
for (TargetSet::const_iterator it = targets.begin();
it != targets.end(); ++it)
{
cmGeneratorTarget* gt =
(*it)->GetMakefile()->GetGlobalGenerator()->GetGeneratorTarget(*it);
this->insert(gt);
this->insert(*it);
}
}

30
Source/cmGlobalVisualStudioGenerator.h
View File

@ -73,7 +73,7 @@ public:
const char* vsSolutionFile = 0);
// return true if target is fortran only
bool TargetIsFortranOnly(cmTarget const& t);
bool TargetIsFortranOnly(const cmGeneratorTarget *gt);
/** Get the top-level registry key for this VS version. */
std::string GetRegistryBase();
@ -88,7 +88,7 @@ public:
/** Return true if building for Windows CE */
virtual bool TargetsWindowsCE() const { return false; }
class TargetSet: public std::set<cmTarget const*> {};
class TargetSet: public std::set<cmGeneratorTarget const*> {};
class TargetCompare
{
std::string First;
@ -122,15 +122,16 @@ protected:
virtual bool ComputeTargetDepends();
class VSDependSet: public std::set<std::string> {};
class VSDependMap: public std::map<cmTarget const*, VSDependSet> {};
class VSDependMap: public std::map<cmGeneratorTarget const*, VSDependSet> {};
VSDependMap VSTargetDepends;
void ComputeVSTargetDepends(cmTarget&);
void ComputeVSTargetDepends(cmGeneratorTarget *);
bool CheckTargetLinks(cmTarget& target, const std::string& name);
std::string GetUtilityForTarget(cmTarget& target, const std::string&);
virtual std::string WriteUtilityDepend(cmTarget const*) = 0;
std::string GetUtilityDepend(cmTarget const* target);
typedef std::map<cmTarget const*, std::string> UtilityDependsMap;
bool CheckTargetLinks(cmGeneratorTarget& target, const std::string& name);
std::string GetUtilityForTarget(cmGeneratorTarget& target,
const std::string&);
virtual std::string WriteUtilityDepend(cmGeneratorTarget const*) = 0;
std::string GetUtilityDepend(const cmGeneratorTarget *target);
typedef std::map<cmGeneratorTarget const*, std::string> UtilityDependsMap;
UtilityDependsMap UtilityDepends;
protected:
@ -141,13 +142,14 @@ private:
void PrintCompilerAdvice(std::ostream&, std::string const&,
const char*) const {}
void FollowLinkDepends(cmTarget const* target,
std::set<cmTarget const*>& linked);
void FollowLinkDepends(cmGeneratorTarget const* target,
std::set<cmGeneratorTarget const*>& linked);
class TargetSetMap: public std::map<cmTarget*, TargetSet> {};
class TargetSetMap: public std::map<cmGeneratorTarget*, TargetSet> {};
TargetSetMap TargetLinkClosure;
void FillLinkClosure(cmTarget const* target, TargetSet& linked);
TargetSet const& GetTargetLinkClosure(cmTarget* target);
void FillLinkClosure(const cmGeneratorTarget *target,
TargetSet& linked);
TargetSet const& GetTargetLinkClosure(cmGeneratorTarget* target);
};
class cmGlobalVisualStudioGenerator::OrderedTargetDependSet:

404
Source/cmGlobalXCodeGenerator.cxx
View File

File diff suppressed because it is too large Load Diff

43
Source/cmGlobalXCodeGenerator.h
View File

@ -16,7 +16,6 @@
#include "cmXCodeObject.h"
#include "cmCustomCommand.h"
class cmGlobalGeneratorFactory;
class cmTarget;
class cmSourceFile;
class cmSourceGroup;
@ -90,7 +89,7 @@ protected:
virtual void AddExtraIDETargets();
virtual void Generate();
private:
cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
cmXCodeObject* CreateOrGetPBXGroup(cmGeneratorTarget* gtgt,
cmSourceGroup* sg);
cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
std::string name);
@ -108,22 +107,22 @@ private:
cmXCodeObject* resourceBuildPhase,
std::vector<cmXCodeObject*> contentBuildPhases,
cmXCodeObject* frameworkBuildPhase,
cmTarget& cmtarget);
cmGeneratorTarget *gtgt);
std::string ComputeInfoPListLocation(cmTarget& target);
std::string ComputeInfoPListLocation(cmGeneratorTarget *target);
void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
cmTarget& target,
cmGeneratorTarget *target,
std::vector<cmCustomCommand>
const & commands,
const char* commandFileName);
void CreateCustomRulesMakefile(const char* makefileBasename,
cmTarget& target,
cmGeneratorTarget* target,
std::vector<cmCustomCommand> const & commands,
const std::string& configName);
cmXCodeObject* FindXCodeTarget(cmTarget const*);
cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget *);
std::string GetOrCreateId(const std::string& name, const std::string& id);
// create cmXCodeObject from these functions so that memory can be managed
@ -132,22 +131,23 @@ private:
cmXCodeObject* CreateObject(cmXCodeObject::Type type);
cmXCodeObject* CreateString(const std::string& s);
cmXCodeObject* CreateObjectReference(cmXCodeObject*);
cmXCodeObject* CreateXCodeTarget(cmTarget& target,
cmXCodeObject* CreateXCodeTarget(cmGeneratorTarget *gtgt,
cmXCodeObject* buildPhases);
void ForceLinkerLanguages();
void ForceLinkerLanguage(cmTarget& cmtarget);
const char* GetTargetLinkFlagsVar(cmTarget const& cmtarget) const;
void ForceLinkerLanguage(cmGeneratorTarget* gtgt);
const char* GetTargetLinkFlagsVar(const cmGeneratorTarget *target) const;
const char* GetTargetFileType(cmGeneratorTarget* target);
const char* GetTargetProductType(cmGeneratorTarget* target);
std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget);
std::string AddConfigurations(cmXCodeObject* target,
cmGeneratorTarget *gtgt);
void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
const char* value);
void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
const char* value,
const std::string& configName);
cmXCodeObject* CreateUtilityTarget(cmTarget& target);
cmXCodeObject* CreateUtilityTarget(cmGeneratorTarget *gtgt);
void AddDependAndLinkInformation(cmXCodeObject* target);
void CreateBuildSettings(cmTarget& target,
void CreateBuildSettings(cmGeneratorTarget *gtgt,
cmXCodeObject* buildSettings,
const std::string& buildType);
std::string ExtractFlag(const char* flag, std::string& flags);
@ -163,18 +163,18 @@ private:
void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath,
cmTarget& cmtarget,
cmGeneratorTarget *target,
const std::string &lang,
cmSourceFile* sf);
cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
cmTarget& cmtarget,
cmGeneratorTarget *target,
const std::string &lang,
cmSourceFile* sf);
cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
cmTarget& cmtarget);
cmGeneratorTarget *target);
cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
cmSourceFile* sf,
cmTarget& cmtarget);
cmGeneratorTarget *gtgt);
bool CreateXCodeTargets(cmLocalGenerator* gen,
std::vector<cmXCodeObject*>&);
bool IsHeaderFile(cmSourceFile*);
@ -187,7 +187,7 @@ private:
std::vector<cmLocalGenerator*>& gens);
cmXCodeObject* CreateBuildPhase(const char* name,
const char* name2,
cmTarget& cmtarget,
cmGeneratorTarget *target,
const std::vector<cmCustomCommand>&);
void CreateReRunCMakeFile(cmLocalGenerator* root,
std::vector<cmLocalGenerator*> const& gens);
@ -226,10 +226,9 @@ private:
void PrintCompilerAdvice(std::ostream&, std::string const&,
const char*) const {}
std::string GetObjectsNormalDirectory(
const std::string &projName,
std::string GetObjectsNormalDirectory(const std::string &projName,
const std::string &configName,
const cmTarget *t) const;
const cmGeneratorTarget *t) const;
void addObject(cmXCodeObject *obj);
std::string PostBuildMakeTarget(std::string const& tName,
@ -251,7 +250,7 @@ private:
std::map<std::string, cmXCodeObject* > GroupNameMap;
std::map<std::string, cmXCodeObject* > TargetGroup;
std::map<std::string, cmXCodeObject* > FileRefs;
std::map<cmTarget const*, cmXCodeObject* > XCodeObjectMap;
std::map<cmGeneratorTarget const*, cmXCodeObject* > XCodeObjectMap;
std::vector<std::string> Architectures;
std::string GeneratorToolset;
};

52
Source/cmGraphVizWriter.cxx
View File

@ -17,7 +17,7 @@
static const char* getShapeForTarget(const cmTarget* target)
static const char* getShapeForTarget(const cmGeneratorTarget* target)
{
if (!target)
{
@ -163,7 +163,7 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
this->CollectTargetsAndLibs();
for(std::map<std::string, const cmTarget*>::const_iterator ptrIt =
for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
this->TargetPtrs.begin();
ptrIt != this->TargetPtrs.end();
++ptrIt)
@ -214,7 +214,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
this->CollectTargetsAndLibs();
for(std::map<std::string, const cmTarget*>::const_iterator ptrIt =
for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
this->TargetPtrs.begin();
ptrIt != this->TargetPtrs.end();
++ptrIt)
@ -268,7 +268,7 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName)
std::set<std::string> insertedConnections;
std::set<std::string> insertedNodes;
for(std::map<std::string, const cmTarget*>::const_iterator ptrIt =
for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
this->TargetPtrs.begin();
ptrIt != this->TargetPtrs.end();
++ptrIt)
@ -308,8 +308,8 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName,
std::set<std::string>& insertedConnections,
cmGeneratedFileStream& str) const
{
std::map<std::string, const cmTarget* >::const_iterator targetPtrIt =
this->TargetPtrs.find(targetName);
std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt
= this->TargetPtrs.find(targetName);
if (targetPtrIt == this->TargetPtrs.end()) // not found at all
{
@ -327,7 +327,7 @@ void cmGraphVizWriter::WriteConnections(const std::string& targetName,
std::string myNodeName = this->TargetNamesNodes.find(targetName)->second;
const cmTarget::LinkLibraryVectorType* ll =
&(targetPtrIt->second->GetOriginalLinkLibraries());
&(targetPtrIt->second->Target->GetOriginalLinkLibraries());
for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
llit != ll->end();
@ -367,8 +367,8 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
std::set<std::string>& insertedConnections,
cmGeneratedFileStream& str) const
{
std::map<std::string, const cmTarget* >::const_iterator targetPtrIt =
this->TargetPtrs.find(targetName);
std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt
= this->TargetPtrs.find(targetName);
if (targetPtrIt == this->TargetPtrs.end()) // not found at all
{
@ -386,8 +386,8 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
std::string myNodeName = this->TargetNamesNodes.find(targetName)->second;
// now search who links against me
for(std::map<std::string, const cmTarget*>::const_iterator dependerIt =
this->TargetPtrs.begin();
for(std::map<std::string, const cmGeneratorTarget*>::const_iterator
dependerIt = this->TargetPtrs.begin();
dependerIt != this->TargetPtrs.end();
++dependerIt)
{
@ -404,7 +404,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
// Now we have a target, check whether it links against targetName.
// If so, draw a connection, and then continue with dependers on that one.
const cmTarget::LinkLibraryVectorType* ll =
&(dependerIt->second->GetOriginalLinkLibraries());
&(dependerIt->second->Target->GetOriginalLinkLibraries());
for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
llit != ll->end();
@ -448,7 +448,7 @@ void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
void cmGraphVizWriter::WriteNode(const std::string& targetName,
const cmTarget* target,
const cmGeneratorTarget* target,
std::set<std::string>& insertedNodes,
cmGeneratedFileStream& str) const
{
@ -488,12 +488,11 @@ int cmGraphVizWriter::CollectAllTargets()
lit != this->LocalGenerators.end();
++ lit )
{
const cmTargets* targets = &((*lit)->GetMakefile()->GetTargets());
for ( cmTargets::const_iterator tit = targets->begin();
tit != targets->end();
++ tit )
std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets();
for ( std::vector<cmGeneratorTarget*>::const_iterator it =
targets.begin(); it != targets.end(); ++it )
{
const char* realTargetName = tit->first.c_str();
const char* realTargetName = (*it)->GetName().c_str();
if(this->IgnoreThisTarget(realTargetName))
{
// Skip ignored targets
@ -503,7 +502,7 @@ int cmGraphVizWriter::CollectAllTargets()
std::ostringstream ostr;
ostr << this->GraphNodePrefix << cnt++;
this->TargetNamesNodes[realTargetName] = ostr.str();
this->TargetPtrs[realTargetName] = &tit->second;
this->TargetPtrs[realTargetName] = *it;
}
}
@ -519,19 +518,18 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt)
lit != this->LocalGenerators.end();
++ lit )
{
const cmTargets* targets = &((*lit)->GetMakefile()->GetTargets());
for ( cmTargets::const_iterator tit = targets->begin();
tit != targets->end();
++ tit )
std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets();
for ( std::vector<cmGeneratorTarget*>::const_iterator it =
targets.begin(); it != targets.end(); ++it )
{
const char* realTargetName = tit->first.c_str();
const char* realTargetName = (*it)->GetName().c_str();
if (this->IgnoreThisTarget(realTargetName))
{
// Skip ignored targets
continue;
}
const cmTarget::LinkLibraryVectorType* ll =
&(tit->second.GetOriginalLinkLibraries());
&((*it)->Target->GetOriginalLinkLibraries());
for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
llit != ll->end();
++ llit )
@ -543,8 +541,8 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt)
continue;
}
std::map<std::string, const cmTarget*>::const_iterator tarIt =
this->TargetPtrs.find(libName);
std::map<std::string, const cmGeneratorTarget*>::const_iterator tarIt
= this->TargetPtrs.find(libName);
if ( tarIt == this->TargetPtrs.end() )
{
std::ostringstream ostr;

7
Source/cmGraphVizWriter.h
View File

@ -14,9 +14,9 @@
#include "cmStandardIncludes.h"
#include "cmLocalGenerator.h"
#include "cmGeneratedFileStream.h"
#include "cmTarget.h"
#include <cmsys/RegularExpression.hxx>
class cmGeneratorTarget;
/** This class implements writing files for graphviz (dot) for graphs
* representing the dependencies between the targets in the project. */
@ -54,7 +54,8 @@ protected:
std::set<std::string>& insertedConnections,
cmGeneratedFileStream& str) const;
void WriteNode(const std::string& targetName, const cmTarget* target,
void WriteNode(const std::string& targetName,
const cmGeneratorTarget* target,
std::set<std::string>& insertedNodes,
cmGeneratedFileStream& str) const;
@ -73,7 +74,7 @@ protected:
const std::vector<cmLocalGenerator*>& LocalGenerators;
std::map<std::string, const cmTarget*> TargetPtrs;
std::map<std::string, const cmGeneratorTarget*> TargetPtrs;
// maps from the actual target names to node names in dot:
std::map<std::string, std::string> TargetNamesNodes;

7
Source/cmInstallTargetGenerator.cxx
View File

@ -76,7 +76,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
if(this->Target->NeedRelinkBeforeInstall(config))
{
fromDirConfig =
this->Target->Target->GetMakefile()->GetCurrentBinaryDirectory();
this->Target->GetLocalGenerator()->GetCurrentBinaryDirectory();
fromDirConfig += cmake::GetCMakeFilesDirectory();
fromDirConfig += "/CMakeRelink.dir/";
}
@ -111,7 +111,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
case cmState::UTILITY:
case cmState::GLOBAL_TARGET:
case cmState::UNKNOWN_LIBRARY:
this->Target->Target->GetMakefile()->IssueMessage(cmake::INTERNAL_ERROR,
this->Target->GetLocalGenerator()->IssueMessage(cmake::INTERNAL_ERROR,
"cmInstallTargetGenerator created with non-installable target.");
return;
}
@ -440,8 +440,7 @@ cmInstallTargetGenerator::GetInstallFilename(cmGeneratorTarget const* target,
void cmInstallTargetGenerator::Compute(cmLocalGenerator* lg)
{
this->Target = lg->GetGlobalGenerator()->GetGeneratorTarget(
lg->GetMakefile()->FindTarget(this->TargetName));
this->Target = lg->FindGeneratorTarget(this->TargetName);
}
//----------------------------------------------------------------------------

58
Source/cmLocalGenerator.cxx
View File

@ -132,15 +132,15 @@ void cmLocalGenerator::TraceDependencies()
this->GlobalGenerator->CreateEvaluationSourceFiles(*ci);
}
// Generate the rule files for each target.
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
if (t->second->GetType() == cmState::INTERFACE_LIBRARY)
if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
t->second->TraceDependencies();
(*t)->TraceDependencies();
}
}
@ -448,9 +448,16 @@ void cmLocalGenerator::GenerateInstallRules()
}
void cmLocalGenerator::AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt)
void cmLocalGenerator::AddGeneratorTarget(cmGeneratorTarget* gt)
{
this->GeneratorTargets[t] = gt;
this->GeneratorTargets.push_back(gt);
}
cmGeneratorTarget* cmLocalGenerator::FindGeneratorTarget(
const std::string& name) const
{
return this->GetGlobalGenerator()->GetGeneratorTarget(
this->Makefile->FindTarget(name));
}
//----------------------------------------------------------------------------
@ -465,12 +472,12 @@ void cmLocalGenerator::ComputeTargetManifest()
}
// Add our targets to the manifest for each configuration.
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
cmGeneratorTarget& target = *t->second;
if (target.GetType() == cmState::INTERFACE_LIBRARY)
cmGeneratorTarget* target = *t;
if (target->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
@ -478,7 +485,7 @@ void cmLocalGenerator::ComputeTargetManifest()
ci != configNames.end(); ++ci)
{
const char* config = ci->c_str();
target.ComputeTargetManifest(config);
target->ComputeTargetManifest(config);
}
}
}
@ -2133,7 +2140,7 @@ void cmLocalGenerator
"has the following visibility properties set for " << lang << ":\n" <<
warnCMP0063 <<
"For compatibility CMake is not honoring them for this target.";
target->Target->GetMakefile()->GetCMakeInstance()
target->GetLocalGenerator()->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
target->GetBacktrace());
}
@ -2503,28 +2510,29 @@ cmLocalGenerator
{
// Convert the old-style install specification from each target to
// an install generator and run it.
cmTargets& tgts = this->Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if (l->second.GetType() == cmState::INTERFACE_LIBRARY)
if ((*l)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
// Include the user-specified pre-install script for this target.
if(const char* preinstall = l->second.GetProperty("PRE_INSTALL_SCRIPT"))
if(const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT"))
{
cmInstallScriptGenerator g(preinstall, false, 0);
g.Generate(os, config, configurationTypes);
}
// Install this target if a destination is given.
if(l->second.GetInstallPath() != "")
if((*l)->Target->GetInstallPath() != "")
{
// Compute the full install destination. Note that converting
// to unix slashes also removes any trailing slash.
// We also skip over the leading slash given by the user.
std::string destination = l->second.GetInstallPath().substr(1);
std::string destination = (*l)->Target->GetInstallPath().substr(1);
cmSystemTools::ConvertToUnixSlashes(destination);
if(destination.empty())
{
@ -2532,7 +2540,7 @@ cmLocalGenerator
}
// Generate the proper install generator for this target type.
switch(l->second.GetType())
switch((*l)->GetType())
{
case cmState::EXECUTABLE:
case cmState::STATIC_LIBRARY:
@ -2540,7 +2548,7 @@ cmLocalGenerator
{
// Use a target install generator.
cmInstallTargetGeneratorLocal
g(this, l->first, destination.c_str(), false);
g(this, (*l)->GetName(), destination.c_str(), false);
g.Generate(os, config, configurationTypes);
}
break;
@ -2551,18 +2559,18 @@ cmLocalGenerator
// to the normal destination and the DLL to the runtime
// destination.
cmInstallTargetGeneratorLocal
g1(this, l->first, destination.c_str(), true);
g1(this, (*l)->GetName(), destination.c_str(), true);
g1.Generate(os, config, configurationTypes);
// We also skip over the leading slash given by the user.
destination = l->second.GetRuntimeInstallPath().substr(1);
destination = (*l)->Target->GetRuntimeInstallPath().substr(1);
cmSystemTools::ConvertToUnixSlashes(destination);
cmInstallTargetGeneratorLocal
g2(this, l->first, destination.c_str(), false);
g2(this, (*l)->GetName(), destination.c_str(), false);
g2.Generate(os, config, configurationTypes);
#else
// Use a target install generator.
cmInstallTargetGeneratorLocal
g(this, l->first, destination.c_str(), false);
g(this, (*l)->GetName(), destination.c_str(), false);
g.Generate(os, config, configurationTypes);
#endif
}
@ -2573,7 +2581,7 @@ cmLocalGenerator
}
// Include the user-specified post-install script for this target.
if(const char* postinstall = l->second.GetProperty("POST_INSTALL_SCRIPT"))
if(const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT"))
{
cmInstallScriptGenerator g(postinstall, false, 0);
g.Generate(os, config, configurationTypes);

7
Source/cmLocalGenerator.h
View File

@ -113,13 +113,14 @@ public:
bool forResponseFile = false,
const std::string& config = "");
const cmGeneratorTargetsType &GetGeneratorTargets() const
const std::vector<cmGeneratorTarget*> &GetGeneratorTargets() const
{
return this->GeneratorTargets;
}
void AddGeneratorTarget(cmTarget* t, cmGeneratorTarget* gt);
void AddGeneratorTarget(cmGeneratorTarget* gt);
cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const;
cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const;
/**
@ -367,7 +368,7 @@ protected:
std::set<std::string> ObjectMaxPathViolations;
std::set<cmGeneratorTarget const*> WarnCMP0063;
cmGeneratorTargetsType GeneratorTargets;
std::vector<cmGeneratorTarget*> GeneratorTargets;
bool EmitUniversalBinaryFlags;

10
Source/cmLocalGhsMultiGenerator.cxx
View File

@ -26,16 +26,16 @@ cmLocalGhsMultiGenerator::~cmLocalGhsMultiGenerator() {}
void cmLocalGhsMultiGenerator::Generate()
{
cmGeneratorTargetsType tgts = this->GetGeneratorTargets();
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for (cmGeneratorTargetsType::iterator l = tgts.begin(); l != tgts.end();
++l)
for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if (l->second->GetType() == cmState::INTERFACE_LIBRARY)
if ((*l)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
cmGhsMultiTargetGenerator tg(l->second);
cmGhsMultiTargetGenerator tg(*l);
tg.Generate();
}
}

20
Source/cmLocalNinjaGenerator.cxx
View File

@ -73,23 +73,23 @@ void cmLocalNinjaGenerator::Generate()
}
}
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator t = targets.begin();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
if (t->second->GetType() == cmState::INTERFACE_LIBRARY)
if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(t->second);
cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(*t);
if(tg)
{
tg->Generate();
// Add the target to "all" if required.
if (!this->GetGlobalNinjaGenerator()->IsExcluded(
this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0],
t->second))
this->GetGlobalNinjaGenerator()->AddDependencyToAll(t->second->Target);
*t))
this->GetGlobalNinjaGenerator()->AddDependencyToAll(*t);
delete tg;
}
}
@ -285,14 +285,14 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
void
cmLocalNinjaGenerator
::AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs)
::AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs)
{
this->GetGlobalNinjaGenerator()->AppendTargetOutputs(target, outputs);
}
void
cmLocalNinjaGenerator
::AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs)
::AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs)
{
this->GetGlobalNinjaGenerator()->AppendTargetDepends(target, outputs);
}
@ -441,7 +441,7 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
}
void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc,
cmTarget* target)
cmGeneratorTarget* target)
{
this->CustomCommandTargets[cc].insert(target);
}
@ -459,7 +459,7 @@ void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements()
//
// FIXME: This won't work in certain obscure scenarios involving indirect
// dependencies.
std::set<cmTarget*>::iterator j = i->second.begin();
std::set<cmGeneratorTarget*>::iterator j = i->second.begin();
assert(j != i->second.end());
std::vector<std::string> ccTargetDeps;
this->AppendTargetDepends(*j, ccTargetDeps);

9
Source/cmLocalNinjaGenerator.h
View File

@ -58,10 +58,11 @@ public:
std::string BuildCommandLine(const std::vector<std::string> &cmdLines);
void AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs);
void AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs);
void AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs);
void AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs);
void AddCustomCommandTarget(cmCustomCommand const* cc, cmTarget* target);
void AddCustomCommandTarget(cmCustomCommand const* cc,
cmGeneratorTarget* target);
void AppendCustomCommandLines(cmCustomCommandGenerator const& ccg,
std::vector<std::string> &cmdLines);
void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg,
@ -102,7 +103,7 @@ private:
std::string HomeRelativeOutputPath;
typedef std::map<cmCustomCommand const*, std::set<cmTarget*> >
typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*> >
CustomCommandTargetMap;
CustomCommandTargetMap CustomCommandTargets;
};

93
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -113,18 +113,18 @@ void cmLocalUnixMakefileGenerator3::Generate()
this->Makefile->IsOn("CMAKE_SKIP_ASSEMBLY_SOURCE_RULES");
// Generate the rule files for each target.
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
cmGlobalUnixMakefileGenerator3* gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
for(cmGeneratorTargetsType::iterator t = targets.begin();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
if (t->second->GetType() == cmState::INTERFACE_LIBRARY)
if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
cmMakefileTargetGenerator::New(t->second));
cmMakefileTargetGenerator::New(*t));
if (tg.get())
{
tg->WriteRuleFiles();
@ -174,11 +174,11 @@ void cmLocalUnixMakefileGenerator3::
GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
{
std::set<std::string> emitted;
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
for(cmGeneratorTargetsType::iterator ti = targets.begin();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
ti != targets.end(); ++ti)
{
cmGeneratorTarget* gt = ti->second;
cmGeneratorTarget* gt = *ti;
if (gt->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
@ -188,7 +188,7 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
->GetSafeDefinition("CMAKE_BUILD_TYPE"));
// Compute full path to object file directory for this target.
std::string dir;
dir += gt->Makefile->GetCurrentBinaryDirectory();
dir += gt->LocalGenerator->GetCurrentBinaryDirectory();
dir += "/";
dir += this->GetTargetDirectory(gt);
dir += "/";
@ -417,22 +417,22 @@ void cmLocalUnixMakefileGenerator3
// for each target we just provide a rule to cd up to the top and do a make
// on the target
cmGeneratorTargetsType targets = this->GetGeneratorTargets();
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
std::string localName;
for(cmGeneratorTargetsType::iterator t = targets.begin();
for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
t != targets.end(); ++t)
{
if((t->second->GetType() == cmState::EXECUTABLE) ||
(t->second->GetType() == cmState::STATIC_LIBRARY) ||
(t->second->GetType() == cmState::SHARED_LIBRARY) ||
(t->second->GetType() == cmState::MODULE_LIBRARY) ||
(t->second->GetType() == cmState::OBJECT_LIBRARY) ||
(t->second->GetType() == cmState::UTILITY))
if(((*t)->GetType() == cmState::EXECUTABLE) ||
((*t)->GetType() == cmState::STATIC_LIBRARY) ||
((*t)->GetType() == cmState::SHARED_LIBRARY) ||
((*t)->GetType() == cmState::MODULE_LIBRARY) ||
((*t)->GetType() == cmState::OBJECT_LIBRARY) ||
((*t)->GetType() == cmState::UTILITY))
{
emitted.insert(t->second->GetName());
emitted.insert((*t)->GetName());
// for subdirs add a rule to build this specific target by name.
localName = this->GetRelativeTargetDirectory(t->second);
localName = this->GetRelativeTargetDirectory(*t);
localName += "/rule";
commands.clear();
depends.clear();
@ -449,23 +449,23 @@ void cmLocalUnixMakefileGenerator3
localName, depends, commands, true);
// Add a target with the canonical name (no prefix, suffix or path).
if(localName != t->second->GetName())
if(localName != (*t)->GetName())
{
commands.clear();
depends.push_back(localName);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
t->second->GetName(), depends, commands, true);
(*t)->GetName(), depends, commands, true);
}
// Add a fast rule to build the target
std::string makefileName =
this->GetRelativeTargetDirectory(t->second);
this->GetRelativeTargetDirectory(*t);
makefileName += "/build.make";
// make sure the makefile name is suitable for a makefile
std::string makeTargetName =
this->GetRelativeTargetDirectory(t->second);
this->GetRelativeTargetDirectory(*t);
makeTargetName += "/build";
localName = t->second->GetName();
localName = (*t)->GetName();
localName += "/fast";
depends.clear();
commands.clear();
@ -479,11 +479,11 @@ void cmLocalUnixMakefileGenerator3
// Add a local name for the rule to relink the target before
// installation.
if(t->second->NeedRelinkBeforeInstall(this->ConfigName))
if((*t)->NeedRelinkBeforeInstall(this->ConfigName))
{
makeTargetName = this->GetRelativeTargetDirectory(t->second);
makeTargetName = this->GetRelativeTargetDirectory(*t);
makeTargetName += "/preinstall";
localName = t->second->GetName();
localName = (*t)->GetName();
localName += "/preinstall";
depends.clear();
commands.clear();
@ -1762,43 +1762,43 @@ void cmLocalUnixMakefileGenerator3
ruleFileStream
<< "# Targets provided globally by CMake.\n"
<< "\n";
cmTargets* targets = &(this->Makefile->GetTargets());
cmTargets::iterator glIt;
for ( glIt = targets->begin(); glIt != targets->end(); ++ glIt )
std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
std::vector<cmGeneratorTarget*>::iterator glIt;
for ( glIt = targets.begin(); glIt != targets.end(); ++ glIt )
{
if ( glIt->second.GetType() == cmState::GLOBAL_TARGET )
if ( (*glIt)->GetType() == cmState::GLOBAL_TARGET )
{
std::string targetString = "Special rule for the target " + glIt->first;
std::string targetString = "Special rule for the target " +
(*glIt)->GetName();
std::vector<std::string> commands;
std::vector<std::string> depends;
const char* text = glIt->second.GetProperty("EchoString");
const char* text = (*glIt)->GetProperty("EchoString");
if ( !text )
{
text = "Running external command ...";
}
depends.insert(depends.end(), glIt->second.GetUtilities().begin(),
glIt->second.GetUtilities().end());
depends.insert(depends.end(), (*glIt)->Target->GetUtilities().begin(),
(*glIt)->Target->GetUtilities().end());
this->AppendEcho(commands, text,
cmLocalUnixMakefileGenerator3::EchoGlobal);
cmGeneratorTarget* gt = this->GlobalGenerator
->GetGeneratorTarget(&glIt->second);
cmGeneratorTarget* gt = *glIt;
// Global targets store their rules in pre- and post-build commands.
this->AppendCustomDepends(depends,
glIt->second.GetPreBuildCommands());
gt->Target->GetPreBuildCommands());
this->AppendCustomDepends(depends,
glIt->second.GetPostBuildCommands());
gt->Target->GetPostBuildCommands());
this->AppendCustomCommands(commands,
glIt->second.GetPreBuildCommands(),
gt->Target->GetPreBuildCommands(),
gt,
cmLocalGenerator::START_OUTPUT);
this->AppendCustomCommands(commands,
glIt->second.GetPostBuildCommands(),
gt->Target->GetPostBuildCommands(),
gt,
cmLocalGenerator::START_OUTPUT);
std::string targetName = glIt->second.GetName();
std::string targetName = gt->GetName();
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
targetName, depends, commands, true);
@ -1977,7 +1977,7 @@ void cmLocalUnixMakefileGenerator3
cmGeneratorTarget* target)
{
ImplicitDependLanguageMap const& implicitLangs =
this->GetImplicitDepends(*target->Target);
this->GetImplicitDepends(target);
// list the languages
cmakefileStream
@ -2292,19 +2292,20 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const&
cmLocalUnixMakefileGenerator3::GetImplicitDepends(cmTarget const& tgt)
cmLocalUnixMakefileGenerator3::GetImplicitDepends(
const cmGeneratorTarget* tgt)
{
return this->ImplicitDepends[tgt.GetName()];
return this->ImplicitDepends[tgt->GetName()];
}
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3::AddImplicitDepends(cmTarget const& tgt,
cmLocalUnixMakefileGenerator3::AddImplicitDepends(const cmGeneratorTarget* tgt,
const std::string& lang,
const char* obj,
const char* src)
{
this->ImplicitDepends[tgt.GetName()][lang][obj].push_back(src);
this->ImplicitDepends[tgt->GetName()][lang][obj].push_back(src);
}
//----------------------------------------------------------------------------

13
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -21,7 +21,6 @@ class cmCustomCommand;
class cmCustomCommandGenerator;
class cmDepends;
class cmMakefileTargetGenerator;
class cmTarget;
class cmSourceFile;
/** \class cmLocalUnixMakefileGenerator3
@ -141,9 +140,11 @@ public:
public std::map<std::string, ImplicitDependFileMap> {};
struct ImplicitDependTargetMap:
public std::map<std::string, ImplicitDependLanguageMap> {};
ImplicitDependLanguageMap const& GetImplicitDepends(cmTarget const& tgt);
ImplicitDependLanguageMap const&
GetImplicitDepends(cmGeneratorTarget const* tgt);
void AddImplicitDepends(cmTarget const& tgt, const std::string& lang,
void AddImplicitDepends(cmGeneratorTarget const* tgt,
const std::string& lang,
const char* obj, const char* src);
// write the target rules for the local Makefile into the stream
@ -197,12 +198,12 @@ protected:
const std::string& helpTarget);
void WriteTargetDependRule(std::ostream& ruleFileStream,
cmTarget& target);
cmGeneratorTarget* target);
void WriteTargetCleanRule(std::ostream& ruleFileStream,
cmTarget& target,
cmGeneratorTarget* target,
const std::vector<std::string>& files);
void WriteTargetRequiresRule(std::ostream& ruleFileStream,
cmTarget& target,
cmGeneratorTarget* target,
const std::vector<std::string>& objects);
void AppendRuleDepend(std::vector<std::string>& depends,

13
Source/cmLocalVisualStudio10Generator.cxx
View File

@ -74,22 +74,23 @@ cmLocalVisualStudio10Generator::~cmLocalVisualStudio10Generator()
void cmLocalVisualStudio10Generator::Generate()
{
cmTargets &tgts = this->Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if(l->second.GetType() == cmState::INTERFACE_LIBRARY)
if((*l)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
->TargetIsFortranOnly(l->second))
->TargetIsFortranOnly(*l))
{
this->CreateSingleVCProj(l->first.c_str(),l->second);
this->CreateSingleVCProj((*l)->GetName().c_str(), *l);
}
else
{
cmVisualStudio10TargetGenerator tg(
&l->second, static_cast<cmGlobalVisualStudio10Generator*>(
*l, static_cast<cmGlobalVisualStudio10Generator*>(
this->GetGlobalGenerator()));
tg.Generate();
}

333
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -82,12 +82,12 @@ private:
void cmLocalVisualStudio6Generator::AddCMakeListsRules()
{
cmTargets &tgts = this->Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++)
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if (l->second.GetType() == cmState::INTERFACE_LIBRARY
|| l->second.GetType() == cmState::GLOBAL_TARGET)
if ((*l)->GetType() == cmState::INTERFACE_LIBRARY
|| (*l)->GetType() == cmState::GLOBAL_TARGET)
{
continue;
}
@ -98,7 +98,7 @@ void cmLocalVisualStudio6Generator::AddCMakeListsRules()
this->Makefile->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
if (!cmSystemTools::IsOn(suppRegenRule))
{
this->AddDSPBuildRule(l->second);
this->AddDSPBuildRule(*l);
}
}
}
@ -124,54 +124,56 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
// Create the DSP or set of DSP's for libraries and executables
cmTargets &tgts = this->Makefile->GetTargets();
// build any targets
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++)
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
switch(l->second.GetType())
switch((*l)->GetType())
{
case cmState::STATIC_LIBRARY:
case cmState::OBJECT_LIBRARY:
this->SetBuildType(STATIC_LIBRARY, l->first.c_str(), l->second);
this->SetBuildType(STATIC_LIBRARY,
(*l)->GetName().c_str(), *l);
break;
case cmState::SHARED_LIBRARY:
case cmState::MODULE_LIBRARY:
this->SetBuildType(DLL, l->first.c_str(), l->second);
this->SetBuildType(DLL,
(*l)->GetName().c_str(), *l);
break;
case cmState::EXECUTABLE:
this->SetBuildType(EXECUTABLE,l->first.c_str(), l->second);
this->SetBuildType(EXECUTABLE,
(*l)->GetName().c_str(), *l);
break;
case cmState::UTILITY:
case cmState::GLOBAL_TARGET:
this->SetBuildType(UTILITY, l->first.c_str(), l->second);
this->SetBuildType(UTILITY,
(*l)->GetName().c_str(), *l);
break;
case cmState::INTERFACE_LIBRARY:
continue;
default:
cmSystemTools::Error("Bad target type: ", l->first.c_str());
cmSystemTools::Error("Bad target type: ", (*l)->GetName().c_str());
break;
}
// INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
// so don't build a projectfile for it
const char* path =
l->second.GetProperty("EXTERNAL_MSPROJECT");
(*l)->GetProperty("EXTERNAL_MSPROJECT");
if(!path)
{
// check to see if the dsp is going into a sub-directory
std::string::size_type pos = l->first.rfind('/');
std::string::size_type pos = (*l)->GetName().rfind('/');
if(pos != std::string::npos)
{
std::string dir = this->GetCurrentBinaryDirectory();
dir += "/";
dir += l->first.substr(0, pos);
dir += (*l)->GetName().substr(0, pos);
if(!cmSystemTools::MakeDirectory(dir.c_str()))
{
cmSystemTools::Error("Error creating directory: ", dir.c_str());
}
}
this->CreateSingleDSP(l->first.c_str(),l->second);
this->CreateSingleDSP((*l)->GetName().c_str(), *l);
}
}
}
@ -182,7 +184,7 @@ void cmLocalVisualStudio6Generator::OutputDSPFile()
extern std::string GetVS6TargetName(const std::string& targetName);
void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname,
cmTarget &target)
cmGeneratorTarget* target)
{
// add to the list of projects
std::string pname = GetVS6TargetName(lname);
@ -209,9 +211,9 @@ void cmLocalVisualStudio6Generator::CreateSingleDSP(const std::string& lname,
}
void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmGeneratorTarget *tgt)
{
std::string dspname = GetVS6TargetName(tgt.GetName());
std::string dspname = GetVS6TargetName(tgt->GetName());
dspname += ".dsp.cmake";
cmCustomCommandLine commandLine;
commandLine.push_back(cmSystemTools::GetCMakeCommand());
@ -243,8 +245,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
no_working_directory, true);
if(this->Makefile->GetSource(makefileIn.c_str()))
{
cmGeneratorTarget* gt = this->GlobalGenerator->GetGeneratorTarget(&tgt);
gt->AddSource(makefileIn);
tgt->AddSource(makefileIn);
}
else
{
@ -255,7 +256,7 @@ void cmLocalVisualStudio6Generator::AddDSPBuildRule(cmTarget& tgt)
void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
const std::string& libName,
cmTarget &target)
cmGeneratorTarget *target)
{
// For utility targets need custom command since pre- and post-
// build does not do anything in Visual Studio 6. In order for the
@ -263,23 +264,23 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
// special care for dependencies. The first rule must depend on all
// the dependencies of all the rules. The later rules must each
// depend only on the previous rule.
if ((target.GetType() == cmState::UTILITY ||
target.GetType() == cmState::GLOBAL_TARGET) &&
(!target.GetPreBuildCommands().empty() ||
!target.GetPostBuildCommands().empty()))
if ((target->GetType() == cmState::UTILITY ||
target->GetType() == cmState::GLOBAL_TARGET) &&
(!target->Target->GetPreBuildCommands().empty() ||
!target->Target->GetPostBuildCommands().empty()))
{
// Accumulate the dependencies of all the commands.
std::vector<std::string> depends;
for (std::vector<cmCustomCommand>::const_iterator cr =
target.GetPreBuildCommands().begin();
cr != target.GetPreBuildCommands().end(); ++cr)
target->Target->GetPreBuildCommands().begin();
cr != target->Target->GetPreBuildCommands().end(); ++cr)
{
depends.insert(depends.end(),
cr->GetDepends().begin(), cr->GetDepends().end());
}
for (std::vector<cmCustomCommand>::const_iterator cr =
target.GetPostBuildCommands().begin();
cr != target.GetPostBuildCommands().end(); ++cr)
target->Target->GetPostBuildCommands().begin();
cr != target->Target->GetPostBuildCommands().end(); ++cr)
{
depends.insert(depends.end(),
cr->GetDepends().begin(), cr->GetDepends().end());
@ -288,14 +289,14 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
// Add the pre- and post-build commands in order.
int count = 1;
for (std::vector<cmCustomCommand>::const_iterator cr =
target.GetPreBuildCommands().begin();
cr != target.GetPreBuildCommands().end(); ++cr)
target->Target->GetPreBuildCommands().begin();
cr != target->Target->GetPreBuildCommands().end(); ++cr)
{
this->AddUtilityCommandHack(target, count++, depends, *cr);
}
for (std::vector<cmCustomCommand>::const_iterator cr =
target.GetPostBuildCommands().begin();
cr != target.GetPostBuildCommands().end(); ++cr)
target->Target->GetPostBuildCommands().begin();
cr != target->Target->GetPostBuildCommands().end(); ++cr)
{
this->AddUtilityCommandHack(target, count++, depends, *cr);
}
@ -304,12 +305,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
// We may be modifying the source groups temporarily, so make a copy.
std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
// get the classes from the source lists then add them to the groups
std::vector<cmSourceFile*> classes;
if (!gt->GetConfigCommonSourceFiles(classes))
if (!target->GetConfigCommonSourceFiles(classes))
{
return;
}
@ -373,11 +371,9 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
}
void cmLocalVisualStudio6Generator
::WriteGroup(const cmSourceGroup *sg, cmTarget& target,
::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
std::ostream &fout, const std::string& libName)
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
const std::vector<const cmSourceFile *> &sourceFiles =
sg->GetSourceFiles();
// If the group is empty, don't write it at all.
@ -409,9 +405,10 @@ void cmLocalVisualStudio6Generator
std::string compileFlags;
std::vector<std::string> depends;
std::string objectNameDir;
if(gt->HasExplicitObjectName(*sf))
if(target->HasExplicitObjectName(*sf))
{
objectNameDir = cmSystemTools::GetFilenamePath(gt->GetObjectName(*sf));
objectNameDir =
cmSystemTools::GetFilenamePath(target->GetObjectName(*sf));
}
// Add per-source file flags.
@ -482,8 +479,8 @@ void cmLocalVisualStudio6Generator
cmSystemTools::ExpandListArgument(dependsValue, depends);
}
if (GetVS6TargetName(source) != libName ||
target.GetType() == cmState::UTILITY ||
target.GetType() == cmState::GLOBAL_TARGET)
target->GetType() == cmState::UTILITY ||
target->GetType() == cmState::GLOBAL_TARGET)
{
fout << "# Begin Source File\n\n";
@ -573,15 +570,15 @@ void cmLocalVisualStudio6Generator
void
cmLocalVisualStudio6Generator
::AddUtilityCommandHack(cmTarget& target, int count,
::AddUtilityCommandHack(cmGeneratorTarget *target, int count,
std::vector<std::string>& depends,
const cmCustomCommand& origCommand)
{
// Create a fake output that forces the rule to run.
char* output = new char[(strlen(this->GetCurrentBinaryDirectory())
+ target.GetName().size() + 30)];
+ target->GetName().size() + 30)];
sprintf(output,"%s/%s_force_%i", this->GetCurrentBinaryDirectory(),
target.GetName().c_str(), count);
target->GetName().c_str(), count);
const char* comment = origCommand.GetComment();
if(!comment && origCommand.GetOutputs().empty())
{
@ -596,8 +593,7 @@ cmLocalVisualStudio6Generator
origCommand.GetCommandLines(), comment,
origCommand.GetWorkingDirectory().c_str()))
{
cmGeneratorTarget* gt = this->GlobalGenerator->GetGeneratorTarget(&target);
gt->AddSource(outsf->GetFullPath());
target->AddSource(outsf->GetFullPath());
}
// Replace the dependencies with the output of this rule so that the
@ -713,7 +709,7 @@ void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout)
void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
const std::string& libName,
cmTarget& target)
cmGeneratorTarget *target)
{
std::string root= this->Makefile->GetRequiredDefinition("CMAKE_ROOT");
const char *def=
@ -745,7 +741,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
this->DSPFooterTemplate += "/DLLFooter.dsptemplate";
break;
case EXECUTABLE:
if ( target.GetPropertyAsBool("WIN32_EXECUTABLE") )
if ( target->GetPropertyAsBool("WIN32_EXECUTABLE") )
{
this->DSPHeaderTemplate = root;
this->DSPHeaderTemplate += "/EXEWinHeader.dsptemplate";
@ -797,19 +793,16 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
//----------------------------------------------------------------------------
cmsys::auto_ptr<cmCustomCommand>
cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target,
cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmGeneratorTarget* target,
const std::string& config)
{
cmsys::auto_ptr<cmCustomCommand> pcc;
// VS6 forgets to create the output directory for archives if it
// differs from the intermediate directory.
if(target.GetType() != cmState::STATIC_LIBRARY) { return pcc; }
if(target->GetType() != cmState::STATIC_LIBRARY) { return pcc; }
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
std::string outDir = gt->GetDirectory(config, false);
std::string outDir = target->GetDirectory(config, false);
// Add a pre-link event to create the directory.
cmCustomCommandLine command;
@ -831,11 +824,11 @@ cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target,
// look for custom rules on a target and collect them together
std::string
cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
cmLocalVisualStudio6Generator::CreateTargetRules(cmGeneratorTarget *target,
const std::string& configName,
const std::string& /* libName */)
{
if (target.GetType() >= cmState::UTILITY )
if (target->GetType() >= cmState::UTILITY )
{
return "";
}
@ -845,8 +838,8 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
// Write the pre-build and pre-link together (VS6 does not support both).
event.Start("PreLink");
event.Write(target.GetPreBuildCommands());
event.Write(target.GetPreLinkCommands());
event.Write(target->Target->GetPreBuildCommands());
event.Write(target->Target->GetPreLinkCommands());
cmsys::auto_ptr<cmCustomCommand> pcc(
this->MaybeCreateImplibDir(target, configName, false));
if(pcc.get())
@ -862,7 +855,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
// Write the post-build rules.
event.Start("PostBuild");
event.Write(target.GetPostBuildCommands());
event.Write(target->Target->GetPostBuildCommands());
event.Finish();
customRuleCode += "# End Special Build Tool\n";
@ -881,7 +874,8 @@ inline std::string removeQuotes(const std::string& s)
std::string
cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
cmLocalVisualStudio6Generator::GetTargetIncludeOptions(
cmGeneratorTarget *target,
const std::string& config)
{
std::string includeOptions;
@ -892,12 +886,10 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
unsigned int maxIncludeLength = 3000;
bool useShortPath = false;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
for(int j=0; j < 2; ++j)
{
std::vector<std::string> includes;
this->GetIncludeDirectories(includes, gt, "C", config);
this->GetIncludeDirectories(includes, target, "C", config);
std::vector<std::string>::iterator i;
for(i = includes.begin(); i != includes.end(); ++i)
@ -945,11 +937,11 @@ cmLocalVisualStudio6Generator::GetTargetIncludeOptions(cmTarget &target,
void cmLocalVisualStudio6Generator
::WriteDSPHeader(std::ostream& fout,
const std::string& libName, cmTarget &target,
const std::string& libName, cmGeneratorTarget* target,
std::vector<cmSourceGroup> &)
{
bool targetBuilds = (target.GetType() >= cmState::EXECUTABLE &&
target.GetType() <= cmState::MODULE_LIBRARY);
bool targetBuilds = (target->GetType() >= cmState::EXECUTABLE &&
target->GetType() <= cmState::MODULE_LIBRARY);
#ifdef CM_USE_OLD_VS6
// Lookup the library and executable output directories.
std::string libPath;
@ -1059,7 +1051,8 @@ void cmLocalVisualStudio6Generator
}
}
std::vector<std::string>::const_iterator i;
const std::vector<std::string>& libdirs = target.GetLinkDirectories();
const std::vector<std::string>& libdirs =
target->Target->GetLinkDirectories();
for(i = libdirs.begin(); i != libdirs.end(); ++i)
{
std::string path = *i;
@ -1101,19 +1094,19 @@ void cmLocalVisualStudio6Generator
}
// find link libraries
const cmTarget::LinkLibraryVectorType& libs =
target.GetLinkLibrariesForVS6();
target->Target->GetLinkLibrariesForVS6();
cmTarget::LinkLibraryVectorType::const_iterator j;
for(j = libs.begin(); j != libs.end(); ++j)
{
// add libraries to executables and dlls (but never include
// a library in a library, bad recursion)
// NEVER LINK STATIC LIBRARIES TO OTHER STATIC LIBRARIES
if ((target.GetType() != cmState::SHARED_LIBRARY
&& target.GetType() != cmState::STATIC_LIBRARY
&& target.GetType() != cmState::MODULE_LIBRARY) ||
(target.GetType()==cmState::SHARED_LIBRARY
if ((target->GetType() != cmState::SHARED_LIBRARY
&& target->GetType() != cmState::STATIC_LIBRARY
&& target->GetType() != cmState::MODULE_LIBRARY) ||
(target->GetType()==cmState::SHARED_LIBRARY
&& libName != GetVS6TargetName(j->first)) ||
(target.GetType()==cmState::MODULE_LIBRARY
(target->GetType()==cmState::MODULE_LIBRARY
&& libName != GetVS6TargetName(j->first)))
{
// Compute the proper name to use to link this library.
@ -1195,7 +1188,7 @@ void cmLocalVisualStudio6Generator
std::string extraLinkOptionsRelease;
std::string extraLinkOptionsMinSizeRel;
std::string extraLinkOptionsRelWithDebInfo;
if(target.GetType() == cmState::EXECUTABLE)
if(target->GetType() == cmState::EXECUTABLE)
{
extraLinkOptions = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
@ -1208,7 +1201,7 @@ void cmLocalVisualStudio6Generator
extraLinkOptionsRelWithDebInfo = this->Makefile->
GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO");
}
if(target.GetType() == cmState::SHARED_LIBRARY)
if(target->GetType() == cmState::SHARED_LIBRARY)
{
extraLinkOptions = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
@ -1221,7 +1214,7 @@ void cmLocalVisualStudio6Generator
extraLinkOptionsRelWithDebInfo = this->Makefile->
GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO");
}
if(target.GetType() == cmState::MODULE_LIBRARY)
if(target->GetType() == cmState::MODULE_LIBRARY)
{
extraLinkOptions = this->Makefile->
GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
@ -1236,63 +1229,61 @@ void cmLocalVisualStudio6Generator
}
// Get extra linker options for this target.
if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS"))
if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS"))
{
extraLinkOptions += " ";
extraLinkOptions += targetLinkFlags;
}
if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_DEBUG"))
if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_DEBUG"))
{
extraLinkOptionsDebug += " ";
extraLinkOptionsDebug += targetLinkFlags;
}
if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_RELEASE"))
if(const char* targetLinkFlags = target->GetProperty("LINK_FLAGS_RELEASE"))
{
extraLinkOptionsRelease += " ";
extraLinkOptionsRelease += targetLinkFlags;
}
if(const char* targetLinkFlags = target.GetProperty("LINK_FLAGS_MINSIZEREL"))
if(const char* targetLinkFlags =
target->GetProperty("LINK_FLAGS_MINSIZEREL"))
{
extraLinkOptionsMinSizeRel += " ";
extraLinkOptionsMinSizeRel += targetLinkFlags;
}
if(const char* targetLinkFlags =
target.GetProperty("LINK_FLAGS_RELWITHDEBINFO"))
target->GetProperty("LINK_FLAGS_RELWITHDEBINFO"))
{
extraLinkOptionsRelWithDebInfo += " ";
extraLinkOptionsRelWithDebInfo += targetLinkFlags;
}
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
// Get standard libraries for this language.
if(targetBuilds)
{
// Get the language to use for linking.
std::vector<std::string> configs;
target.GetMakefile()->GetConfigurations(configs);
target->Target->GetMakefile()->GetConfigurations(configs);
std::vector<std::string>::const_iterator it = configs.begin();
const std::string& linkLanguage = gt->GetLinkerLanguage(*it);
const std::string& linkLanguage = target->GetLinkerLanguage(*it);
for ( ; it != configs.end(); ++it)
{
const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it);
const std::string& configLinkLanguage = target->GetLinkerLanguage(*it);
if (configLinkLanguage != linkLanguage)
{
cmSystemTools::Error
("Linker language must not vary by configuration for target: ",
target.GetName().c_str());
target->GetName().c_str());
}
}
if(linkLanguage.empty())
{
cmSystemTools::Error
("CMake can not determine linker language for target: ",
target.GetName().c_str());
target->GetName().c_str());
return;
}
@ -1313,13 +1304,13 @@ void cmLocalVisualStudio6Generator
// Compute version number information.
std::string targetVersionFlag;
if(target.GetType() == cmState::EXECUTABLE ||
target.GetType() == cmState::SHARED_LIBRARY ||
target.GetType() == cmState::MODULE_LIBRARY)
if(target->GetType() == cmState::EXECUTABLE ||
target->GetType() == cmState::SHARED_LIBRARY ||
target->GetType() == cmState::MODULE_LIBRARY)
{
int major;
int minor;
gt->GetTargetVersion(major, minor);
target->GetTargetVersion(major, minor);
std::ostringstream targetVersionStream;
targetVersionStream << "/version:" << major << "." << minor;
targetVersionFlag = targetVersionStream.str();
@ -1332,20 +1323,20 @@ void cmLocalVisualStudio6Generator
std::string outputNameRelease = outputName;
std::string outputNameMinSizeRel = outputName;
std::string outputNameRelWithDebInfo = outputName;
if(target.GetType() == cmState::EXECUTABLE ||
target.GetType() == cmState::STATIC_LIBRARY ||
target.GetType() == cmState::SHARED_LIBRARY ||
target.GetType() == cmState::MODULE_LIBRARY)
if(target->GetType() == cmState::EXECUTABLE ||
target->GetType() == cmState::STATIC_LIBRARY ||
target->GetType() == cmState::SHARED_LIBRARY ||
target->GetType() == cmState::MODULE_LIBRARY)
{
outputName = gt->GetFullName();
outputNameDebug = gt->GetFullName("Debug");
outputNameRelease = gt->GetFullName("Release");
outputNameMinSizeRel = gt->GetFullName("MinSizeRel");
outputNameRelWithDebInfo = gt->GetFullName("RelWithDebInfo");
outputName = target->GetFullName();
outputNameDebug = target->GetFullName("Debug");
outputNameRelease = target->GetFullName("Release");
outputNameMinSizeRel = target->GetFullName("MinSizeRel");
outputNameRelWithDebInfo = target->GetFullName("RelWithDebInfo");
}
else if(target.GetType() == cmState::OBJECT_LIBRARY)
else if(target->GetType() == cmState::OBJECT_LIBRARY)
{
outputName = target.GetName();
outputName = target->GetName();
outputName += ".lib";
outputNameDebug = outputName;
outputNameRelease = outputName;
@ -1359,30 +1350,30 @@ void cmLocalVisualStudio6Generator
std::string outputDirRelease;
std::string outputDirMinSizeRel;
std::string outputDirRelWithDebInfo;
if(target.GetType() == cmState::EXECUTABLE ||
target.GetType() == cmState::STATIC_LIBRARY ||
target.GetType() == cmState::SHARED_LIBRARY ||
target.GetType() == cmState::MODULE_LIBRARY)
if(target->GetType() == cmState::EXECUTABLE ||
target->GetType() == cmState::STATIC_LIBRARY ||
target->GetType() == cmState::SHARED_LIBRARY ||
target->GetType() == cmState::MODULE_LIBRARY)
{
#ifdef CM_USE_OLD_VS6
outputDirOld =
removeQuotes(this->ConvertToOutputFormat
(gt->GetDirectory().c_str(), SHELL));
(target->GetDirectory().c_str(), SHELL));
#endif
outputDirDebug =
removeQuotes(this->ConvertToOutputFormat(
gt->GetDirectory("Debug").c_str(), SHELL));
target->GetDirectory("Debug").c_str(), SHELL));
outputDirRelease =
removeQuotes(this->ConvertToOutputFormat(
gt->GetDirectory("Release").c_str(), SHELL));
target->GetDirectory("Release").c_str(), SHELL));
outputDirMinSizeRel =
removeQuotes(this->ConvertToOutputFormat(
gt->GetDirectory("MinSizeRel").c_str(), SHELL));
target->GetDirectory("MinSizeRel").c_str(), SHELL));
outputDirRelWithDebInfo =
removeQuotes(this->ConvertToOutputFormat(
gt->GetDirectory("RelWithDebInfo").c_str(), SHELL));
target->GetDirectory("RelWithDebInfo").c_str(), SHELL));
}
else if(target.GetType() == cmState::OBJECT_LIBRARY)
else if(target->GetType() == cmState::OBJECT_LIBRARY)
{
std::string outputDir = cmake::GetCMakeFilesDirectoryPostSlash();
outputDirDebug = outputDir + "Debug";
@ -1396,9 +1387,9 @@ void cmLocalVisualStudio6Generator
std::string optionsRelease;
std::string optionsMinSizeRel;
std::string optionsRelWithDebInfo;
if(target.GetType() == cmState::EXECUTABLE ||
target.GetType() == cmState::SHARED_LIBRARY ||
target.GetType() == cmState::MODULE_LIBRARY)
if(target->GetType() == cmState::EXECUTABLE ||
target->GetType() == cmState::SHARED_LIBRARY ||
target->GetType() == cmState::MODULE_LIBRARY)
{
extraLinkOptionsDebug =
extraLinkOptions + " " + extraLinkOptionsDebug;
@ -1424,24 +1415,24 @@ void cmLocalVisualStudio6Generator
std::string targetImplibFlagRelease;
std::string targetImplibFlagMinSizeRel;
std::string targetImplibFlagRelWithDebInfo;
if(target.GetType() == cmState::SHARED_LIBRARY ||
target.GetType() == cmState::MODULE_LIBRARY ||
target.GetType() == cmState::EXECUTABLE)
if(target->GetType() == cmState::SHARED_LIBRARY ||
target->GetType() == cmState::MODULE_LIBRARY ||
target->GetType() == cmState::EXECUTABLE)
{
std::string fullPathImpDebug = gt->GetDirectory("Debug", true);
std::string fullPathImpRelease = gt->GetDirectory("Release", true);
std::string fullPathImpDebug = target->GetDirectory("Debug", true);
std::string fullPathImpRelease = target->GetDirectory("Release", true);
std::string fullPathImpMinSizeRel =
gt->GetDirectory("MinSizeRel", true);
target->GetDirectory("MinSizeRel", true);
std::string fullPathImpRelWithDebInfo =
gt->GetDirectory("RelWithDebInfo", true);
target->GetDirectory("RelWithDebInfo", true);
fullPathImpDebug += "/";
fullPathImpRelease += "/";
fullPathImpMinSizeRel += "/";
fullPathImpRelWithDebInfo += "/";
fullPathImpDebug += gt->GetFullName("Debug", true);
fullPathImpRelease += gt->GetFullName("Release", true);
fullPathImpMinSizeRel += gt->GetFullName("MinSizeRel", true);
fullPathImpRelWithDebInfo += gt->GetFullName("RelWithDebInfo", true);
fullPathImpDebug += target->GetFullName("Debug", true);
fullPathImpRelease += target->GetFullName("Release", true);
fullPathImpMinSizeRel += target->GetFullName("MinSizeRel", true);
fullPathImpRelWithDebInfo += target->GetFullName("RelWithDebInfo", true);
targetImplibFlagDebug = "/implib:";
targetImplibFlagRelease = "/implib:";
@ -1494,7 +1485,7 @@ void cmLocalVisualStudio6Generator
std::string staticLibOptionsRelease;
std::string staticLibOptionsMinSizeRel;
std::string staticLibOptionsRelWithDebInfo;
if(target.GetType() == cmState::STATIC_LIBRARY )
if(target->GetType() == cmState::STATIC_LIBRARY )
{
const char *libflagsGlobal =
this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS");
@ -1513,7 +1504,7 @@ void cmLocalVisualStudio6Generator
this->AppendFlags(staticLibOptionsRelWithDebInfo, this->Makefile->
GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO"));
const char *libflags = target.GetProperty("STATIC_LIBRARY_FLAGS");
const char *libflags = target->GetProperty("STATIC_LIBRARY_FLAGS");
this->AppendFlags(staticLibOptions, libflags);
this->AppendFlags(staticLibOptionsDebug, libflags);
this->AppendFlags(staticLibOptionsRelease, libflags);
@ -1521,13 +1512,13 @@ void cmLocalVisualStudio6Generator
this->AppendFlags(staticLibOptionsRelWithDebInfo, libflags);
this->AppendFlags(staticLibOptionsDebug,
target.GetProperty("STATIC_LIBRARY_FLAGS_DEBUG"));
target->GetProperty("STATIC_LIBRARY_FLAGS_DEBUG"));
this->AppendFlags(staticLibOptionsRelease,
target.GetProperty("STATIC_LIBRARY_FLAGS_RELEASE"));
target->GetProperty("STATIC_LIBRARY_FLAGS_RELEASE"));
this->AppendFlags(staticLibOptionsMinSizeRel,
target.GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL"));
target->GetProperty("STATIC_LIBRARY_FLAGS_MINSIZEREL"));
this->AppendFlags(staticLibOptionsRelWithDebInfo,
target.GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO"));
target->GetProperty("STATIC_LIBRARY_FLAGS_RELWITHDEBINFO"));
std::string objects;
this->OutputObjects(target, "LIB", objects);
@ -1543,7 +1534,7 @@ void cmLocalVisualStudio6Generator
// Add the export symbol definition for shared library objects.
std::string exportSymbol;
if(const char* exportMacro = gt->GetExportMacro())
if(const char* exportMacro = target->GetExportMacro())
{
exportSymbol = exportMacro;
}
@ -1567,8 +1558,8 @@ void cmLocalVisualStudio6Generator
libnameExports.c_str());
cmSystemTools::ReplaceString(line, "CMAKE_MFC_FLAG",
mfcFlag);
if(target.GetType() == cmState::STATIC_LIBRARY ||
target.GetType() == cmState::OBJECT_LIBRARY)
if(target->GetType() == cmState::STATIC_LIBRARY ||
target->GetType() == cmState::OBJECT_LIBRARY)
{
cmSystemTools::ReplaceString(line, "CM_STATIC_LIB_ARGS_DEBUG",
staticLibOptionsDebug.c_str());
@ -1674,7 +1665,7 @@ void cmLocalVisualStudio6Generator
(exePath.c_str(), SHELL)).c_str());
#endif
if(targetBuilds || target.GetType() == cmState::OBJECT_LIBRARY)
if(targetBuilds || target->GetType() == cmState::OBJECT_LIBRARY)
{
cmSystemTools::ReplaceString(line, "OUTPUT_DIRECTORY_DEBUG",
outputDirDebug.c_str());
@ -1698,8 +1689,8 @@ void cmLocalVisualStudio6Generator
= this->Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
cmSystemTools::ReplaceString(line, "DEBUG_POSTFIX",
debugPostfix?debugPostfix:"");
if(target.GetType() >= cmState::EXECUTABLE &&
target.GetType() <= cmState::OBJECT_LIBRARY)
if(target->GetType() >= cmState::EXECUTABLE &&
target->GetType() <= cmState::OBJECT_LIBRARY)
{
// store flags for each configuration
std::string flags = " ";
@ -1708,24 +1699,24 @@ void cmLocalVisualStudio6Generator
std::string flagsDebug = " ";
std::string flagsRelWithDebInfo = " ";
std::vector<std::string> configs;
target.GetMakefile()->GetConfigurations(configs);
target->Target->GetMakefile()->GetConfigurations(configs);
std::vector<std::string>::const_iterator it = configs.begin();
const std::string& linkLanguage = gt->GetLinkerLanguage(*it);
const std::string& linkLanguage = target->GetLinkerLanguage(*it);
for ( ; it != configs.end(); ++it)
{
const std::string& configLinkLanguage = gt->GetLinkerLanguage(*it);
const std::string& configLinkLanguage = target->GetLinkerLanguage(*it);
if (configLinkLanguage != linkLanguage)
{
cmSystemTools::Error
("Linker language must not vary by configuration for target: ",
target.GetName().c_str());
target->GetName().c_str());
}
}
if(linkLanguage.empty())
{
cmSystemTools::Error
("CMake can not determine linker language for target: ",
target.GetName().c_str());
target->GetName().c_str());
return;
}
// if CXX is on and the target contains cxx code then add the cxx flags
@ -1750,12 +1741,12 @@ void cmLocalVisualStudio6Generator
flagsRelWithDebInfo = this->Makefile->GetSafeDefinition(flagVar.c_str());
flagsRelWithDebInfo += " -DCMAKE_INTDIR=\\\"RelWithDebInfo\\\" ";
this->AddCompileOptions(flags, gt, linkLanguage, "");
this->AddCompileOptions(flagsDebug, gt, linkLanguage, "Debug");
this->AddCompileOptions(flagsRelease, gt, linkLanguage, "Release");
this->AddCompileOptions(flagsMinSizeRel, gt, linkLanguage,
this->AddCompileOptions(flags, target, linkLanguage, "");
this->AddCompileOptions(flagsDebug, target, linkLanguage, "Debug");
this->AddCompileOptions(flagsRelease, target, linkLanguage, "Release");
this->AddCompileOptions(flagsMinSizeRel, target, linkLanguage,
"MinSizeRel");
this->AddCompileOptions(flagsRelWithDebInfo, gt, linkLanguage,
this->AddCompileOptions(flagsRelWithDebInfo, target, linkLanguage,
"RelWithDebInfo");
// if _UNICODE and _SBCS are not found, then add -D_MBCS
@ -1775,14 +1766,14 @@ void cmLocalVisualStudio6Generator
std::set<std::string> minsizeDefinesSet;
std::set<std::string> debugrelDefinesSet;
this->AddCompileDefinitions(definesSet, gt, "", linkLanguage);
this->AddCompileDefinitions(debugDefinesSet, gt,
this->AddCompileDefinitions(definesSet, target, "", linkLanguage);
this->AddCompileDefinitions(debugDefinesSet, target,
"DEBUG", linkLanguage);
this->AddCompileDefinitions(releaseDefinesSet, gt,
this->AddCompileDefinitions(releaseDefinesSet, target,
"RELEASE", linkLanguage);
this->AddCompileDefinitions(minsizeDefinesSet, gt,
this->AddCompileDefinitions(minsizeDefinesSet, target,
"MINSIZEREL", linkLanguage);
this->AddCompileDefinitions(debugrelDefinesSet, gt,
this->AddCompileDefinitions(debugrelDefinesSet, target,
"RELWITHDEBINFO", linkLanguage);
std::string defines = " ";
@ -1850,15 +1841,13 @@ void cmLocalVisualStudio6Generator::WriteDSPFooter(std::ostream& fout)
//----------------------------------------------------------------------------
void cmLocalVisualStudio6Generator
::ComputeLinkOptions(cmTarget& target,
::ComputeLinkOptions(cmGeneratorTarget *target,
const std::string& configName,
const std::string extraOptions,
std::string& options)
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
// Compute the link information for this configuration.
cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
if(!pcli)
{
return;
@ -1917,15 +1906,13 @@ void cmLocalVisualStudio6Generator
//----------------------------------------------------------------------------
void cmLocalVisualStudio6Generator
::OutputObjects(cmTarget& target, const char* tool,
::OutputObjects(cmGeneratorTarget* target, const char* tool,
std::string& options)
{
// VS 6 does not support per-config source locations so we
// list object library content on the link line instead.
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
std::vector<std::string> objs;
gt->UseObjectLibraries(objs, "");
target->UseObjectLibraries(objs, "");
for(std::vector<std::string>::const_iterator
oi = objs.begin(); oi != objs.end(); ++oi)
{
@ -1948,7 +1935,7 @@ cmLocalVisualStudio6Generator
//----------------------------------------------------------------------------
std::string
cmLocalVisualStudio6Generator
::ComputeLongestObjectDirectory(cmTarget&) const
::ComputeLongestObjectDirectory(cmGeneratorTarget const*) const
{
// Compute the maximum length configuration name.
std::string config_max;

29
Source/cmLocalVisualStudio6Generator.h
View File

@ -14,7 +14,6 @@
#include "cmLocalVisualStudioGenerator.h"
class cmTarget;
class cmSourceFile;
class cmSourceGroup;
class cmCustomCommand;
@ -47,50 +46,52 @@ public:
/**
* Specify the type of the build: static, dll, or executable.
*/
void SetBuildType(BuildType, const std::string& libName, cmTarget&);
void SetBuildType(BuildType, const std::string& libName, cmGeneratorTarget*);
virtual
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
virtual std::string ComputeLongestObjectDirectory(cmTarget&) const;
virtual std::string
ComputeLongestObjectDirectory(cmGeneratorTarget const*) const;
private:
std::string DSPHeaderTemplate;
std::string DSPFooterTemplate;
void CreateSingleDSP(const std::string& lname, cmTarget &tgt);
void CreateSingleDSP(const std::string& lname, cmGeneratorTarget* tgt);
void WriteDSPFile(std::ostream& fout, const std::string& libName,
cmTarget &tgt);
cmGeneratorTarget* tgt);
void WriteDSPBeginGroup(std::ostream& fout,
const char* group,
const char* filter);
void WriteDSPEndGroup(std::ostream& fout);
void WriteDSPHeader(std::ostream& fout, const std::string& libName,
cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
cmGeneratorTarget* tgt, std::vector<cmSourceGroup> &sgs);
void WriteDSPFooter(std::ostream& fout);
void AddDSPBuildRule(cmTarget& tgt);
void AddDSPBuildRule(cmGeneratorTarget* tgt);
void WriteCustomRule(std::ostream& fout,
const char* source,
const cmCustomCommand& command,
const char* flags);
void AddUtilityCommandHack(cmTarget& target, int count,
void AddUtilityCommandHack(cmGeneratorTarget* target, int count,
std::vector<std::string>& depends,
const cmCustomCommand& origCommand);
void WriteGroup(const cmSourceGroup *sg, cmTarget& target,
void WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
std::ostream &fout, const std::string& libName);
class EventWriter;
friend class EventWriter;
cmsys::auto_ptr<cmCustomCommand>
MaybeCreateOutputDir(cmTarget& target, const std::string& config);
std::string CreateTargetRules(cmTarget &target,
MaybeCreateOutputDir(cmGeneratorTarget *target, const std::string& config);
std::string CreateTargetRules(cmGeneratorTarget* target,
const std::string& configName,
const std::string& libName);
void ComputeLinkOptions(cmTarget& target, const std::string& configName,
void ComputeLinkOptions(cmGeneratorTarget* target,
const std::string& configName,
const std::string extraOptions,
std::string& options);
void OutputObjects(cmTarget& target, const char* tool,
void OutputObjects(cmGeneratorTarget* target, const char* tool,
std::string& options);
std::string GetTargetIncludeOptions(cmTarget &target,
std::string GetTargetIncludeOptions(cmGeneratorTarget* target,
const std::string& config);
std::vector<std::string> Configurations;

251
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -34,7 +34,8 @@ public:
LocalGenerator(e) {}
typedef cmComputeLinkInformation::ItemVector ItemVector;
void OutputLibraries(std::ostream& fout, ItemVector const& libs);
void OutputObjects(std::ostream& fout, cmTarget* t, const char* isep = 0);
void OutputObjects(std::ostream& fout, cmGeneratorTarget* t,
const char* isep = 0);
private:
cmLocalVisualStudio7Generator* LocalGenerator;
};
@ -67,19 +68,19 @@ cmLocalVisualStudio7Generator::~cmLocalVisualStudio7Generator()
void cmLocalVisualStudio7Generator::AddHelperCommands()
{
// Now create GUIDs for targets
cmTargets &tgts = this->Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if(l->second.GetType() == cmState::INTERFACE_LIBRARY)
if((*l)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
const char* path = l->second.GetProperty("EXTERNAL_MSPROJECT");
const char* path = (*l)->GetProperty("EXTERNAL_MSPROJECT");
if(path)
{
this->ReadAndStoreExternalGUID(
l->second.GetName().c_str(), path);
(*l)->GetName().c_str(), path);
}
}
@ -95,7 +96,6 @@ void cmLocalVisualStudio7Generator::Generate()
void cmLocalVisualStudio7Generator::AddCMakeListsRules()
{
cmTargets &tgts = this->Makefile->GetTargets();
// Create the regeneration custom rule.
if(!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION"))
{
@ -104,17 +104,17 @@ void cmLocalVisualStudio7Generator::AddCMakeListsRules()
if(cmSourceFile* sf = this->CreateVCProjBuildRule())
{
// Add the rule to targets that need it.
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if (l->second.GetType() == cmState::GLOBAL_TARGET)
if ((*l)->GetType() == cmState::GLOBAL_TARGET)
{
continue;
}
if(l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
if((*l)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&l->second);
gt->AddSource(sf->GetFullPath());
(*l)->AddSource(sf->GetFullPath());
}
}
}
@ -126,12 +126,11 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets()
// Visual Studio .NET 2003 Service Pack 1 will not run post-build
// commands for targets in which no sources are built. Add dummy
// rules to force these targets to build.
cmTargets &tgts = this->Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin();
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); l++)
{
cmTarget& tgt = l->second;
if(tgt.GetType() == cmState::GLOBAL_TARGET)
if((*l)->GetType() == cmState::GLOBAL_TARGET)
{
std::vector<std::string> no_depends;
cmCustomCommandLine force_command;
@ -143,16 +142,14 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets()
std::string force = this->GetCurrentBinaryDirectory();
force += cmake::GetCMakeFilesDirectory();
force += "/";
force += tgt.GetName();
force += (*l)->GetName();
force += "_force";
if(cmSourceFile* file =
this->Makefile->AddCustomCommandToOutput(
force.c_str(), no_depends, no_main_dependency,
force_commands, " ", 0, true))
{
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&tgt);
gt->AddSource(file->GetFullPath());
(*l)->AddSource(file->GetFullPath());
}
}
}
@ -176,21 +173,21 @@ void cmLocalVisualStudio7Generator::WriteProjectFiles()
}
// Get the set of targets in this directory.
cmTargets &tgts = this->Makefile->GetTargets();
std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
// Create the project file for each target.
for(cmTargets::iterator l = tgts.begin();
for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
l != tgts.end(); l++)
{
if(l->second.GetType() == cmState::INTERFACE_LIBRARY)
if((*l)->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
}
// INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
// so don't build a projectfile for it
if(!l->second.GetProperty("EXTERNAL_MSPROJECT"))
if(!(*l)->GetProperty("EXTERNAL_MSPROJECT"))
{
this->CreateSingleVCProj(l->first.c_str(),l->second);
this->CreateSingleVCProj((*l)->GetName().c_str(), *l);
}
}
}
@ -228,7 +225,7 @@ void cmLocalVisualStudio7Generator::WriteStampFiles()
//----------------------------------------------------------------------------
void cmLocalVisualStudio7Generator
::CreateSingleVCProj(const std::string& lname, cmTarget &target)
::CreateSingleVCProj(const std::string& lname, cmGeneratorTarget *target)
{
cmGlobalVisualStudioGenerator* gg
= static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
@ -244,7 +241,7 @@ void cmLocalVisualStudio7Generator
}
// add to the list of projects
target.SetProperty("GENERATOR_FILE_NAME",lname.c_str());
target->Target->SetProperty("GENERATOR_FILE_NAME",lname.c_str());
// create the dsp.cmake file
std::string fname;
fname = this->GetCurrentBinaryDirectory();
@ -327,8 +324,9 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
}
void cmLocalVisualStudio7Generator::WriteConfigurations(
std::ostream& fout, std::vector<std::string> const& configs,
const std::string& libName, cmTarget &target
std::ostream& fout,
std::vector<std::string> const& configs,
const std::string& libName, cmGeneratorTarget *target
)
{
fout << "\t<Configurations>\n";
@ -646,7 +644,7 @@ private:
void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
const std::string& configName,
const std::string& libName,
cmTarget &target)
cmGeneratorTarget *target)
{
const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
if(!mfcFlag)
@ -667,10 +665,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
const char* projectType = 0;
bool targetBuilds = true;
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
switch(target.GetType())
switch(target->GetType())
{
case cmState::OBJECT_LIBRARY:
targetBuilds = false; // no manifest tool for object library
@ -702,12 +697,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
{
const std::string& linkLanguage = (this->FortranProject?
std::string("Fortran"):
gt->GetLinkerLanguage(configName));
target->GetLinkerLanguage(configName));
if(linkLanguage.empty())
{
cmSystemTools::Error
("CMake can not determine linker language for target: ",
target.GetName().c_str());
target->GetName().c_str());
return;
}
if(linkLanguage == "C" || linkLanguage == "CXX"
@ -733,12 +728,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
}
// Add the target-specific flags.
this->AddCompileOptions(flags, gt, linkLanguage, configName);
this->AddCompileOptions(flags, target, linkLanguage, configName);
}
if(this->FortranProject)
{
switch(this->GetFortranFormat(target.GetProperty("Fortran_FORMAT")))
switch(this->GetFortranFormat(target->GetProperty("Fortran_FORMAT")))
{
case FortranFormatFixed: flags += " -fixed"; break;
case FortranFormatFree: flags += " -free"; break;
@ -765,7 +760,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
targetOptions.Parse(defineFlags.c_str());
targetOptions.ParseFinish();
std::vector<std::string> targetDefines;
gt->GetCompileDefinitions(targetDefines, configName, "CXX");
target->GetCompileDefinitions(targetDefines, configName, "CXX");
targetOptions.AddDefines(targetDefines);
targetOptions.SetVerboseMakefile(
this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"));
@ -777,22 +772,22 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
targetOptions.AddDefine(configDefine);
// Add the export symbol definition for shared library objects.
if(const char* exportMacro = gt->GetExportMacro())
if(const char* exportMacro = target->GetExportMacro())
{
targetOptions.AddDefine(exportMacro);
}
// The intermediate directory name consists of a directory for the
// target and a subdirectory for the configuration name.
std::string intermediateDir = this->GetTargetDirectory(gt);
std::string intermediateDir = this->GetTargetDirectory(target);
intermediateDir += "/";
intermediateDir += configName;
if (target.GetType() < cmState::UTILITY)
if (target->Target->GetType() < cmState::UTILITY)
{
std::string const& outDir =
target.GetType() == cmState::OBJECT_LIBRARY?
intermediateDir : gt->GetDirectory(configName);
target->Target->GetType() == cmState::OBJECT_LIBRARY?
intermediateDir : target->GetDirectory(configName);
fout << "\t\t\tOutputDirectory=\""
<< this->ConvertToXMLOutputPathSingle(outDir.c_str()) << "\"\n";
}
@ -807,7 +802,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
if (this->FortranProject)
{
// Intel Fortran >= 15.0 uses TargetName property.
std::string targetNameFull = gt->GetFullName(configName);
std::string targetNameFull = target->GetFullName(configName);
std::string targetName =
cmSystemTools::GetFilenameWithoutLastExtension(targetNameFull);
std::string targetExt =
@ -842,7 +837,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
if(this->FortranProject)
{
const char* target_mod_dir =
target.GetProperty("Fortran_MODULE_DIRECTORY");
target->Target->GetProperty("Fortran_MODULE_DIRECTORY");
std::string modDir;
if(target_mod_dir)
{
@ -861,7 +856,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
targetOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
fout << "\t\t\t\tAdditionalIncludeDirectories=\"";
std::vector<std::string> includes;
this->GetIncludeDirectories(includes, gt, "C", configName);
this->GetIncludeDirectories(includes, target, "C", configName);
std::vector<std::string>::iterator i = includes.begin();
for(;i != includes.end(); ++i)
{
@ -882,10 +877,10 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
targetOptions.OutputFlagMap(fout, "\t\t\t\t");
targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n", "CXX");
fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n";
if(target.GetType() <= cmState::OBJECT_LIBRARY)
if(target->Target->GetType() <= cmState::OBJECT_LIBRARY)
{
// Specify the compiler program database file if configured.
std::string pdb = gt->GetCompilePDBPath(configName);
std::string pdb = target->GetCompilePDBPath(configName);
if(!pdb.empty())
{
fout << "\t\t\t\tProgramDataBaseFileName=\""
@ -989,7 +984,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
"\t\t\t\tName=\"" << manifestTool << "\"";
std::vector<cmSourceFile const*> manifest_srcs;
gt->GetManifests(manifest_srcs, configName);
target->GetManifests(manifest_srcs, configName);
if (!manifest_srcs.empty())
{
fout << "\n\t\t\t\tAdditionalManifestFiles=\"";
@ -1004,7 +999,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
// Check if we need the FAT32 workaround.
// Check the filesystem type where the target will be written.
if (cmLVS6G_IsFAT(gt->GetDirectory(configName).c_str()))
if (cmLVS6G_IsFAT(target->GetDirectory(configName).c_str()))
{
// Add a flag telling the manifest tool to use a workaround
// for FAT32 file systems, which can cause an empty manifest
@ -1038,28 +1033,28 @@ cmLocalVisualStudio7Generator
}
void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
const std::string& configName, cmTarget &target,
const std::string& configName, cmGeneratorTarget* target,
const Options& targetOptions)
{
cmGlobalVisualStudio7Generator* gg =
static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
std::string temp;
std::string extraLinkOptions;
if(target.GetType() == cmState::EXECUTABLE)
if(target->GetType() == cmState::EXECUTABLE)
{
extraLinkOptions =
this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS")
+ std::string(" ")
+ GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName);
}
if(target.GetType() == cmState::SHARED_LIBRARY)
if(target->GetType() == cmState::SHARED_LIBRARY)
{
extraLinkOptions =
this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS")
+ std::string(" ")
+ GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName);
}
if(target.GetType() == cmState::MODULE_LIBRARY)
if(target->GetType() == cmState::MODULE_LIBRARY)
{
extraLinkOptions =
this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS")
@ -1067,7 +1062,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
+ GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName);
}
const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
const char* targetLinkFlags = target->GetProperty("LINK_FLAGS");
if(targetLinkFlags)
{
extraLinkOptions += " ";
@ -1076,7 +1071,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
std::string configTypeUpper = cmSystemTools::UpperCase(configName);
std::string linkFlagsConfig = "LINK_FLAGS_";
linkFlagsConfig += configTypeUpper;
targetLinkFlags = target.GetProperty(linkFlagsConfig.c_str());
targetLinkFlags = target->GetProperty(linkFlagsConfig.c_str());
if(targetLinkFlags)
{
extraLinkOptions += " ";
@ -1096,28 +1091,26 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
this->ConvertToOutputFormat(this->ModuleDefinitionFile, SHELL);
linkOptions.AddFlag("ModuleDefinitionFile", defFile.c_str());
}
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
if (target.GetType() == cmState::SHARED_LIBRARY &&
if (target->GetType() == cmState::SHARED_LIBRARY &&
this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
{
if (target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)/exportall.def");
}
}
switch(target.GetType())
switch(target->GetType())
{
case cmState::UNKNOWN_LIBRARY:
break;
case cmState::OBJECT_LIBRARY:
{
std::string libpath = this->GetTargetDirectory(gt);
std::string libpath = this->GetTargetDirectory(target);
libpath += "/";
libpath += configName;
libpath += "/";
libpath += target.GetName();
libpath += target->GetName();
libpath += ".lib";
const char* tool =
this->FortranProject? "VFLibrarianTool":"VCLibrarianTool";
@ -1129,8 +1122,8 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
}
case cmState::STATIC_LIBRARY:
{
std::string targetNameFull = gt->GetFullName(configName);
std::string libpath = gt->GetDirectory(configName);
std::string targetNameFull = target->GetFullName(configName);
std::string libpath = target->GetDirectory(configName);
libpath += "/";
libpath += targetNameFull;
const char* tool = "VCLibrarianTool";
@ -1145,14 +1138,14 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
|| this->FortranProject)
{
std::ostringstream libdeps;
this->Internal->OutputObjects(libdeps, &target);
this->Internal->OutputObjects(libdeps, target);
if(!libdeps.str().empty())
{
fout << "\t\t\t\tAdditionalDependencies=\"" << libdeps.str() << "\"\n";
}
}
std::string libflags;
this->GetStaticLibraryFlags(libflags, configTypeUpper, gt);
this->GetStaticLibraryFlags(libflags, configTypeUpper, target);
if(!libflags.empty())
{
fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n";
@ -1169,11 +1162,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
std::string targetNameFull;
std::string targetNameImport;
std::string targetNamePDB;
gt->GetLibraryNames(targetName, targetNameSO, targetNameFull,
target->GetLibraryNames(targetName, targetNameSO, targetNameFull,
targetNameImport, targetNamePDB, configName);
// Compute the link library and directory information.
cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
if(!pcli)
{
return;
@ -1205,22 +1198,22 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
|| this->FortranProject)
{
this->Internal->OutputObjects(fout, &target, " ");
this->Internal->OutputObjects(fout, target, " ");
}
fout << " ";
this->Internal->OutputLibraries(fout, cli.GetItems());
fout << "\"\n";
temp = gt->GetDirectory(configName);
temp = target->GetDirectory(configName);
temp += "/";
temp += targetNameFull;
fout << "\t\t\t\tOutputFile=\""
<< this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
this->WriteTargetVersionAttribute(fout, gt);
this->WriteTargetVersionAttribute(fout, target);
linkOptions.OutputFlagMap(fout, "\t\t\t\t");
fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
this->OutputLibraryDirectories(fout, cli.GetDirectories());
fout << "\"\n";
temp = gt->GetPDBDirectory(configName);
temp = target->GetPDBDirectory(configName);
temp += "/";
temp += targetNamePDB;
fout << "\t\t\t\tProgramDatabaseFile=\"" <<
@ -1248,7 +1241,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
{
fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"\n";
}
temp = gt->GetDirectory(configName, true);
temp = target->GetDirectory(configName, true);
temp += "/";
temp += targetNameImport;
fout << "\t\t\t\tImportLibrary=\""
@ -1266,11 +1259,11 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
std::string targetNameFull;
std::string targetNameImport;
std::string targetNamePDB;
gt->GetExecutableNames(targetName, targetNameFull,
target->GetExecutableNames(targetName, targetNameFull,
targetNameImport, targetNamePDB, configName);
// Compute the link library and directory information.
cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
if(!pcli)
{
return;
@ -1278,7 +1271,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
cmComputeLinkInformation& cli = *pcli;
std::string linkLanguage = cli.GetLinkLanguage();
bool isWin32Executable = target.GetPropertyAsBool("WIN32_EXECUTABLE");
bool isWin32Executable = target->GetPropertyAsBool("WIN32_EXECUTABLE");
// Compute the variable name to lookup standard libraries for this
// language.
@ -1304,23 +1297,23 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
|| this->FortranProject)
{
this->Internal->OutputObjects(fout, &target, " ");
this->Internal->OutputObjects(fout, target, " ");
}
fout << " ";
this->Internal->OutputLibraries(fout, cli.GetItems());
fout << "\"\n";
temp = gt->GetDirectory(configName);
temp = target->GetDirectory(configName);
temp += "/";
temp += targetNameFull;
fout << "\t\t\t\tOutputFile=\""
<< this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
this->WriteTargetVersionAttribute(fout, gt);
this->WriteTargetVersionAttribute(fout, target);
linkOptions.OutputFlagMap(fout, "\t\t\t\t");
fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
this->OutputLibraryDirectories(fout, cli.GetDirectories());
fout << "\"\n";
std::string path = this->ConvertToXMLOutputPathSingle(
gt->GetPDBDirectory(configName).c_str());
target->GetPDBDirectory(configName).c_str());
fout << "\t\t\t\tProgramDatabaseFile=\""
<< path << "/" << targetNamePDB
<< "\"\n";
@ -1367,7 +1360,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
{
fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"";
}
temp = gt->GetDirectory(configName, true);
temp = target->GetDirectory(configName, true);
temp += "/";
temp += targetNameImport;
fout << "\t\t\t\tImportLibrary=\""
@ -1418,13 +1411,11 @@ cmLocalVisualStudio7GeneratorInternals
//----------------------------------------------------------------------------
void
cmLocalVisualStudio7GeneratorInternals
::OutputObjects(std::ostream& fout, cmTarget* t, const char* isep)
::OutputObjects(std::ostream& fout, cmGeneratorTarget* gt, const char* isep)
{
// VS < 8 does not support per-config source locations so we
// list object library content on the link line instead.
cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
cmGeneratorTarget* gt =
lg->GetGlobalGenerator()->GetGeneratorTarget(t);
std::vector<std::string> objs;
gt->UseObjectLibraries(objs, "");
const char* sep = isep? isep : "";
@ -1481,7 +1472,7 @@ cmLocalVisualStudio7Generator
void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
const std::string& libName,
cmTarget &target)
cmGeneratorTarget* target)
{
std::vector<std::string> configs;
this->Makefile->GetConfigurations(configs);
@ -1489,13 +1480,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
// We may be modifying the source groups temporarily, so make a copy.
std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
// get the classes from the source lists then add them to the groups
this->ModuleDefinitionFile = "";
std::vector<cmSourceFile*> classes;
if (!gt->GetConfigCommonSourceFiles(classes))
if (!target->GetConfigCommonSourceFiles(classes))
{
return;
}
@ -1538,7 +1526,7 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
// VS >= 8 support per-config source locations so we
// list object library content as external objects.
std::vector<std::string> objs;
gt->UseObjectLibraries(objs, "");
target->UseObjectLibraries(objs, "");
if(!objs.empty())
{
// TODO: Separate sub-filter for each object library used?
@ -1573,7 +1561,7 @@ class cmLocalVisualStudio7GeneratorFCInfo
{
public:
cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg,
cmTarget& target,
cmGeneratorTarget* target,
cmSourceFile const& sf,
std::vector<std::string> const& configs);
std::map<std::string, cmLVS7GFileConfig> FileConfigMap;
@ -1581,12 +1569,10 @@ public:
cmLocalVisualStudio7GeneratorFCInfo
::cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg,
cmTarget& target,
cmGeneratorTarget* gt,
cmSourceFile const& sf,
std::vector<std::string> const& configs)
{
cmGeneratorTarget* gt =
lg->GetGlobalGenerator()->GetGeneratorTarget(&target);
std::string objectName;
if(gt->HasExplicitObjectName(&sf))
{
@ -1703,10 +1689,10 @@ cmLocalVisualStudio7GeneratorFCInfo
//----------------------------------------------------------------------------
std::string
cmLocalVisualStudio7Generator
::ComputeLongestObjectDirectory(cmTarget& target) const
::ComputeLongestObjectDirectory(cmGeneratorTarget const* target) const
{
std::vector<std::string> configs;
target.GetMakefile()->GetConfigurations(configs);
target->Target->GetMakefile()->GetConfigurations(configs);
// Compute the maximum length configuration name.
std::string config_max;
@ -1725,9 +1711,7 @@ cmLocalVisualStudio7Generator
std::string dir_max;
dir_max += this->GetCurrentBinaryDirectory();
dir_max += "/";
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
dir_max += this->GetTargetDirectory(gt);
dir_max += this->GetTargetDirectory(target);
dir_max += "/";
dir_max += config_max;
dir_max += "/";
@ -1735,7 +1719,7 @@ cmLocalVisualStudio7Generator
}
bool cmLocalVisualStudio7Generator
::WriteGroup(const cmSourceGroup *sg, cmTarget& target,
::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
std::ostream &fout, const std::string& libName,
std::vector<std::string> const& configs)
{
@ -1770,15 +1754,14 @@ bool cmLocalVisualStudio7Generator
}
// Loop through each source in the source group.
std::string objectName;
for(std::vector<const cmSourceFile *>::const_iterator sf =
sourceFiles.begin(); sf != sourceFiles.end(); ++sf)
{
std::string source = (*sf)->GetFullPath();
FCInfo fcinfo(this, target, *(*sf), configs);
if (source != libName || target.GetType() == cmState::UTILITY ||
target.GetType() == cmState::GLOBAL_TARGET )
if (source != libName || target->GetType() == cmState::UTILITY ||
target->GetType() == cmState::GLOBAL_TARGET )
{
fout << "\t\t\t<File\n";
std::string d = this->ConvertToXMLOutputPathSingle(source.c_str());
@ -2025,10 +2008,10 @@ void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout)
void cmLocalVisualStudio7Generator
::OutputTargetRules(std::ostream& fout,
const std::string& configName,
cmTarget &target,
cmGeneratorTarget *target,
const std::string& /*libName*/)
{
if (target.GetType() > cmState::GLOBAL_TARGET)
if (target->GetType() > cmState::GLOBAL_TARGET)
{
return;
}
@ -2038,36 +2021,35 @@ void cmLocalVisualStudio7Generator
const char* tool =
this->FortranProject? "VFPreBuildEventTool":"VCPreBuildEventTool";
event.Start(tool);
event.Write(target.GetPreBuildCommands());
event.Write(target->Target->GetPreBuildCommands());
event.Finish();
// Add pre-link event.
tool = this->FortranProject? "VFPreLinkEventTool":"VCPreLinkEventTool";
event.Start(tool);
bool addedPrelink = false;
if (target.GetType() == cmState::SHARED_LIBRARY &&
if (target->GetType() == cmState::SHARED_LIBRARY &&
this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
{
if (target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
addedPrelink = true;
std::vector<cmCustomCommand> commands =
target.GetPreLinkCommands();
target->Target->GetPreLinkCommands();
cmGlobalVisualStudioGenerator* gg
= static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
cmGeneratorTarget* gt =
this->GlobalGenerator->GetGeneratorTarget(&target);
gg->AddSymbolExportCommand(
gt, commands, configName);
target, commands, configName);
event.Write(commands);
}
}
if (!addedPrelink)
{
event.Write(target.GetPreLinkCommands());
event.Write(target->Target->GetPreLinkCommands());
}
cmsys::auto_ptr<cmCustomCommand> pcc(
this->MaybeCreateImplibDir(target, configName, this->FortranProject));
this->MaybeCreateImplibDir(target,
configName, this->FortranProject));
if(pcc.get())
{
event.Write(*pcc);
@ -2077,18 +2059,18 @@ void cmLocalVisualStudio7Generator
// Add post-build event.
tool = this->FortranProject? "VFPostBuildEventTool":"VCPostBuildEventTool";
event.Start(tool);
event.Write(target.GetPostBuildCommands());
event.Write(target->Target->GetPostBuildCommands());
event.Finish();
}
void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout,
cmTarget& target)
cmGeneratorTarget* target)
{
// if we have all the required Source code control tags
// then add that to the project
const char* vsProjectname = target.GetProperty("VS_SCC_PROJECTNAME");
const char* vsLocalpath = target.GetProperty("VS_SCC_LOCALPATH");
const char* vsProvider = target.GetProperty("VS_SCC_PROVIDER");
const char* vsProjectname = target->GetProperty("VS_SCC_PROJECTNAME");
const char* vsLocalpath = target->GetProperty("VS_SCC_LOCALPATH");
const char* vsProvider = target->GetProperty("VS_SCC_PROVIDER");
if(vsProvider && vsLocalpath && vsProjectname)
{
@ -2096,7 +2078,7 @@ void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout,
<< "\tSccLocalPath=\"" << vsLocalpath << "\"\n"
<< "\tSccProvider=\"" << vsProvider << "\"\n";
const char* vsAuxPath = target.GetProperty("VS_SCC_AUXPATH");
const char* vsAuxPath = target->GetProperty("VS_SCC_AUXPATH");
if(vsAuxPath)
{
fout << "\tSccAuxPath=\"" << vsAuxPath << "\"\n";
@ -2108,7 +2090,7 @@ void
cmLocalVisualStudio7Generator
::WriteProjectStartFortran(std::ostream& fout,
const std::string& libName,
cmTarget & target)
cmGeneratorTarget *target)
{
cmGlobalVisualStudio7Generator* gg =
@ -2118,13 +2100,13 @@ cmLocalVisualStudio7Generator
<< "<VisualStudioProject\n"
<< "\tProjectCreator=\"Intel Fortran\"\n"
<< "\tVersion=\"" << gg->GetIntelProjectVersion() << "\"\n";
const char* keyword = target.GetProperty("VS_KEYWORD");
const char* keyword = target->GetProperty("VS_KEYWORD");
if(!keyword)
{
keyword = "Console Application";
}
const char* projectType = 0;
switch(target.GetType())
switch(target->GetType())
{
case cmState::STATIC_LIBRARY:
projectType = "typeStaticLibrary";
@ -2169,7 +2151,7 @@ cmLocalVisualStudio7Generator
void
cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
const std::string& libName,
cmTarget & target,
cmGeneratorTarget *target,
std::vector<cmSourceGroup> &)
{
if(this->FortranProject)
@ -2193,12 +2175,12 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
{
fout << "\tVersion=\"" << (gg->GetVersion()/10) << ".00\"\n";
}
const char* projLabel = target.GetProperty("PROJECT_LABEL");
const char* projLabel = target->GetProperty("PROJECT_LABEL");
if(!projLabel)
{
projLabel = libName.c_str();
}
const char* keyword = target.GetProperty("VS_KEYWORD");
const char* keyword = target->GetProperty("VS_KEYWORD");
if(!keyword)
{
keyword = "Win32Proj";
@ -2210,7 +2192,7 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
}
this->WriteProjectSCC(fout, target);
if(const char* targetFrameworkVersion =
target.GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION"))
target->GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION"))
{
fout << "\tTargetFrameworkVersion=\"" << targetFrameworkVersion << "\"\n";
}
@ -2231,12 +2213,13 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
}
void cmLocalVisualStudio7Generator::WriteVCProjFooter(std::ostream& fout,
cmTarget &target)
void cmLocalVisualStudio7Generator::WriteVCProjFooter(
std::ostream& fout,
cmGeneratorTarget *target)
{
fout << "\t<Globals>\n";
cmPropertyMap const& props = target.GetProperties();
cmPropertyMap const& props = target->Target->GetProperties();
for(cmPropertyMap::const_iterator i = props.begin(); i != props.end(); ++i)
{
if(i->first.find("VS_GLOBAL_") == 0)

32
Source/cmLocalVisualStudio7Generator.h
View File

@ -15,7 +15,6 @@
#include "cmLocalVisualStudioGenerator.h"
#include "cmVisualStudioGeneratorOptions.h"
class cmTarget;
class cmSourceFile;
class cmCustomCommand;
class cmSourceGroup;
@ -57,13 +56,15 @@ public:
std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
cmSourceFile* CreateVCProjBuildRule();
void WriteStampFiles();
virtual std::string ComputeLongestObjectDirectory(cmTarget&) const;
virtual std::string
ComputeLongestObjectDirectory(cmGeneratorTarget const*) const;
virtual void ReadAndStoreExternalGUID(const std::string& name,
const char* path);
virtual void AddCMakeListsRules();
protected:
void CreateSingleVCProj(const std::string& lname, cmTarget &tgt);
void CreateSingleVCProj(const std::string& lname,
cmGeneratorTarget *tgt);
private:
typedef cmVisualStudioGeneratorOptions Options;
typedef cmLocalVisualStudio7GeneratorFCInfo FCInfo;
@ -72,30 +73,33 @@ private:
void FixGlobalTargets();
void WriteProjectFiles();
void WriteVCProjHeader(std::ostream& fout, const std::string& libName,
cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
void WriteVCProjFooter(std::ostream& fout, cmTarget &target);
cmGeneratorTarget* tgt,
std::vector<cmSourceGroup> &sgs);
void WriteVCProjFooter(std::ostream& fout, cmGeneratorTarget* target);
void WriteVCProjFile(std::ostream& fout, const std::string& libName,
cmTarget &tgt);
cmGeneratorTarget* tgt);
void WriteConfigurations(std::ostream& fout,
std::vector<std::string> const& configs,
const std::string& libName, cmTarget &tgt);
const std::string& libName, cmGeneratorTarget* tgt);
void WriteConfiguration(std::ostream& fout,
const std::string& configName,
const std::string& libName, cmTarget &tgt);
const std::string& libName, cmGeneratorTarget* tgt);
std::string EscapeForXML(const std::string& s);
std::string ConvertToXMLOutputPath(const char* path);
std::string ConvertToXMLOutputPathSingle(const char* path);
void OutputTargetRules(std::ostream& fout, const std::string& configName,
cmTarget &target, const std::string& libName);
cmGeneratorTarget* target,
const std::string& libName);
void OutputBuildTool(std::ostream& fout, const std::string& configName,
cmTarget& t, const Options& targetOptions);
cmGeneratorTarget* t, const Options& targetOptions);
void OutputLibraryDirectories(std::ostream& fout,
std::vector<std::string> const& dirs);
void WriteProjectSCC(std::ostream& fout, cmTarget& target);
void WriteProjectSCC(std::ostream& fout, cmGeneratorTarget *target);
void WriteProjectStart(std::ostream& fout, const std::string& libName,
cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
cmGeneratorTarget* tgt,
std::vector<cmSourceGroup> &sgs);
void WriteProjectStartFortran(std::ostream& fout, const std::string& libName,
cmTarget &tgt);
cmGeneratorTarget* tgt);
void WriteVCProjBeginGroup(std::ostream& fout,
const char* group,
const char* filter);
@ -110,7 +114,7 @@ private:
cmGeneratorTarget* gt);
bool WriteGroup(const cmSourceGroup *sg,
cmTarget& target, std::ostream &fout,
cmGeneratorTarget* target, std::ostream &fout,
const std::string& libName,
std::vector<std::string> const& configs);

14
Source/cmLocalVisualStudioGenerator.cxx
View File

@ -43,7 +43,7 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>& mapping,
cmGeneratorTarget const* gt)
{
std::string dir_max = this->ComputeLongestObjectDirectory(*gt->Target);
std::string dir_max = this->ComputeLongestObjectDirectory(gt);
// Count the number of object files with each name. Note that
// windows file names are not case sensitive.
@ -80,7 +80,7 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames(
//----------------------------------------------------------------------------
cmsys::auto_ptr<cmCustomCommand>
cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target,
cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target,
const std::string& config,
bool isFortran)
{
@ -89,13 +89,11 @@ cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target,
// If an executable exports symbols then VS wants to create an
// import library but forgets to create the output directory.
// The Intel Fortran plugin always forgets to the directory.
if(target.GetType() != cmState::EXECUTABLE &&
!(isFortran && target.GetType() == cmState::SHARED_LIBRARY))
if(target->GetType() != cmState::EXECUTABLE &&
!(isFortran && target->GetType() == cmState::SHARED_LIBRARY))
{ return pcc; }
cmGeneratorTarget* gt =
this->GetGlobalGenerator()->GetGeneratorTarget(&target);
std::string outDir = gt->GetDirectory(config, false);
std::string impDir = gt->GetDirectory(config, true);
std::string outDir = target->GetDirectory(config, false);
std::string impDir = target->GetDirectory(config, true);
if(impDir == outDir) { return pcc; }
// Add a pre-build event to create the directory.

6
Source/cmLocalVisualStudioGenerator.h
View File

@ -44,7 +44,8 @@ public:
cmGlobalVisualStudioGenerator::VSVersion GetVersion() const;
virtual std::string ComputeLongestObjectDirectory(cmTarget&) const = 0;
virtual std::string
ComputeLongestObjectDirectory(cmGeneratorTarget const*) const = 0;
virtual void AddCMakeListsRules() = 0;
@ -58,7 +59,8 @@ protected:
/** Construct a custom command to make exe import lib dir. */
cmsys::auto_ptr<cmCustomCommand>
MaybeCreateImplibDir(cmTarget& target, const std::string& config,
MaybeCreateImplibDir(cmGeneratorTarget *target,
const std::string& config,
bool isFortran);
};

16
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@ -16,7 +16,6 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmTarget.h"
#include "cmake.h"
//----------------------------------------------------------------------------
@ -279,11 +278,13 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
if(!relink)
{
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(),
this->GeneratorTarget);
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreBuildCommands(),
this->GeneratorTarget);
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(),
this->GeneratorTarget);
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreLinkCommands(),
this->GeneratorTarget);
}
// Determine whether a link script will be used.
@ -448,8 +449,9 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
if(!relink)
{
this->LocalGenerator->
AppendCustomCommands(commands, this->Target->GetPostBuildCommands(),
this->GeneratorTarget);
AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget);
}
// Write the build rule.

19
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@ -16,7 +16,6 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmTarget.h"
#include "cmake.h"
#include "cmAlgorithms.h"
@ -114,7 +113,8 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules()
// Add post-build rules.
this->LocalGenerator->
AppendCustomCommands(commands, this->Target->GetPostBuildCommands(),
AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget);
// Depend on the object files.
@ -457,11 +457,13 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
if(!relink)
{
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreBuildCommands(),
this->GeneratorTarget);
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreBuildCommands(),
this->GeneratorTarget);
this->LocalGenerator
->AppendCustomCommands(commands, this->Target->GetPreLinkCommands(),
this->GeneratorTarget);
->AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPreLinkCommands(),
this->GeneratorTarget);
}
// Determine whether a link script will be used.
@ -811,8 +813,9 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
if(!relink)
{
this->LocalGenerator->
AppendCustomCommands(commands, this->Target->GetPostBuildCommands(),
this->GeneratorTarget);
AppendCustomCommands(commands,
this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget);
}
// Compute the list of outputs.

5
Source/cmMakefileTargetGenerator.cxx
View File

@ -18,7 +18,6 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmTarget.h"
#include "cmake.h"
#include "cmState.h"
#include "cmComputeLinkInformation.h"
@ -432,7 +431,7 @@ void cmMakefileTargetGenerator
std::string srcFullPath =
this->Convert(source.GetFullPath(), cmLocalGenerator::FULL);
this->LocalGenerator->
AddImplicitDepends(*this->Target, lang,
AddImplicitDepends(this->GeneratorTarget, lang,
objFullPath.c_str(),
srcFullPath.c_str());
}
@ -1241,7 +1240,7 @@ void cmMakefileTargetGenerator
std::string srcFullPath =
this->Convert(idi->second, cmLocalGenerator::FULL);
this->LocalGenerator->
AddImplicitDepends(*this->Target, idi->first,
AddImplicitDepends(this->GeneratorTarget, idi->first,
objFullPath.c_str(),
srcFullPath.c_str());
}

2
Source/cmMakefileTargetGenerator.h
View File

@ -24,7 +24,6 @@ class cmGeneratedFileStream;
class cmGlobalUnixMakefileGenerator3;
class cmLocalUnixMakefileGenerator3;
class cmMakefile;
class cmTarget;
class cmSourceFile;
/** \class cmMakefileTargetGenerator
@ -51,7 +50,6 @@ public:
std::string GetProgressFileNameFull()
{ return this->ProgressFileNameFull; }
cmTarget* GetTarget() { return this->Target;}
cmGeneratorTarget* GetGeneratorTarget() { return this->GeneratorTarget;}
protected:

11
Source/cmMakefileUtilityTargetGenerator.cxx
View File

@ -16,7 +16,6 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmTarget.h"
//----------------------------------------------------------------------------
cmMakefileUtilityTargetGenerator
@ -68,19 +67,21 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
// Utility targets store their rules in pre- and post-build commands.
this->LocalGenerator->AppendCustomDepends
(depends, this->Target->GetPreBuildCommands());
(depends, this->GeneratorTarget->Target->GetPreBuildCommands());
this->LocalGenerator->AppendCustomDepends
(depends, this->Target->GetPostBuildCommands());
(depends, this->GeneratorTarget->Target->GetPostBuildCommands());
this->LocalGenerator->AppendCustomCommands
(commands, this->Target->GetPreBuildCommands(), this->GeneratorTarget);
(commands, this->GeneratorTarget->Target->GetPreBuildCommands(),
this->GeneratorTarget);
// Depend on all custom command outputs for sources
this->DriveCustomCommands(depends);
this->LocalGenerator->AppendCustomCommands
(commands, this->Target->GetPostBuildCommands(), this->GeneratorTarget);
(commands, this->GeneratorTarget->Target->GetPostBuildCommands(),
this->GeneratorTarget);
// Add dependencies on targets that must be built first.
this->AppendTargetDepends(depends);

36
Source/cmNinjaNormalTargetGenerator.cxx
View File

@ -399,7 +399,6 @@ static int calculateCommandLineLengthLimit(int linkRuleLength)
void cmNinjaNormalTargetGenerator::WriteLinkStatement()
{
cmTarget& target = *this->GetTarget();
cmGeneratorTarget& gt = *this->GetGeneratorTarget();
const std::string cfgName = this->GetConfigName();
std::string targetOutput = ConvertToNinjaPath(
@ -443,7 +442,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
// Write comments.
cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream());
const cmState::TargetType targetType = target.GetType();
const cmState::TargetType targetType = gt.GetType();
this->GetBuildFileStream()
<< "# Link build statements for "
<< cmState::GetTargetTypeName(targetType)
@ -490,13 +489,13 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
&genTarget,
useWatcomQuote);
if(this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")
&& target.GetType() == cmState::SHARED_LIBRARY)
&& gt.GetType() == cmState::SHARED_LIBRARY)
{
if(target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
std::string name_of_def_file
= gt.GetSupportDirectory();
name_of_def_file += "/" + target.GetName();
name_of_def_file += "/" + gt.GetName();
name_of_def_file += ".def ";
vars["LINK_FLAGS"] += " /DEF:";
vars["LINK_FLAGS"] += this->GetLocalGenerator()
@ -505,7 +504,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
}
}
this->addPoolNinjaVariable("JOB_POOL_LINK", &target, vars);
this->addPoolNinjaVariable("JOB_POOL_LINK", &gt, vars);
this->AddModuleDefinitionFlag(vars["LINK_FLAGS"]);
vars["LINK_FLAGS"] = cmGlobalNinjaGenerator
@ -599,9 +598,9 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
}
const std::vector<cmCustomCommand> *cmdLists[3] = {
&target.GetPreBuildCommands(),
&target.GetPreLinkCommands(),
&target.GetPostBuildCommands()
&gt.Target->GetPreBuildCommands(),
&gt.Target->GetPreLinkCommands(),
&gt.Target->GetPostBuildCommands()
};
std::vector<std::string> preLinkCmdLines, postBuildCmdLines;
@ -626,17 +625,17 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
}
// maybe create .def file from list of objects
if (target.GetType() == cmState::SHARED_LIBRARY &&
if (gt.GetType() == cmState::SHARED_LIBRARY &&
this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
{
if(target.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
{
std::string cmakeCommand =
this->GetLocalGenerator()->ConvertToOutputFormat(
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
std::string name_of_def_file
= gt.GetSupportDirectory();
name_of_def_file += "/" + target.GetName();
name_of_def_file += "/" + gt.GetName();
name_of_def_file += ".def";
std::string cmd = cmakeCommand;
cmd += " -E __create_def ";
@ -699,11 +698,11 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
const std::string rspfile =
std::string(cmake::GetCMakeFilesDirectoryPostSlash())
+ target.GetName() + ".rsp";
+ gt.GetName() + ".rsp";
// Gather order-only dependencies.
cmNinjaDeps orderOnlyDeps;
this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(),
this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(),
orderOnlyDeps);
// Ninja should restat after linking if and only if there are byproducts.
@ -772,8 +771,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
}
// Add aliases for the file name and the target name.
globalGen.AddTargetAlias(this->TargetNameOut, &target);
globalGen.AddTargetAlias(this->GetTargetName(), &target);
globalGen.AddTargetAlias(this->TargetNameOut, &gt);
globalGen.AddTargetAlias(this->GetTargetName(), &gt);
}
//----------------------------------------------------------------------------
@ -781,7 +780,8 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement()
{
// Write a phony output that depends on all object files.
cmNinjaDeps outputs;
this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs);
this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(),
outputs);
cmNinjaDeps depends = this->GetObjects();
this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
"Object library "
@ -791,5 +791,5 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement()
// Add aliases for the target name.
this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),
this->GetTarget());
this->GetGeneratorTarget());
}

11
Source/cmNinjaTargetGenerator.cxx
View File

@ -486,7 +486,8 @@ cmNinjaTargetGenerator
si != customCommands.end(); ++si)
{
cmCustomCommand const* cc = (*si)->GetCustomCommand();
this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget());
this->GetLocalGenerator()->AddCustomCommandTarget(cc,
this->GetGeneratorTarget());
// Record the custom commands for this target. The container is used
// in WriteObjectBuildStatement when called in a loop below.
this->CustomCommands.push_back(cc);
@ -511,7 +512,8 @@ cmNinjaTargetGenerator
}
cmNinjaDeps orderOnlyDeps;
this->GetLocalGenerator()->AppendTargetDepends(this->Target, orderOnlyDeps);
this->GetLocalGenerator()->AppendTargetDepends(this->GeneratorTarget,
orderOnlyDeps);
// Add order-only dependencies on custom command outputs.
for(std::vector<cmCustomCommand const*>::const_iterator
@ -633,7 +635,8 @@ cmNinjaTargetGenerator
ConvertToNinjaPath(objectFileDir),
cmLocalGenerator::SHELL);
this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetTarget(), vars);
this->addPoolNinjaVariable("JOB_POOL_COMPILE",
this->GetGeneratorTarget(), vars);
this->SetMsvcTargetPdbVariable(vars);
@ -782,7 +785,7 @@ cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
void cmNinjaTargetGenerator::addPoolNinjaVariable(
const std::string& pool_property,
cmTarget* target,
cmGeneratorTarget* target,
cmNinjaVars& vars)
{
const char* pool = target->GetProperty(pool_property);

5
Source/cmNinjaTargetGenerator.h
View File

@ -53,9 +53,6 @@ protected:
cmGeneratedFileStream& GetBuildFileStream() const;
cmGeneratedFileStream& GetRulesFileStream() const;
cmTarget* GetTarget() const
{ return this->Target; }
cmGeneratorTarget* GetGeneratorTarget() const
{ return this->GeneratorTarget; }
@ -152,7 +149,7 @@ protected:
std::set<std::string> MacContentFolders;
void addPoolNinjaVariable(const std::string& pool_property,
cmTarget* target,
cmGeneratorTarget* target,
cmNinjaVars& vars);
private:

16
Source/cmNinjaUtilityTargetGenerator.cxx
View File

@ -16,7 +16,6 @@
#include "cmGlobalNinjaGenerator.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmTarget.h"
#include "cmCustomCommandGenerator.h"
cmNinjaUtilityTargetGenerator::cmNinjaUtilityTargetGenerator(
@ -34,8 +33,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
cmNinjaDeps deps, outputs, util_outputs(1, utilCommandName);
const std::vector<cmCustomCommand> *cmdLists[2] = {
&this->GetTarget()->GetPreBuildCommands(),
&this->GetTarget()->GetPostBuildCommands()
&this->GetGeneratorTarget()->Target->GetPreBuildCommands(),
&this->GetGeneratorTarget()->Target->GetPostBuildCommands()
};
bool uses_terminal = false;
@ -66,7 +65,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
{
cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
this->GetLocalGenerator());
this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget());
this->GetLocalGenerator()->AddCustomCommandTarget(cc,
this->GetGeneratorTarget());
// Depend on all custom command outputs.
const std::vector<std::string>& ccOutputs = ccg.GetOutputs();
@ -78,8 +78,10 @@ void cmNinjaUtilityTargetGenerator::Generate()
}
}
this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs);
this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(), deps);
this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(),
outputs);
this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(),
deps);
if (commands.empty()) {
this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
@ -140,5 +142,5 @@ void cmNinjaUtilityTargetGenerator::Generate()
}
this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),
this->GetTarget());
this->GetGeneratorTarget());
}

2
Source/cmQtAutoGeneratorInitializer.cxx
View File

@ -895,7 +895,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
commandLines, false, autogenComment.c_str());
cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
lg->AddGeneratorTarget(autogenTarget, gt);
lg->AddGeneratorTarget(gt);
lg->GetGlobalGenerator()->AddGeneratorTarget(autogenTarget, gt);
// Set target folder

4
Source/cmTarget.h
View File

@ -260,6 +260,10 @@ public:
return this->LinkLibrariesForVS6;}
#endif
struct StrictTargetComparison {
bool operator()(cmTarget const* t1, cmTarget const* t2) const;
};
private:
bool HandleLocationPropertyPolicy(cmMakefile* context) const;

49
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -13,7 +13,6 @@
#include "cmVisualStudio10TargetGenerator.h"
#include "cmGlobalVisualStudio10Generator.h"
#include "cmGeneratorTarget.h"
#include "cmTarget.h"
#include "cmComputeLinkInformation.h"
#include "cmGeneratedFileStream.h"
#include "cmMakefile.h"
@ -167,13 +166,12 @@ static std::string cmVS10EscapeComment(std::string comment)
}
cmVisualStudio10TargetGenerator::
cmVisualStudio10TargetGenerator(cmTarget* target,
cmVisualStudio10TargetGenerator(cmGeneratorTarget* target,
cmGlobalVisualStudio10Generator* gg)
{
this->GlobalGenerator = gg;
this->Target = target;
this->GeneratorTarget = gg->GetGeneratorTarget(target);
this->Makefile = target->GetMakefile();
this->GeneratorTarget = target;
this->Makefile = target->Target->GetMakefile();
this->Makefile->GetConfigurations(this->Configurations);
this->LocalGenerator =
(cmLocalVisualStudio7Generator*)
@ -275,8 +273,9 @@ void cmVisualStudio10TargetGenerator::Generate()
return;
}
// Tell the global generator the name of the project file
this->Target->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str());
this->Target->SetProperty("GENERATOR_FILE_NAME_EXT",
this->GeneratorTarget->Target
->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str());
this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME_EXT",
".vcxproj");
if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
{
@ -732,7 +731,8 @@ void cmVisualStudio10TargetGenerator
cmGlobalVisualStudio10Generator* gg =
static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
const char* mfcFlag =
this->Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG");
this->GeneratorTarget->
Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG");
std::string mfcFlagValue = mfcFlag ? mfcFlag : "0";
std::string useOfMfcValue = "false";
@ -1462,7 +1462,8 @@ void cmVisualStudio10TargetGenerator::WriteSource(
}
else
{
this->GlobalGenerator->PathTooLong(this->Target, sf, sourceRel);
this->GlobalGenerator->PathTooLong(this->GeneratorTarget,
sf, sourceRel);
}
}
this->ConvertToWindowsSlash(sourceFile);
@ -1915,12 +1916,12 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
std::string baseFlagVar = "CMAKE_";
baseFlagVar += linkLanguage;
baseFlagVar += "_FLAGS";
flags = this->
flags = this->GeneratorTarget->
Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str());
std::string flagVar = baseFlagVar + std::string("_") +
cmSystemTools::UpperCase(configName);
flags += " ";
flags += this->
flags += this->GeneratorTarget->
Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str());
}
// set the correct language
@ -1936,7 +1937,8 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
linkLanguage, configName.c_str());
// Get preprocessor definitions for this directory.
std::string defineFlags = this->Target->GetMakefile()->GetDefineFlags();
std::string defineFlags =
this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
if(this->MSTools)
{
clOptions.FixExceptionHandlingDefault();
@ -2440,11 +2442,11 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
linkFlagVarBase += linkType;
linkFlagVarBase += "_LINKER_FLAGS";
flags += " ";
flags += this->
flags += this->GeneratorTarget->
Target->GetMakefile()->GetRequiredDefinition(linkFlagVarBase.c_str());
std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG;
flags += " ";
flags += this->
flags += this->GeneratorTarget->
Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str());
const char* targetLinkFlags =
this->GeneratorTarget->GetProperty("LINK_FLAGS");
@ -2674,7 +2676,8 @@ cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config)
linkOptions.OutputFlagMap(*this->BuildFileStream, " ");
this->WriteString("</Link>\n", 2);
if(!this->GlobalGenerator->NeedLinkLibraryDependencies(*this->Target))
if(!this->GlobalGenerator->NeedLinkLibraryDependencies(
this->GeneratorTarget))
{
this->WriteString("<ProjectReference>\n", 2);
this->WriteString(
@ -2811,7 +2814,7 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName)
{
addedPrelink = true;
std::vector<cmCustomCommand> commands =
this->Target->GetPreLinkCommands();
this->GeneratorTarget->Target->GetPreLinkCommands();
this->GlobalGenerator->AddSymbolExportCommand(
this->GeneratorTarget, commands, configName);
this->WriteEvent("PreLinkEvent", commands, configName);
@ -2820,12 +2823,12 @@ cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName)
if (!addedPrelink)
{
this->WriteEvent("PreLinkEvent",
this->Target->GetPreLinkCommands(), configName);
this->GeneratorTarget->Target->GetPreLinkCommands(), configName);
}
this->WriteEvent("PreBuildEvent",
this->Target->GetPreBuildCommands(), configName);
this->GeneratorTarget->Target->GetPreBuildCommands(), configName);
this->WriteEvent("PostBuildEvent",
this->Target->GetPostBuildCommands(), configName);
this->GeneratorTarget->Target->GetPostBuildCommands(), configName);
}
void cmVisualStudio10TargetGenerator::WriteEvent(
@ -2875,7 +2878,7 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences()
for( OrderedTargetDependSet::const_iterator i = depends.begin();
i != depends.end(); ++i)
{
cmTarget const* dt = (*i)->Target;
cmGeneratorTarget const* dt = *i;
if(dt->GetType() == cmState::INTERFACE_LIBRARY)
{
continue;
@ -2883,12 +2886,12 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences()
// skip fortran targets as they can not be processed by MSBuild
// the only reference will be in the .sln file
if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
->TargetIsFortranOnly(*dt))
->TargetIsFortranOnly(dt))
{
continue;
}
this->WriteString("<ProjectReference Include=\"", 2);
cmMakefile* mf = dt->GetMakefile();
cmLocalGenerator* lg = dt->GetLocalGenerator();
std::string name = dt->GetName();
std::string path;
const char* p = dt->GetProperty("EXTERNAL_MSPROJECT");
@ -2898,7 +2901,7 @@ void cmVisualStudio10TargetGenerator::WriteProjectReferences()
}
else
{
path = mf->GetCurrentBinaryDirectory();
path = lg->GetCurrentBinaryDirectory();
path += "/";
path += dt->GetName();
path += ".vcxproj";

4
Source/cmVisualStudio10TargetGenerator.h
View File

@ -13,7 +13,6 @@
#define cmVisualStudioTargetGenerator_h
#include "cmStandardIncludes.h"
class cmTarget;
class cmMakefile;
class cmGeneratorTarget;
class cmGeneratedFileStream;
@ -29,7 +28,7 @@ struct cmIDEFlagTable;
class cmVisualStudio10TargetGenerator
{
public:
cmVisualStudio10TargetGenerator(cmTarget* target,
cmVisualStudio10TargetGenerator(cmGeneratorTarget* target,
cmGlobalVisualStudio10Generator* gg);
~cmVisualStudio10TargetGenerator();
void Generate();
@ -148,7 +147,6 @@ private:
OptionsMap LinkOptions;
std::string PathToVcxproj;
std::vector<std::string> Configurations;
cmTarget* Target;
cmGeneratorTarget* GeneratorTarget;
cmMakefile* Makefile;
std::string Platform;

8
Source/cmXCodeObject.h
View File

@ -13,7 +13,7 @@
#define cmXCodeObject_h
#include "cmStandardIncludes.h"
class cmTarget;
class cmGeneratorTarget;
class cmXCodeObject
{
@ -87,11 +87,11 @@ public:
{
this->Id = id;
}
cmTarget* GetTarget()
cmGeneratorTarget* GetTarget()
{
return this->Target;
}
void SetTarget(cmTarget* t)
void SetTarget(cmGeneratorTarget* t)
{
this->Target = t;
}
@ -146,7 +146,7 @@ public:
protected:
void PrintString(std::ostream& os) const;
cmTarget* Target;
cmGeneratorTarget* Target;
Type TypeValue;
std::string Id;
PBXType IsA;