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

ENH: make LOCATION an computed property of the target and get rid of a bunch of const junk

This commit is contained in:
Ken Martin 2005-06-22 09:06:46 -04:00
parent 5fab6eebd6
commit 369308ca76
27 changed files with 217 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmExportLibraryDependencies.cxx
View File

@ -91,7 +91,7 @@ void cmExportLibraryDependenciesCommand::FinalPass()
cmTargets &tgts = gen->GetMakefile()->GetTargets();
std::vector<std::string> depends;
const char *defType;
for(cmTargets::const_iterator l = tgts.begin();
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); ++l)
{
if ((l->second.GetType() != cmTarget::INSTALL_FILES)

4
Source/cmGlobalGenerator.cxx
View File

@ -531,9 +531,9 @@ void cmGlobalGenerator::Configure()
{
manager = m_LocalGenerators[i]->GetMakefile()->GetCacheManager();
m_LocalGenerators[i]->ConfigureFinalPass();
cmTargets const& targets =
cmTargets & targets =
m_LocalGenerators[i]->GetMakefile()->GetTargets();
for (cmTargets::const_iterator l = targets.begin();
for (cmTargets::iterator l = targets.begin();
l != targets.end(); l++)
{
cmTarget::LinkLibraries libs = l->second.GetLinkLibraries();

4
Source/cmGlobalKdevelopGenerator.cxx
View File

@ -78,7 +78,7 @@ void cmGlobalKdevelopGenerator::Generate()
//run from kdevelop for now just pick the first executable found
std::string executable;
cmTargets& targets=mf->GetTargets();
for (cmTargets::const_iterator ti = targets.begin();
for (cmTargets::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
if (ti->second.GetType()==cmTarget::EXECUTABLE)
@ -134,7 +134,7 @@ bool cmGlobalKdevelopGenerator
//get all sources
cmTargets& targets=makefile->GetTargets();
for (cmTargets::const_iterator ti = targets.begin();
for (cmTargets::iterator ti = targets.begin();
ti != targets.end(); ti++)
{
const std::vector<cmSourceFile*>& sources=ti->second.GetSourceFiles();

22
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -467,7 +467,7 @@ cmGlobalUnixMakefileGenerator3
std::vector<std::string> all_tgts;
// for all of out targets
for (cmTargets::const_iterator l = lg->GetMakefile()->GetTargets().begin();
for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin();
l != lg->GetMakefile()->GetTargets().end(); l++)
{
if((l->second.GetType() == cmTarget::EXECUTABLE) ||
@ -528,7 +528,7 @@ cmGlobalUnixMakefileGenerator3
std::vector<std::string> all_tgts;
// for all of out targets
for (cmTargets::const_iterator l = lg->GetMakefile()->GetTargets().begin();
for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin();
l != lg->GetMakefile()->GetTargets().end(); l++)
{
if((l->second.GetType() == cmTarget::EXECUTABLE) ||
@ -597,7 +597,7 @@ cmGlobalUnixMakefileGenerator3
std::vector<std::string> all_tgts;
// for all of out targets
for (cmTargets::const_iterator l = lg->GetMakefile()->GetTargets().begin();
for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin();
l != lg->GetMakefile()->GetTargets().end(); l++)
{
if((l->second.GetType() == cmTarget::EXECUTABLE) ||
@ -658,7 +658,7 @@ cmGlobalUnixMakefileGenerator3
std::vector<std::string> all_tgts;
// for all of out targets
for (cmTargets::const_iterator l = lg->GetMakefile()->GetTargets().begin();
for (cmTargets::iterator l = lg->GetMakefile()->GetTargets().begin();
l != lg->GetMakefile()->GetTargets().end(); l++)
{
if((l->second.GetType() == cmTarget::EXECUTABLE) ||
@ -713,8 +713,8 @@ cmGlobalUnixMakefileGenerator3
depends.push_back("cmake_check_build_system");
// for each target Generate the rule files for each target.
const cmTargets& targets = lg->GetMakefile()->GetTargets();
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t)
cmTargets& targets = lg->GetMakefile()->GetTargets();
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
{
if((t->second.GetType() == cmTarget::EXECUTABLE) ||
(t->second.GetType() == cmTarget::STATIC_LIBRARY) ||
@ -767,9 +767,9 @@ cmGlobalUnixMakefileGenerator3
depends.push_back("cmake_check_build_system");
// for each target Generate the rule files for each target.
const cmTargets& targets = lg->GetMakefile()->GetTargets();
cmTargets& targets = lg->GetMakefile()->GetTargets();
bool needRequiresStep = this->NeedRequiresStep(lg);
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t)
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
{
if (((t->second.GetType() == cmTarget::EXECUTABLE) ||
(t->second.GetType() == cmTarget::STATIC_LIBRARY) ||
@ -870,7 +870,7 @@ cmGlobalUnixMakefileGenerator3
void
cmGlobalUnixMakefileGenerator3
::AppendGlobalTargetDepends(std::vector<std::string>& depends,
const cmTarget& target)
cmTarget& target)
{
// Keep track of dependencies already listed.
std::set<cmStdString> emitted;
@ -964,8 +964,8 @@ cmGlobalUnixMakefileGenerator3::WriteHelpRule(std::ostream& ruleFileStream)
lg = static_cast<cmLocalUnixMakefileGenerator3 *>(m_LocalGenerators[i]);
// for each target Generate the rule files for each target.
const cmTargets& targets = lg->GetMakefile()->GetTargets();
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t)
cmTargets& targets = lg->GetMakefile()->GetTargets();
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
{
if((t->second.GetType() == cmTarget::EXECUTABLE) ||
(t->second.GetType() == cmTarget::STATIC_LIBRARY) ||

2
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -106,7 +106,7 @@ protected:
cmLocalUnixMakefileGenerator3 *lg);
void AppendGlobalTargetDepends(std::vector<std::string>& depends,
const cmTarget& target);
cmTarget& target);
void AppendAnyGlobalDepend(std::vector<std::string>& depends,
const char* name);

7
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -247,9 +247,8 @@ void cmGlobalVisualStudio6Generator::WriteDSWFile(std::ostream& fout,
unsigned int j;
for(j = 0; j < generators.size(); ++j)
{
const cmTargets &atgts =
generators[j]->GetMakefile()->GetTargets();
for(cmTargets::const_iterator al = atgts.begin();
cmTargets &atgts = generators[j]->GetMakefile()->GetTargets();
for(cmTargets::iterator al = atgts.begin();
al != atgts.end(); ++al)
{
if (al->second.IsInAll())
@ -368,7 +367,7 @@ void cmGlobalVisualStudio6Generator::OutputDSWFile()
void cmGlobalVisualStudio6Generator::WriteProject(std::ostream& fout,
const char* dspname,
const char* dir,
const cmTarget& target)
cmTarget& target)
{
fout << "#########################################################"
"######################\n\n";

3
Source/cmGlobalVisualStudio6Generator.h
View File

@ -79,8 +79,7 @@ private:
void WriteDSWFile(std::ostream& fout);
void WriteDSWHeader(std::ostream& fout);
void WriteProject(std::ostream& fout,
const char* name, const char* path,
const cmTarget &t);
const char* name, const char* path, cmTarget &t);
void WriteExternalProject(std::ostream& fout,
const char* name, const char* path,
const std::vector<std::string>& dependencies);

10
Source/cmGlobalVisualStudio71Generator.cxx
View File

@ -96,9 +96,8 @@ void cmGlobalVisualStudio71Generator::WriteSLNFile(std::ostream& fout,
unsigned int j;
for(j = 0; j < generators.size(); ++j)
{
const cmTargets &atgts =
generators[j]->GetMakefile()->GetTargets();
for(cmTargets::const_iterator al = atgts.begin();
cmTargets &atgts = generators[j]->GetMakefile()->GetTargets();
for(cmTargets::iterator al = atgts.begin();
al != atgts.end(); ++al)
{
if (al->second.IsInAll())
@ -229,7 +228,7 @@ void
cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
const char* dspname,
const char* dir,
const cmTarget& t)
cmTarget& t)
{
std::string d = cmSystemTools::ConvertToOutputPath(dir);
fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \""
@ -252,8 +251,7 @@ void
cmGlobalVisualStudio71Generator
::WriteProjectDepends(std::ostream& fout,
const char* dspname,
const char*,
const cmTarget& target)
const char*, cmTarget& target)
{
// insert Begin Project Dependency Project_Dep_Name project stuff here
if (target.GetType() != cmTarget::STATIC_LIBRARY)

6
Source/cmGlobalVisualStudio71Generator.h
View File

@ -47,11 +47,9 @@ protected:
cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
virtual void WriteProject(std::ostream& fout,
const char* name, const char* path,
const cmTarget &t);
const char* name, const char* path, cmTarget &t);
virtual void WriteProjectDepends(std::ostream& fout,
const char* name, const char* path,
const cmTarget &t);
const char* name, const char* path, cmTarget &t);
virtual void WriteProjectConfigurations(std::ostream& fout, const char* name, bool in_all);
virtual void WriteExternalProject(std::ostream& fout, const char* name, const char* path,
const std::vector<std::string>& depends);

11
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -312,9 +312,8 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout,
unsigned int j;
for(j = 0; j < generators.size(); ++j)
{
const cmTargets &atgts =
generators[j]->GetMakefile()->GetTargets();
for(cmTargets::const_iterator al = atgts.begin();
cmTargets &atgts = generators[j]->GetMakefile()->GetTargets();
for(cmTargets::iterator al = atgts.begin();
al != atgts.end(); ++al)
{
if (al->second.IsInAll())
@ -498,8 +497,7 @@ void cmGlobalVisualStudio7Generator::WriteSLNFile(std::ostream& fout,
// the libraries it uses are also done here
void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout,
const char* dspname,
const char* dir,
const cmTarget&)
const char* dir, cmTarget&)
{
std::string d = cmSystemTools::ConvertToOutputPath(dir);
fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \""
@ -517,8 +515,7 @@ void
cmGlobalVisualStudio7Generator
::WriteProjectDepends(std::ostream& fout,
const char* dspname,
const char*,
const cmTarget& target)
const char*, cmTarget& target)
{
int depcount = 0;
// insert Begin Project Dependency Project_Dep_Name project stuff here

6
Source/cmGlobalVisualStudio7Generator.h
View File

@ -86,11 +86,9 @@ protected:
virtual void WriteSLNFile(std::ostream& fout, cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
virtual void WriteProject(std::ostream& fout,
const char* name, const char* path,
const cmTarget &t);
const char* name, const char* path, cmTarget &t);
virtual void WriteProjectDepends(std::ostream& fout,
const char* name, const char* path,
const cmTarget &t);
const char* name, const char* path, cmTarget &t);
virtual void WriteProjectConfigurations(std::ostream& fout, const char* name, bool in_all);
virtual void WriteSLNFooter(std::ostream& fout);
virtual void WriteSLNHeader(std::ostream& fout);

8
Source/cmLocalGenerator.cxx
View File

@ -190,7 +190,7 @@ void cmLocalGenerator::GenerateTestFiles()
void cmLocalGenerator::GenerateInstallRules()
{
const cmTargets &tgts = m_Makefile->GetTargets();
cmTargets &tgts = m_Makefile->GetTargets();
const char* prefix
= m_Makefile->GetDefinition("CMAKE_INSTALL_PREFIX");
#if defined(_WIN32) && !defined(__CYGWIN__)
@ -283,7 +283,7 @@ void cmLocalGenerator::GenerateInstallRules()
}
std::string destination;
for(cmTargets::const_iterator l = tgts.begin();
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++)
{
const char* preinstall = l->second.GetProperty("PRE_INSTALL_SCRIPT");
@ -1164,8 +1164,8 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
* to the name of the library. This will not link a library against itself.
*/
void cmLocalGenerator::OutputLinkLibraries(std::ostream& fout,
const char* targetLibrary,
const cmTarget &tgt)
const char* targetLibrary,
cmTarget &tgt)
{
// Try to emit each search path once
std::set<cmStdString> emitted;

2
Source/cmLocalGenerator.h
View File

@ -154,7 +154,7 @@ protected:
cmTarget&target);
///! put all the libraries for a target on into the given stream
virtual void OutputLinkLibraries(std::ostream&, const char* name, const cmTarget &);
virtual void OutputLinkLibraries(std::ostream&, const char* name,cmTarget &);
/** Get the include flags for the current makefile and language. */

44
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -160,7 +160,7 @@ void cmLocalUnixMakefileGenerator3::FormatOutputPath(std::string& path,
void cmLocalUnixMakefileGenerator3
::WriteCustomCommands(const cmTarget &target,std::ostream& ruleFileStream,
::WriteCustomCommands(cmTarget &target,std::ostream& ruleFileStream,
std::vector<std::string>& cleanFiles)
{
std::string tgtDir = m_Makefile->GetStartOutputDirectory();
@ -303,7 +303,7 @@ const std::string &cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteTargetRuleFiles(const cmTarget& target)
::WriteTargetRuleFiles(cmTarget& target)
{
// Create a directory for this target.
std::string dir = this->GetTargetDirectory(target);
@ -496,7 +496,7 @@ void
cmLocalUnixMakefileGenerator3
::WriteObjectBuildFile(std::string &obj,
const char *lang,
const cmTarget& target,
cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& depends,
std::string &depMakeFile)
@ -649,7 +649,7 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteObjectRuleFiles(const cmTarget& target, const cmSourceFile& source,
::WriteObjectRuleFiles(cmTarget& target, const cmSourceFile& source,
std::vector<std::string>& objects)
{
// Identify the language of the source file.
@ -771,7 +771,7 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteUtilityRuleFiles(const cmTarget& target)
::WriteUtilityRuleFiles(cmTarget& target)
{
// Create a directory for this target.
std::string dir = this->GetTargetDirectory(target);
@ -1253,7 +1253,7 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmLocalUnixMakefileGenerator3
::WriteTargetRequiresRule(std::ostream& ruleFileStream, const cmTarget& target,
::WriteTargetRequiresRule(std::ostream& ruleFileStream, cmTarget& target,
const std::vector<std::string>& objects)
{
std::vector<std::string> depends;
@ -1285,7 +1285,7 @@ void
cmLocalUnixMakefileGenerator3
::WriteExecutableRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
@ -1468,7 +1468,7 @@ void
cmLocalUnixMakefileGenerator3
::WriteStaticLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
@ -1494,7 +1494,7 @@ void
cmLocalUnixMakefileGenerator3
::WriteSharedLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
@ -1536,7 +1536,7 @@ void
cmLocalUnixMakefileGenerator3
::WriteModuleLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles)
@ -1564,7 +1564,7 @@ void
cmLocalUnixMakefileGenerator3
::WriteLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const char* linkRuleVar,
@ -1793,7 +1793,7 @@ cmLocalUnixMakefileGenerator3
void
cmLocalUnixMakefileGenerator3
::WriteObjectsVariable(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::string& variableName,
@ -1844,7 +1844,7 @@ cmLocalUnixMakefileGenerator3
void
cmLocalUnixMakefileGenerator3
::WriteTargetDependRule(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects)
{
std::vector<std::string> depends;
@ -1875,7 +1875,7 @@ cmLocalUnixMakefileGenerator3
void
cmLocalUnixMakefileGenerator3
::WriteTargetCleanRule(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& files)
{
std::vector<std::string> no_depends;
@ -1922,7 +1922,7 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3::GetTargetDirectory(const cmTarget& target)
cmLocalUnixMakefileGenerator3::GetTargetDirectory(cmTarget& target)
{
std::string dir = target.GetName();
dir += ".dir";
@ -1931,7 +1931,7 @@ cmLocalUnixMakefileGenerator3::GetTargetDirectory(const cmTarget& target)
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory(const cmTarget& target)
cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory(cmTarget& target)
{
std::string dir = m_Makefile->GetStartOutputDirectory();
dir += "/";
@ -1978,7 +1978,7 @@ cmLocalUnixMakefileGenerator3
//----------------------------------------------------------------------------
std::string
cmLocalUnixMakefileGenerator3
::GetObjectFileName(const cmTarget& target,
::GetObjectFileName(cmTarget& target,
const cmSourceFile& source)
{
// If the full path to the source file includes this directory,
@ -2087,7 +2087,7 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p)
void
cmLocalUnixMakefileGenerator3
::AppendTargetDepends(std::vector<std::string>& depends,
const cmTarget& target)
cmTarget& target)
{
// Do not bother with dependencies for static libraries.
if(target.GetType() == cmTarget::STATIC_LIBRARY)
@ -2799,13 +2799,13 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
// now write out the object rules
// for each object file name
for (std::map<cmStdString,std::vector<const cmTarget *> >::iterator lo =
for (std::map<cmStdString,std::vector<cmTarget *> >::iterator lo =
m_LocalObjectFiles.begin();
lo != m_LocalObjectFiles.end(); ++lo)
{
commands.clear();
// for each target using the object file
for (std::vector<const cmTarget *>::iterator to =
for (std::vector<cmTarget *>::iterator to =
lo->second.begin(); to != lo->second.end(); ++to)
{
std::string tgtMakefileName = this->GetRelativeTargetDirectory(**to);
@ -2829,9 +2829,9 @@ void cmLocalUnixMakefileGenerator3
// for each target we just provide a rule to cd up to the top and do a make
// on the target
const cmTargets& targets = m_Makefile->GetTargets();
cmTargets& targets = m_Makefile->GetTargets();
std::string localName;
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t)
for(cmTargets::iterator t = targets.begin(); t != targets.end(); ++t)
{
if((t->second.GetType() == cmTarget::EXECUTABLE) ||
(t->second.GetType() == cmTarget::STATIC_LIBRARY) ||

40
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -135,7 +135,7 @@ public:
void WriteSpecialTargetsTop(std::ostream& makefileStream);
void WriteSpecialTargetsBottom(std::ostream& makefileStream);
std::string GetRelativeTargetDirectory(const cmTarget& target);
std::string GetRelativeTargetDirectory(cmTarget& target);
// List the files for which to check dependency integrity. Each
// language has its own list because integrity may be checked
@ -145,10 +145,10 @@ public:
{ return m_CheckDependFiles;}
void AppendTargetDepends(std::vector<std::string>& depends,
const cmTarget& target);
cmTarget& target);
void AppendGlobalTargetDepends(std::vector<std::string>& depends,
const cmTarget& target);
cmTarget& target);
void AppendEcho(std::vector<std::string>& commands,
const char* text);
@ -174,7 +174,7 @@ protected:
// this is responsible for writing all of the rules for all this
// directories custom commands (but not utility targets)
void WriteCustomCommands(const cmTarget &target,std::ostream& os,
void WriteCustomCommands(cmTarget &target,std::ostream& os,
std::vector<std::string>& cleanFiles);
// this method Writes the Directory informaiton files
@ -187,18 +187,18 @@ protected:
void WriteCMakeArgument(std::ostream& os, const char* s);
// write out all the rules for this target
void WriteTargetRuleFiles(const cmTarget& target);
void WriteUtilityRuleFiles(const cmTarget& target);
void WriteTargetRuleFiles(cmTarget& target);
void WriteUtilityRuleFiles(cmTarget& target);
// create the rule files for an object
void WriteObjectRuleFiles(const cmTarget& target,
void WriteObjectRuleFiles(cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& objects);
// write the build rule for an object
void WriteObjectBuildFile(std::string &obj,
const char *lang,
const cmTarget& target,
cmTarget& target,
const cmSourceFile& source,
std::vector<std::string>& depends,
std::string &depMakeFile);
@ -230,21 +230,21 @@ protected:
// these three make some simple changes and then call WriteLibraryRule
void WriteStaticLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles);
void WriteSharedLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles);
void WriteModuleLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles);
@ -252,7 +252,7 @@ protected:
// the main code for writing the Executable target rules
void WriteExecutableRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::vector<std::string>& cleanFiles);
@ -260,7 +260,7 @@ protected:
// the main method for writing library rules
void WriteLibraryRule(std::ostream& ruleFileStream,
const char* ruleFileName,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
const char* linkRuleVar,
@ -278,24 +278,24 @@ protected:
const char* realTarget,
const char* helpTarget);
void WriteObjectsVariable(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects,
const std::vector<std::string>& external_objects,
std::string& variableName,
std::string& variableNameExternal);
void WriteTargetDependRule(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects);
void WriteTargetCleanRule(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& files);
void WriteTargetRequiresRule(std::ostream& ruleFileStream,
const cmTarget& target,
cmTarget& target,
const std::vector<std::string>& objects);
std::string GetTargetDirectory(const cmTarget& target);
std::string GetTargetDirectory(cmTarget& target);
std::string GetSubdirTargetName(const char* pass, const char* subdir);
std::string GetObjectFileName(const cmTarget& target,
std::string GetObjectFileName(cmTarget& target,
const cmSourceFile& source);
const char* GetSourceFileLanguage(const cmSourceFile& source);
std::string ConvertToQuotedOutputPath(const char* p);
@ -347,7 +347,7 @@ private:
// Set of object file names that will be built in this directory.
std::set<cmStdString> m_ObjectFiles;
std::map<cmStdString,std::vector<const cmTarget *> > m_LocalObjectFiles;
std::map<cmStdString,std::vector<cmTarget *> > m_LocalObjectFiles;
};
#endif

7
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -562,7 +562,7 @@ void cmLocalVisualStudio6Generator::WriteDSPEndGroup(std::ostream& fout)
void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
const char* libName,
const cmTarget& target)
cmTarget& target)
{
std::string root= m_Makefile->GetRequiredDefinition("CMAKE_ROOT");
const char *def= m_Makefile->GetDefinition( "MSPROJECT_TEMPLATE_DIRECTORY");
@ -640,7 +640,7 @@ void cmLocalVisualStudio6Generator::SetBuildType(BuildType b,
// look for custom rules on a target and collect them together
std::string
cmLocalVisualStudio6Generator::CreateTargetRules(const cmTarget &target,
cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
const char * /* libName */)
{
std::string customRuleCode = "";
@ -741,8 +741,7 @@ inline std::string removeQuotes(const std::string& s)
void cmLocalVisualStudio6Generator
::WriteDSPHeader(std::ostream& fout,
const char *libName,
const cmTarget &target,
const char *libName, cmTarget &target,
std::vector<cmSourceGroup> &)
{
std::set<std::string> pathEmitted;

6
Source/cmLocalVisualStudio6Generator.h
View File

@ -51,7 +51,7 @@ public:
/**
* Specify the type of the build: static, dll, or executable.
*/
void SetBuildType(BuildType, const char* libName, const cmTarget&);
void SetBuildType(BuildType, const char* libName, cmTarget&);
/**
* Return array of created DSP names in a STL vector.
@ -76,7 +76,7 @@ private:
void WriteDSPEndGroup(std::ostream& fout);
void WriteDSPHeader(std::ostream& fout, const char *libName,
const cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
void WriteDSPFooter(std::ostream& fout);
void AddDSPBuildRule();
@ -91,7 +91,7 @@ private:
std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines);
std::string CreateTargetRules(const cmTarget &target,
std::string CreateTargetRules(cmTarget &target,
const char *libName);
std::string m_IncludeOptions;
std::vector<std::string> m_Configurations;

18
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -183,7 +183,7 @@ void cmLocalVisualStudio7Generator::AddVCProjBuildRule()
void cmLocalVisualStudio7Generator::WriteConfigurations(std::ostream& fout,
const char *libName,
const cmTarget &target)
cmTarget &target)
{
std::vector<std::string> *configs =
static_cast<cmGlobalVisualStudio7Generator *>(m_GlobalGenerator)->GetConfigurations();
@ -287,7 +287,7 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] =
void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
const char* configName,
const char *libName,
const cmTarget &target)
cmTarget &target)
{
// create a map of xml tags to the values they should have in the output
// for example, "BufferSecurityCheck" = "TRUE"
@ -576,7 +576,7 @@ void cmLocalVisualStudio7Generator::FillFlagMapFromCommandFlags(
void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
const char* configName,
const char *libName,
const cmTarget &target)
cmTarget &target)
{
std::string temp;
std::string debugPostfix = "";
@ -794,7 +794,7 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
}
void cmLocalVisualStudio7Generator::OutputModuleDefinitionFile(std::ostream& fout,
const cmTarget &target)
cmTarget &target)
{
std::vector<cmSourceFile*> const& classes = target.GetSourceFiles();
for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
@ -814,7 +814,7 @@ void cmLocalVisualStudio7Generator::OutputModuleDefinitionFile(std::ostream& fou
void cmLocalVisualStudio7Generator::OutputLibraryDirectories(std::ostream& fout,
const char*,
const char*,
const cmTarget &tgt)
cmTarget &tgt)
{
bool hasone = false;
if(m_LibraryOutputPath.size())
@ -867,7 +867,7 @@ void cmLocalVisualStudio7Generator::OutputLibraryDirectories(std::ostream& fout,
void cmLocalVisualStudio7Generator::OutputLibraries(std::ostream& fout,
const char* configName,
const char* libName,
const cmTarget &target)
cmTarget &target)
{
const cmTarget::LinkLibraries& libs = target.GetLinkLibraries();
cmTarget::LinkLibraries::const_iterator j;
@ -1224,8 +1224,8 @@ void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout)
// look for custom rules on a target and collect them together
void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout,
const cmTarget &target,
const char * /* libName */)
cmTarget &target,
const char * /*libName*/)
{
if (target.GetType() > cmTarget::UTILITY)
{
@ -1299,7 +1299,7 @@ void cmLocalVisualStudio7Generator::OutputTargetRules(std::ostream& fout,
void
cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
const char *libName,
const cmTarget &,
cmTarget &,
std::vector<cmSourceGroup> &)
{
fout << "<?xml version=\"1.0\" encoding = \"Windows-1252\"?>\n"

23
Source/cmLocalVisualStudio7Generator.h
View File

@ -69,41 +69,36 @@ private:
std::string& flags);
void OutputVCProjFile();
void WriteVCProjHeader(std::ostream& fout, const char *libName,
const cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
void WriteVCProjFooter(std::ostream& fout);
void CreateSingleVCProj(const char *lname, cmTarget &tgt);
void WriteVCProjFile(std::ostream& fout, const char *libName,
cmTarget &tgt);
void AddVCProjBuildRule();
void WriteConfigurations(std::ostream& fout,
const char *libName,
const cmTarget &tgt);
const char *libName, cmTarget &tgt);
void WriteConfiguration(std::ostream& fout,
const char* configName,
const char* libName,
const cmTarget &tgt);
const char* libName, cmTarget &tgt);
std::string EscapeForXML(const char* s);
std::string ConvertToXMLOutputPath(const char* path);
std::string ConvertToXMLOutputPathSingle(const char* path);
void OutputDefineFlags(const char* flags,
std::ostream& fout);
void OutputTargetRules(std::ostream& fout,
const cmTarget &target,
void OutputTargetRules(std::ostream& fout, cmTarget &target,
const char *libName);
void OutputBuildTool(std::ostream& fout, const char* configName,
const char* libname, const cmTarget& t);
const char* libname, cmTarget& t);
void OutputLibraries(std::ostream& fout,
const char* configName,
const char* libName,
const cmTarget &target);
cmTarget &target);
void OutputLibraryDirectories(std::ostream& fout,
const char* configName,
const char* libName,
const cmTarget &target);
void OutputModuleDefinitionFile(std::ostream& fout,
const cmTarget &target);
const char* libName, cmTarget &target);
void OutputModuleDefinitionFile(std::ostream& fout, cmTarget &target);
void WriteProjectStart(std::ostream& fout, const char *libName,
const cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
cmTarget &tgt, std::vector<cmSourceGroup> &sgs);
void WriteVCProjBeginGroup(std::ostream& fout,
const char* group,
const char* filter);

6
Source/cmMakeDepend.cxx
View File

@ -49,7 +49,7 @@ cmMakeDepend::~cmMakeDepend()
// The pointer is kept so the cmSourceFile array can
// be updated with the depend information in the cmMakefile.
void cmMakeDepend::SetMakefile(const cmMakefile* makefile)
void cmMakeDepend::SetMakefile(cmMakefile* makefile)
{
m_Makefile = makefile;
@ -264,8 +264,8 @@ cmDependInformation* cmMakeDepend::GetDependInformation(const char* file,
void cmMakeDepend::GenerateMakefileDependencies()
{
// Now create cmDependInformation objects for files in the directory
const cmTargets &tgts = m_Makefile->GetTargets();
for(cmTargets::const_iterator l = tgts.begin();
cmTargets &tgts = m_Makefile->GetTargets();
for(cmTargets::iterator l = tgts.begin();
l != tgts.end(); l++)
{
const std::vector<cmSourceFile*> &classes = l->second.GetSourceFiles();

4
Source/cmMakeDepend.h
View File

@ -94,7 +94,7 @@ public:
/**
* Set the makefile that is used as a source of classes.
*/
virtual void SetMakefile(const cmMakefile* makefile);
virtual void SetMakefile(cmMakefile* makefile);
/**
* Get the depend info struct for a source file
@ -153,7 +153,7 @@ protected:
*/
std::string FullPath(const char *filename, const char *extraPath);
const cmMakefile* m_Makefile;
cmMakefile* m_Makefile;
bool m_Verbose;
cmsys::RegularExpression m_IncludeFileRegularExpression;
cmsys::RegularExpression m_ComplainFileRegularExpression;

49
Source/cmMakefile.cxx
View File

@ -179,13 +179,13 @@ void cmMakefile::PrintStringVector(const char* s, const std::vector<std::pair<cm
// call print on all the classes in the makefile
void cmMakefile::Print() const
void cmMakefile::Print()
{
// print the class lists
std::cout << "classes:\n";
std::cout << " m_Targets: ";
for (cmTargets::const_iterator l = m_Targets.begin();
for (cmTargets::iterator l = m_Targets.begin();
l != m_Targets.end(); l++)
{
std::cout << l->first << std::endl;
@ -1078,9 +1078,9 @@ void cmMakefile::AddLibrary(const char* lname, int shared,
target.ClearDependencyInformation( *this, lname );
target.SetInAll(true);
target.GetSourceLists() = srcs;
target.SetMakefile(this);
this->AddGlobalLinkInformation(lname, target);
cmTargets::iterator it =
m_Targets.insert(cmTargets::value_type(lname,target)).first;
m_Targets.insert(cmTargets::value_type(lname,target));
// Add an entry into the cache
std::string libPath = lname;
@ -1090,26 +1090,6 @@ void cmMakefile::AddLibrary(const char* lname, int shared,
this->GetCurrentOutputDirectory(),
"Path to a library", cmCacheManager::INTERNAL);
// set the LOCATION property of the target
std::string target_location;
target_location = this->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
if ( target_location.size() == 0 )
{
target_location += this->GetCurrentOutputDirectory();
}
if ( target_location.size() > 0 )
{
target_location += "/";
}
const char* cfgid = this->GetDefinition("CMAKE_CFG_INTDIR");
if ( cfgid && strcmp(cfgid, ".") != 0 )
{
target_location += cfgid;
target_location += "/";
}
target_location += target.GetFullName(this);
it->second.SetProperty("LOCATION",target_location.c_str());
// Add an entry into the cache
std::string ltname = lname;
ltname += "_LIBRARY_TYPE";
@ -1150,30 +1130,11 @@ cmTarget* cmMakefile::AddExecutable(const char *exeName,
target.SetType(cmTarget::EXECUTABLE, exeName);
target.SetInAll(true);
target.GetSourceLists() = srcs;
target.SetMakefile(this);
this->AddGlobalLinkInformation(exeName, target);
cmTargets::iterator it =
m_Targets.insert(cmTargets::value_type(exeName,target)).first;
// set the LOCATION property of the target
std::string target_location;
target_location = this->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
if ( target_location.size() == 0 )
{
target_location += this->GetCurrentOutputDirectory();
}
if ( target_location.size() > 0 )
{
target_location += "/";
}
const char* cfgid = this->GetDefinition("CMAKE_CFG_INTDIR");
if ( cfgid && strcmp(cfgid, ".") != 0 )
{
target_location += cfgid;
target_location += "/";
}
target_location += target.GetFullName(this);
it->second.SetProperty("LOCATION",target_location.c_str());
// Add an entry into the cache
std::string exePath = exeName;
exePath += "_CMAKE_PATH";

3
Source/cmMakefile.h
View File

@ -131,7 +131,7 @@ public:
/**
* Print the object state to std::cout.
*/
void Print() const;
void Print();
/** Add a custom command to the build. */
void AddCustomCommandToTarget(const char* target,
@ -417,7 +417,6 @@ public:
* Get the list of targets
*/
cmTargets &GetTargets() { return m_Targets; }
const cmTargets &GetTargets() const { return m_Targets; }
cmTarget* FindTarget(const char* name);

2
Source/cmOrderLinkDirectories.cxx
View File

@ -214,7 +214,7 @@ void cmOrderLinkDirectories::OrderPaths(std::vector<cmStdString>&
}
//-------------------------------------------------------------------
void cmOrderLinkDirectories::SetLinkInformation(const cmTarget& target,
void cmOrderLinkDirectories::SetLinkInformation(cmTarget& target,
cmTarget::LinkLibraryType
linktype,
const char* targetLibrary)

2
Source/cmOrderLinkDirectories.h
View File

@ -49,7 +49,7 @@ class cmOrderLinkDirectories
public:
cmOrderLinkDirectories();
///! set link information from the target
void SetLinkInformation(const cmTarget&, cmTarget::LinkLibraryType,
void SetLinkInformation(cmTarget&, cmTarget::LinkLibraryType,
const char* targetLibrary);
///! Compute the best order for -L paths from GetLinkLibraries
bool DetermineLibraryPathOrder();

78
Source/cmTarget.cxx
View File

@ -554,14 +554,14 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
void cmTarget::InsertDependency( DependencyMap& depMap,
const cmStdString& lib,
const cmStdString& dep ) const
const cmStdString& dep )
{
depMap[lib].push_back(dep);
}
void cmTarget::DeleteDependency( DependencyMap& depMap,
const cmStdString& lib,
const cmStdString& dep ) const
const cmStdString& dep )
{
// Make sure there is an entry in the map for lib. If so, delete all
// dependencies to dep. There may be repeated entries because of
@ -582,7 +582,7 @@ void cmTarget::Emit( const std::string& lib,
const DependencyMap& dep_map,
std::set<cmStdString>& emitted,
std::set<cmStdString>& visited,
std::vector<std::string>& link_line ) const
std::vector<std::string>& link_line )
{
// It's already been emitted
if( emitted.find(lib) != emitted.end() )
@ -691,8 +691,52 @@ void cmTarget::SetProperty(const char* prop, const char* value)
m_Properties[prop] = value;
}
const char *cmTarget::GetProperty(const char* prop) const
void cmTarget::UpdateLocation()
{
// set the LOCATION property of the target
std::string target_location;
switch( this->GetType() )
{
case cmTarget::STATIC_LIBRARY:
case cmTarget::MODULE_LIBRARY:
case cmTarget::SHARED_LIBRARY:
target_location =
m_Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
break;
case cmTarget::EXECUTABLE:
target_location =
m_Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
break;
default:
return;
}
if ( target_location.size() == 0 )
{
target_location += m_Makefile->GetCurrentOutputDirectory();
}
if ( target_location.size() > 0 )
{
target_location += "/";
}
const char* cfgid = m_Makefile->GetDefinition("CMAKE_CFG_INTDIR");
if ( cfgid && strcmp(cfgid, ".") != 0 )
{
target_location += cfgid;
target_location += "/";
}
target_location += this->GetFullName(m_Makefile);
this->SetProperty("LOCATION",target_location.c_str());
}
const char *cmTarget::GetProperty(const char* prop)
{
// watch for special "computed" properties that are dependent on other
// properties or variables, always recompute them
if (!strcmp(prop,"LOCATION"))
{
this->UpdateLocation();
}
std::map<cmStdString,cmStdString>::const_iterator i =
m_Properties.find(prop);
if (i != m_Properties.end())
@ -702,7 +746,7 @@ const char *cmTarget::GetProperty(const char* prop) const
return 0;
}
bool cmTarget::GetPropertyAsBool(const char* prop) const
bool cmTarget::GetPropertyAsBool(const char* prop)
{
std::map<cmStdString,cmStdString>::const_iterator i =
m_Properties.find(prop);
@ -713,7 +757,7 @@ bool cmTarget::GetPropertyAsBool(const char* prop) const
return false;
}
const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg) const
const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
{
if(this->GetProperty("HAS_CXX"))
{
@ -795,12 +839,12 @@ const char* cmTarget::GetCreateRuleVariable()
return "";
}
const char* cmTarget::GetSuffixVariable() const
const char* cmTarget::GetSuffixVariable()
{
return this->GetSuffixVariableInternal(this->GetType());
}
const char* cmTarget::GetSuffixVariableInternal(TargetType type) const
const char* cmTarget::GetSuffixVariableInternal(TargetType type)
{
switch(type)
{
@ -821,12 +865,12 @@ const char* cmTarget::GetSuffixVariableInternal(TargetType type) const
}
const char* cmTarget::GetPrefixVariable() const
const char* cmTarget::GetPrefixVariable()
{
return this->GetPrefixVariableInternal(this->GetType());
}
const char* cmTarget::GetPrefixVariableInternal(TargetType type) const
const char* cmTarget::GetPrefixVariableInternal(TargetType type)
{
switch(type)
{
@ -846,13 +890,13 @@ const char* cmTarget::GetPrefixVariableInternal(TargetType type) const
return "";
}
std::string cmTarget::GetFullName(cmMakefile* mf) const
std::string cmTarget::GetFullName(cmMakefile* mf)
{
return this->GetFullNameInternal(mf, this->GetType());
}
std::string cmTarget::GetFullNameInternal(cmMakefile* mf,
TargetType type) const
TargetType type)
{
const char* targetPrefix = this->GetProperty("PREFIX");
const char* targetSuffix = this->GetProperty("SUFFIX");
@ -896,13 +940,13 @@ std::string cmTarget::GetFullNameInternal(cmMakefile* mf,
return name;
}
std::string cmTarget::GetBaseName(cmMakefile* mf) const
std::string cmTarget::GetBaseName(cmMakefile* mf)
{
return this->GetBaseNameInternal(mf, this->GetType());
}
std::string
cmTarget::GetBaseNameInternal(cmMakefile* mf, TargetType type) const
cmTarget::GetBaseNameInternal(cmMakefile* mf, TargetType type)
{
std::string pathPrefix = "";
#ifdef __APPLE__
@ -942,7 +986,7 @@ void cmTarget::GetLibraryNames(cmMakefile* mf,
std::string& name,
std::string& soName,
std::string& realName,
std::string& baseName) const
std::string& baseName)
{
// Get the names based on the real type of the library.
this->GetLibraryNamesInternal(mf, name, soName, realName, this->GetType());
@ -955,7 +999,7 @@ void cmTarget::GetLibraryCleanNames(cmMakefile* mf,
std::string& staticName,
std::string& sharedName,
std::string& sharedSOName,
std::string& sharedRealName) const
std::string& sharedRealName)
{
// Get the name as if this were a static library.
std::string soName;
@ -986,7 +1030,7 @@ void cmTarget::GetLibraryNamesInternal(cmMakefile* mf,
std::string& name,
std::string& soName,
std::string& realName,
TargetType type) const
TargetType type)
{
// Construct the name of the soname flag variable for this language.
const char* ll =

75
Source/cmTarget.h
View File

@ -41,7 +41,7 @@ public:
/**
* Return the type of target.
*/
TargetType GetType() const
TargetType GetType()
{
return m_TargetType;
}
@ -52,43 +52,36 @@ public:
void SetType(TargetType f, const char* name);
///! Set/Get the name of the target
const char* GetName() const {return m_Name.c_str();}
const char* GetName() {return m_Name.c_str();}
/**
* Indicate whether the target is part of the all target
*/
bool IsInAll() const { return this->GetPropertyAsBool("IN_ALL"); }
bool GetInAll() const { return this->GetPropertyAsBool("IN_ALL"); }
void SetInAll(bool f) { this->SetProperty("IN_ALL", (f) ? "TRUE" : "FALSE"); }
bool IsInAll() { return this->GetPropertyAsBool("IN_ALL"); }
bool GetInAll() { return this->GetPropertyAsBool("IN_ALL"); }
void SetInAll(bool f) { this->SetProperty("IN_ALL", (f) ?"TRUE" : "FALSE"); }
///! Set the cmMakefile that owns this target
void SetMakefile(cmMakefile *mf) { m_Makefile = mf; };
/**
* Get the list of the custom commands for this target
*/
const std::vector<cmCustomCommand> &GetPreBuildCommands() const
{return m_PreBuildCommands;}
std::vector<cmCustomCommand> &GetPreBuildCommands()
{return m_PreBuildCommands;}
const std::vector<cmCustomCommand> &GetPreLinkCommands() const
{return m_PreLinkCommands;}
std::vector<cmCustomCommand> &GetPreLinkCommands()
{return m_PreLinkCommands;}
const std::vector<cmCustomCommand> &GetPostBuildCommands() const
{return m_PostBuildCommands;}
std::vector<cmCustomCommand> &GetPostBuildCommands()
{return m_PostBuildCommands;}
/**
* Get the list of the source lists used by this target
*/
const std::vector<std::string> &GetSourceLists() const
{return m_SourceLists;}
std::vector<std::string> &GetSourceLists() {return m_SourceLists;}
/**
* Get the list of the source files used by this target
*/
const std::vector<cmSourceFile*> &GetSourceFiles() const
{return m_SourceFiles;}
std::vector<cmSourceFile*> &GetSourceFiles() {return m_SourceFiles;}
/**
@ -96,7 +89,7 @@ public:
*/
enum LinkLibraryType {GENERAL, DEBUG, OPTIMIZED};
typedef std::vector<std::pair<std::string,LinkLibraryType> > LinkLibraries;
const LinkLibraries &GetLinkLibraries() const {return m_LinkLibraries;}
const LinkLibraries &GetLinkLibraries() {return m_LinkLibraries;}
/**
* Clear the dependency information recorded for this target, if any.
@ -112,7 +105,8 @@ public:
void MergeLinkLibraries( cmMakefile& mf, const char* selfname, const LinkLibraries& libs );
const std::vector<std::string>& GetLinkDirectories() const {return m_LinkDirectories;}
const std::vector<std::string>& GetLinkDirectories()
{return m_LinkDirectories;}
void AddLinkDirectory(const char* d);
@ -120,14 +114,14 @@ public:
* Set the path where this target should be installed. This is relative to
* INSTALL_PREFIX
*/
std::string GetInstallPath() const {return m_InstallPath;}
std::string GetInstallPath() {return m_InstallPath;}
void SetInstallPath(const char *name) {m_InstallPath = name;}
/**
* Set the path where this target (if it has a runtime part) should be
* installed. This is relative to INSTALL_PREFIX
*/
std::string GetRuntimeInstallPath() const {return m_RuntimeInstallPath;}
std::string GetRuntimeInstallPath() {return m_RuntimeInstallPath;}
void SetRuntimeInstallPath(const char *name) {m_RuntimeInstallPath = name;}
/**
@ -142,14 +136,14 @@ public:
*/
void AddUtility(const char* u) { m_Utilities.insert(u);}
///! Get the utilities used by this target
std::set<cmStdString>const& GetUtilities() const { return m_Utilities; }
std::set<cmStdString>const& GetUtilities() { return m_Utilities; }
void AnalyzeLibDependencies( const cmMakefile& mf );
///! Set/Get a property of this target file
void SetProperty(const char *prop, const char *value);
const char *GetProperty(const char *prop) const;
bool GetPropertyAsBool(const char *prop) const;
const char *GetProperty(const char *prop);
bool GetPropertyAsBool(const char *prop);
/**
* Trace through the source files in this target and add al source files
@ -158,30 +152,30 @@ public:
void TraceVSDependencies(std::string projName, cmMakefile *mf);
///! Return the prefered linker language for this target
const char* GetLinkerLanguage(cmGlobalGenerator*) const;
const char* GetLinkerLanguage(cmGlobalGenerator*);
///! Return the rule variable used to create this type of target,
// need to add CMAKE_(LANG) for full name.
const char* GetCreateRuleVariable();
///! Return the name of the variable to look up the target suffix
const char* GetSuffixVariable() const;
const char* GetSuffixVariable();
///! Return the name of the variable to look up the target suffix
const char* GetPrefixVariable() const;
const char* GetPrefixVariable();
/** Get the full name of the target according to the settings in the
given makefile. */
std::string GetFullName(cmMakefile* mf) const;
std::string GetFullName(cmMakefile* mf);
/** Get the base name (no suffix) of the target according to the
settings in the given makefile. */
std::string GetBaseName(cmMakefile* mf) const;
std::string GetBaseName(cmMakefile* mf);
/** Get the names of the library needed to generate a build rule
that takes into account shared library version numbers. This
should be called only on a library target. */
void GetLibraryNames(cmMakefile* mf, std::string& name,
std::string& soName, std::string& realName,
std::string& baseName) const;
std::string& baseName);
/** Get the names of the library used to remove existing copies of
the library from the build tree either before linking or during
@ -191,7 +185,7 @@ public:
std::string& staticName,
std::string& sharedName,
std::string& sharedSOName,
std::string& sharedRealName) const;
std::string& sharedRealName);
private:
/**
* A list of direct dependencies. Use in conjunction with DependencyMap.
@ -216,14 +210,14 @@ private:
*/
void InsertDependency( DependencyMap& depMap,
const cmStdString& lib,
const cmStdString& dep ) const;
const cmStdString& dep );
/*
* Deletes \a dep from the dependency list of \a lib.
*/
void DeleteDependency( DependencyMap& depMap,
const cmStdString& lib,
const cmStdString& dep ) const;
const cmStdString& dep );
/**
* Emits the library \a lib and all its dependencies into link_line.
@ -237,7 +231,7 @@ private:
const DependencyMap& dep_map,
std::set<cmStdString>& emitted,
std::set<cmStdString>& visited,
std::vector<std::string>& link_line ) const;
std::vector<std::string>& link_line );
/**
* Finds the dependencies for \a lib and inserts them into \a
@ -246,15 +240,19 @@ private:
void GatherDependencies( const cmMakefile& mf, const std::string& lib,
DependencyMap& dep_map );
const char* GetSuffixVariableInternal(TargetType type) const;
const char* GetPrefixVariableInternal(TargetType type) const;
std::string GetFullNameInternal(cmMakefile* mf, TargetType type) const;
std::string GetBaseNameInternal(cmMakefile* mf, TargetType type) const;
const char* GetSuffixVariableInternal(TargetType type);
const char* GetPrefixVariableInternal(TargetType type);
std::string GetFullNameInternal(cmMakefile* mf, TargetType type);
std::string GetBaseNameInternal(cmMakefile* mf, TargetType type);
void GetLibraryNamesInternal(cmMakefile* mf,
std::string& name,
std::string& soName,
std::string& realName,
TargetType type) const;
TargetType type);
// update the value of the LOCATION var
void UpdateLocation();
private:
std::string m_Name;
std::vector<cmCustomCommand> m_PreBuildCommands;
@ -271,6 +269,9 @@ private:
std::set<cmStdString> m_Utilities;
bool m_RecordDependencies;
std::map<cmStdString,cmStdString> m_Properties;
// the Makefile that owns this target
cmMakefile *m_Makefile;
};
typedef std::map<cmStdString,cmTarget> cmTargets;