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

STYLE: Fixed line-too-long, fixed indentation, removed trailing whitespace, added function separator comment lines.

This commit is contained in:
Brad King 2007-07-02 13:32:41 -04:00
parent 930bb0cd37
commit cac79e92b8
2 changed files with 246 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

377
Source/cmTarget.cxx
View File

@ -9,8 +9,8 @@
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information. PURPOSE. See the above copyright notices for more information.
=========================================================================*/ =========================================================================*/
@ -41,11 +41,11 @@ cmTarget::cmTarget()
this->IsImportedTarget = false; this->IsImportedTarget = false;
} }
// define properties //----------------------------------------------------------------------------
void cmTarget::DefineProperties(cmake *cm) void cmTarget::DefineProperties(cmake *cm)
{ {
cm->DefineProperty cm->DefineProperty
("BUILD_WITH_INSTALL_RPATH", cmProperty::TARGET, ("BUILD_WITH_INSTALL_RPATH", cmProperty::TARGET,
"Should build tree targets have install tree rpaths.", "Should build tree targets have install tree rpaths.",
"BUILD_WITH_INSTALL_RPATH is a boolean specifying whether to link " "BUILD_WITH_INSTALL_RPATH is a boolean specifying whether to link "
"the target in the build tree with the INSTALL_RPATH. This takes " "the target in the build tree with the INSTALL_RPATH. This takes "
@ -53,7 +53,7 @@ void cmTarget::DefineProperties(cmake *cm)
"before installation."); "before installation.");
cm->DefineProperty cm->DefineProperty
("CLEAN_DIRECT_OUTPUT", cmProperty::TARGET, ("CLEAN_DIRECT_OUTPUT", cmProperty::TARGET,
"Do not delete other varients of this target.", "Do not delete other varients of this target.",
"When a library is built CMake by default generates code to remove " "When a library is built CMake by default generates code to remove "
"any existing library using all possible names. This is needed " "any existing library using all possible names. This is needed "
@ -64,14 +64,14 @@ void cmTarget::DefineProperties(cmake *cm)
"prevented by setting the CLEAN_DIRECT_OUTPUT property to 1."); "prevented by setting the CLEAN_DIRECT_OUTPUT property to 1.");
cm->DefineProperty cm->DefineProperty
("COMPILE_FLAGS", cmProperty::TARGET, ("COMPILE_FLAGS", cmProperty::TARGET,
"Additional flags to yse when compiling this target's sources.", "Additional flags to yse when compiling this target's sources.",
"The COMPILE_FLAGS property sets additional compiler flags used " "The COMPILE_FLAGS property sets additional compiler flags used "
"to build sources within the target. It may also be used to pass " "to build sources within the target. It may also be used to pass "
"additional preprocessor definitions."); "additional preprocessor definitions.");
cm->DefineProperty cm->DefineProperty
("DEFINE_SYMBOL", cmProperty::TARGET, ("DEFINE_SYMBOL", cmProperty::TARGET,
"Define a symbol when compiling this target's sources.", "Define a symbol when compiling this target's sources.",
"DEFINE_SYMBOL sets the name of the preprocessor symbol defined when " "DEFINE_SYMBOL sets the name of the preprocessor symbol defined when "
"compiling sources in a shared library. " "compiling sources in a shared library. "
@ -80,29 +80,29 @@ void cmTarget::DefineProperties(cmake *cm)
"identifier). This is useful for headers to know whether they are " "identifier). This is useful for headers to know whether they are "
"being included from inside their library our outside to properly " "being included from inside their library our outside to properly "
"setup dllexport/dllimport decorations. "); "setup dllexport/dllimport decorations. ");
cm->DefineProperty cm->DefineProperty
("DEBUG_POSTFIX", cmProperty::TARGET, ("DEBUG_POSTFIX", cmProperty::TARGET,
"A postfix that will be applied to this target when build debug.", "A postfix that will be applied to this target when build debug.",
"A property on a target that sepcifies a postfix to add to the " "A property on a target that sepcifies a postfix to add to the "
"target name when built in debug mode. For example foo.dll " "target name when built in debug mode. For example foo.dll "
"versus fooD.dll"); "versus fooD.dll");
cm->DefineProperty cm->DefineProperty
("EchoString", cmProperty::TARGET, ("EchoString", cmProperty::TARGET,
"A message to be displayed when the target is built.", "A message to be displayed when the target is built.",
"A message to display on some generaters (such as makefiles) when " "A message to display on some generaters (such as makefiles) when "
"the target is built."); "the target is built.");
cm->DefineProperty cm->DefineProperty
("HAS_CXX", cmProperty::TARGET, ("HAS_CXX", cmProperty::TARGET,
"Force a target to use the CXX linker.", "Force a target to use the CXX linker.",
"Setting HAS_CXX on a target will force the target to use the " "Setting HAS_CXX on a target will force the target to use the "
"C++ linker (and C++ runtime libraries) for linking even if the " "C++ linker (and C++ runtime libraries) for linking even if the "
"target has no C++ code in it."); "target has no C++ code in it.");
cm->DefineProperty cm->DefineProperty
("IMPORT_PREFIX", cmProperty::TARGET, ("IMPORT_PREFIX", cmProperty::TARGET,
"What comes before the import library name.", "What comes before the import library name.",
"Similar to the target property PREFIX, but used for import libraries " "Similar to the target property PREFIX, but used for import libraries "
"(typically corresponding to a DLL) instead of regular libraries. " "(typically corresponding to a DLL) instead of regular libraries. "
@ -110,7 +110,7 @@ void cmTarget::DefineProperties(cmake *cm)
"(such as \"lib\") on an import library name."); "(such as \"lib\") on an import library name.");
cm->DefineProperty cm->DefineProperty
("IMPORT_SUFFIX", cmProperty::TARGET, ("IMPORT_SUFFIX", cmProperty::TARGET,
"What comes after the import library name.", "What comes after the import library name.",
"Similar to the target property SUFFIX, but used for import libraries " "Similar to the target property SUFFIX, but used for import libraries "
"(typically corresponding to a DLL) instead of regular libraries. " "(typically corresponding to a DLL) instead of regular libraries. "
@ -118,7 +118,7 @@ void cmTarget::DefineProperties(cmake *cm)
"(such as \".lib\") on an import library name."); "(such as \".lib\") on an import library name.");
cm->DefineProperty cm->DefineProperty
("EXCLUDE_FROM_ALL", cmProperty::TARGET, ("EXCLUDE_FROM_ALL", cmProperty::TARGET,
"Exclude the target from the all target.", "Exclude the target from the all target.",
"A property on a target that indicates if the target is excluded " "A property on a target that indicates if the target is excluded "
"from the default build target. If it is not, then with a Makefile " "from the default build target. If it is not, then with a Makefile "
@ -127,27 +127,27 @@ void cmTarget::DefineProperties(cmake *cm)
true); true);
cm->DefineProperty cm->DefineProperty
("INSTALL_NAME_DIR", cmProperty::TARGET, ("INSTALL_NAME_DIR", cmProperty::TARGET,
"Mac OSX directory name for installed targets.", "Mac OSX directory name for installed targets.",
"INSTALL_NAME_DIR is a string specifying the " "INSTALL_NAME_DIR is a string specifying the "
"directory portion of the \"install_name\" field of shared libraries " "directory portion of the \"install_name\" field of shared libraries "
"on Mac OSX to use in the installed targets. "); "on Mac OSX to use in the installed targets. ");
cm->DefineProperty cm->DefineProperty
("INSTALL_RPATH", cmProperty::TARGET, ("INSTALL_RPATH", cmProperty::TARGET,
"The rpath to use for installed targets.", "The rpath to use for installed targets.",
"A semicolon-separated list specifying the rpath " "A semicolon-separated list specifying the rpath "
"to use in installed targets (for platforms that support it)."); "to use in installed targets (for platforms that support it).");
cm->DefineProperty cm->DefineProperty
("INSTALL_RPATH_USE_LINK_PATH", cmProperty::TARGET, ("INSTALL_RPATH_USE_LINK_PATH", cmProperty::TARGET,
"Add paths to linker search and installed rpath.", "Add paths to linker search and installed rpath.",
"INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true will " "INSTALL_RPATH_USE_LINK_PATH is a boolean that if set to true will "
"append directories in the linker search path and outside the " "append directories in the linker search path and outside the "
"project to the INSTALL_RPATH. "); "project to the INSTALL_RPATH. ");
cm->DefineProperty cm->DefineProperty
("LINK_FLAGS", cmProperty::TARGET, ("LINK_FLAGS", cmProperty::TARGET,
"Additional flags to use when linking this target.", "Additional flags to use when linking this target.",
"The LINK_FLAGS property can be used to add extra flags to the " "The LINK_FLAGS property can be used to add extra flags to the "
"link step of a target. LINK_FLAGS_<CONFIG> will add to the " "link step of a target. LINK_FLAGS_<CONFIG> will add to the "
@ -155,7 +155,7 @@ void cmTarget::DefineProperties(cmake *cm)
"for example, DEBUG, RELEASE, MINSIZEREL, RELWITHDEBINFO. "); "for example, DEBUG, RELEASE, MINSIZEREL, RELWITHDEBINFO. ");
cm->DefineProperty cm->DefineProperty
("LINKER_LANGUAGE", cmProperty::TARGET, ("LINKER_LANGUAGE", cmProperty::TARGET,
"What tool to use for linking, based on language.", "What tool to use for linking, based on language.",
"The LINKER_LANGUAGE property is used to change the tool " "The LINKER_LANGUAGE property is used to change the tool "
"used to link an executable or shared library. The default is " "used to link an executable or shared library. The default is "
@ -163,7 +163,7 @@ void cmTarget::DefineProperties(cmake *cm)
"are common values for this property."); "are common values for this property.");
cm->DefineProperty cm->DefineProperty
("LOCATION", cmProperty::TARGET, ("LOCATION", cmProperty::TARGET,
"Where a target will be written on disk.", "Where a target will be written on disk.",
"A read only property on a target that indicates where that target " "A read only property on a target that indicates where that target "
"will be written. For libraries and execuatables this will be where " "will be written. For libraries and execuatables this will be where "
@ -171,7 +171,7 @@ void cmTarget::DefineProperties(cmake *cm)
"number of other settings."); "number of other settings.");
cm->DefineProperty cm->DefineProperty
("OUTPUT_NAME", cmProperty::TARGET, ("OUTPUT_NAME", cmProperty::TARGET,
"Sets the real name of a target when it is built.", "Sets the real name of a target when it is built.",
"Sets the real name of a target when it is built and " "Sets the real name of a target when it is built and "
"can be used to help create two targets of the same name even though " "can be used to help create two targets of the same name even though "
@ -180,7 +180,7 @@ void cmTarget::DefineProperties(cmake *cm)
"per-configuration basis."); "per-configuration basis.");
cm->DefineProperty cm->DefineProperty
("PRE_INSTALL_SCRIPT", cmProperty::TARGET, ("PRE_INSTALL_SCRIPT", cmProperty::TARGET,
"Deprecated install support.", "Deprecated install support.",
"The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the " "The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the "
"old way to specify CMake scripts to run before and after " "old way to specify CMake scripts to run before and after "
@ -189,13 +189,13 @@ void cmTarget::DefineProperties(cmake *cm)
"INSTALL command instead."); "INSTALL command instead.");
cm->DefineProperty cm->DefineProperty
("PREFIX", cmProperty::TARGET, ("PREFIX", cmProperty::TARGET,
"What comes before the library name.", "What comes before the library name.",
"A target property that can be set to override the prefix " "A target property that can be set to override the prefix "
"(such as \"lib\") on a library name."); "(such as \"lib\") on a library name.");
cm->DefineProperty cm->DefineProperty
("POST_INSTALL_SCRIPT", cmProperty::TARGET, ("POST_INSTALL_SCRIPT", cmProperty::TARGET,
"Deprecated install support.", "Deprecated install support.",
"The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the " "The PRE_INSTALL_SCRIPT and POST_INSTALL_SCRIPT properties are the "
"old way to specify CMake scripts to run before and after " "old way to specify CMake scripts to run before and after "
@ -204,14 +204,14 @@ void cmTarget::DefineProperties(cmake *cm)
"INSTALL command instead."); "INSTALL command instead.");
cm->DefineProperty cm->DefineProperty
("SKIP_BUILD_RPATH", cmProperty::TARGET, ("SKIP_BUILD_RPATH", cmProperty::TARGET,
"Should rpaths be used for the build tree.", "Should rpaths be used for the build tree.",
"SKIP_BUILD_RPATH is a boolean specifying whether to skip automatic " "SKIP_BUILD_RPATH is a boolean specifying whether to skip automatic "
"generation of an rpath allowing the target to run from the " "generation of an rpath allowing the target to run from the "
"build tree. "); "build tree. ");
cm->DefineProperty cm->DefineProperty
("SOVERSION", cmProperty::TARGET, ("SOVERSION", cmProperty::TARGET,
"What version number is this target.", "What version number is this target.",
"For shared libraries VERSION and SOVERSION can be used to specify " "For shared libraries VERSION and SOVERSION can be used to specify "
"the build version and api version respectively. When building or " "the build version and api version respectively. When building or "
@ -224,18 +224,18 @@ void cmTarget::DefineProperties(cmake *cm)
"These numbers are used as the image version of the binary. "); "These numbers are used as the image version of the binary. ");
cm->DefineProperty cm->DefineProperty
("STATIC_LIBRARY_FLAGS", cmProperty::TARGET, ("STATIC_LIBRARY_FLAGS", cmProperty::TARGET,
"Extra flags to use when linking static libraries.", "Extra flags to use when linking static libraries.",
"Extra flags to use when linking a static library."); "Extra flags to use when linking a static library.");
cm->DefineProperty cm->DefineProperty
("SUFFIX", cmProperty::TARGET, ("SUFFIX", cmProperty::TARGET,
"What comes after the library name.", "What comes after the library name.",
"A target property that can be set to override the suffix " "A target property that can be set to override the suffix "
"(such as \".so\") on a library name."); "(such as \".so\") on a library name.");
cm->DefineProperty cm->DefineProperty
("VERSION", cmProperty::TARGET, ("VERSION", cmProperty::TARGET,
"What version number is this target.", "What version number is this target.",
"For shared libraries VERSION and SOVERSION can be used to specify " "For shared libraries VERSION and SOVERSION can be used to specify "
"the build version and api version respectively. When building or " "the build version and api version respectively. When building or "
@ -252,7 +252,7 @@ void cmTarget::DefineProperties(cmake *cm)
cm->DefineProperty cm->DefineProperty
("WIN32_EXECUTABLE", cmProperty::TARGET, ("WIN32_EXECUTABLE", cmProperty::TARGET,
"Used to specify Windows executable with a WinMain entry point.", "Used to specify Windows executable with a WinMain entry point.",
"This can be set to indicate that a target is a Windows executable " "This can be set to indicate that a target is a Windows executable "
"in contrast to a console application for example. This changes " "in contrast to a console application for example. This changes "
@ -276,14 +276,14 @@ void cmTarget::DefineProperties(cmake *cm)
"All Windows-based systems including Cygwin are DLL platforms."); "All Windows-based systems including Cygwin are DLL platforms.");
cm->DefineProperty cm->DefineProperty
("GENERATOR_FILE_NAME", cmProperty::TARGET, ("GENERATOR_FILE_NAME", cmProperty::TARGET,
"Generator's file for this target.", "Generator's file for this target.",
"An internal property used by some generators to record the name of " "An internal property used by some generators to record the name of "
"project or dsp file associated with this target."); "project or dsp file associated with this target.");
#if 0 #if 0
cm->DefineProperty cm->DefineProperty
("OBJECT_FILES", cmProperty::TARGET, ("OBJECT_FILES", cmProperty::TARGET,
"Used to get the resulting list of object files that make up a " "Used to get the resulting list of object files that make up a "
"target.", "target.",
"This can be used to put object files from one library " "This can be used to put object files from one library "
@ -347,12 +347,12 @@ void cmTarget::SetType(TargetType type, const char* name)
} }
// only add dependency information for library targets // only add dependency information for library targets
this->TargetTypeValue = type; this->TargetTypeValue = type;
if(this->TargetTypeValue >= STATIC_LIBRARY if(this->TargetTypeValue >= STATIC_LIBRARY
&& this->TargetTypeValue <= MODULE_LIBRARY) && this->TargetTypeValue <= MODULE_LIBRARY)
{ {
this->RecordDependencies = true; this->RecordDependencies = true;
} }
else else
{ {
this->RecordDependencies = false; this->RecordDependencies = false;
} }
@ -666,6 +666,7 @@ void cmTarget::AddSources(std::vector<std::string> const& srcs)
} }
} }
//----------------------------------------------------------------------------
cmSourceFile* cmTarget::AddSource(const char* s) cmSourceFile* cmTarget::AddSource(const char* s)
{ {
std::string src = s; std::string src = s;
@ -679,6 +680,7 @@ cmSourceFile* cmTarget::AddSource(const char* s)
return sf; return sf;
} }
//----------------------------------------------------------------------------
void cmTarget::MergeLinkLibraries( cmMakefile& mf, void cmTarget::MergeLinkLibraries( cmMakefile& mf,
const char *selfname, const char *selfname,
const LinkLibraryVectorType& libs ) const LinkLibraryVectorType& libs )
@ -750,7 +752,7 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories()
// is an N^2 algorithm for adding the directories, but N // is an N^2 algorithm for adding the directories, but N
// should not get very big. // should not get very big.
const char* libpath = tgt->GetDirectory(0, implib); const char* libpath = tgt->GetDirectory(0, implib);
if(std::find(this->LinkDirectories.begin(), if(std::find(this->LinkDirectories.begin(),
this->LinkDirectories.end(), this->LinkDirectories.end(),
libpath) == this->LinkDirectories.end()) libpath) == this->LinkDirectories.end())
{ {
@ -767,7 +769,8 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories()
return this->LinkDirectories; return this->LinkDirectories;
} }
void cmTarget::ClearDependencyInformation( cmMakefile& mf, //----------------------------------------------------------------------------
void cmTarget::ClearDependencyInformation( cmMakefile& mf,
const char* target ) const char* target )
{ {
// Clear the dependencies. The cache variable must exist iff we are // Clear the dependencies. The cache variable must exist iff we are
@ -789,14 +792,13 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf,
message += "Your cache is probably stale. Please remove the entry\n "; message += "Your cache is probably stale. Please remove the entry\n ";
message += depname; message += depname;
message += "\nfrom the cache."; message += "\nfrom the cache.";
cmSystemTools::Error( message.c_str() ); cmSystemTools::Error( message.c_str() );
} }
} }
} }
//----------------------------------------------------------------------------
void cmTarget::AddLinkLibrary(const std::string& lib,
void cmTarget::AddLinkLibrary(const std::string& lib,
LinkLibraryType llt) LinkLibraryType llt)
{ {
this->AddFramework(lib.c_str(), llt); this->AddFramework(lib.c_str(), llt);
@ -806,6 +808,7 @@ void cmTarget::AddLinkLibrary(const std::string& lib,
this->LinkLibraries.push_back(tmp); this->LinkLibraries.push_back(tmp);
} }
//----------------------------------------------------------------------------
bool cmTarget::AddFramework(const std::string& libname, LinkLibraryType llt) bool cmTarget::AddFramework(const std::string& libname, LinkLibraryType llt)
{ {
(void)llt; // TODO: What is this? (void)llt; // TODO: What is this?
@ -814,7 +817,7 @@ bool cmTarget::AddFramework(const std::string& libname, LinkLibraryType llt)
std::string frameworkDir = libname; std::string frameworkDir = libname;
frameworkDir += "/../"; frameworkDir += "/../";
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir.c_str()); frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir.c_str());
std::vector<std::string>::iterator i = std::vector<std::string>::iterator i =
std::find(this->Frameworks.begin(), std::find(this->Frameworks.begin(),
this->Frameworks.end(), frameworkDir); this->Frameworks.end(), frameworkDir);
if(i == this->Frameworks.end()) if(i == this->Frameworks.end())
@ -825,8 +828,10 @@ bool cmTarget::AddFramework(const std::string& libname, LinkLibraryType llt)
} }
return false; return false;
} }
//----------------------------------------------------------------------------
void cmTarget::AddLinkLibrary(cmMakefile& mf, void cmTarget::AddLinkLibrary(cmMakefile& mf,
const char *target, const char* lib, const char *target, const char* lib,
LinkLibraryType llt) LinkLibraryType llt)
{ {
// Never add a self dependency, even if the user asks for it. // Never add a self dependency, even if the user asks for it.
@ -874,12 +879,13 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
dependencies += lib; dependencies += lib;
dependencies += ";"; dependencies += ";";
mf.AddCacheDefinition( targetEntry.c_str(), dependencies.c_str(), mf.AddCacheDefinition( targetEntry.c_str(), dependencies.c_str(),
"Dependencies for the target", "Dependencies for the target",
cmCacheManager::STATIC ); cmCacheManager::STATIC );
} }
} }
//----------------------------------------------------------------------------
void void
cmTarget::AnalyzeLibDependencies( const cmMakefile& mf ) cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
{ {
@ -893,7 +899,7 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
// The former is a more thorny issue, since it is not clear how to // The former is a more thorny issue, since it is not clear how to
// determine if two libraries listed on the link line refer to the a // determine if two libraries listed on the link line refer to the a
// single library or not. For example, consider the link "libraries" // single library or not. For example, consider the link "libraries"
// /usr/lib/libtiff.so -ltiff // /usr/lib/libtiff.so -ltiff
// Is this one library or two? The solution implemented here is the // Is this one library or two? The solution implemented here is the
// simplest (and probably the only practical) one: two libraries are // simplest (and probably the only practical) one: two libraries are
// the same if their "link strings" are identical. Thus, the two // the same if their "link strings" are identical. Thus, the two
@ -952,92 +958,93 @@ cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
// cyclic dependencies, so this is probably not a big deal. Note that // cyclic dependencies, so this is probably not a big deal. Note that
// the link line is always correct, just not necessary optimal. // the link line is always correct, just not necessary optimal.
{ {
// Expand variables in link library names. This is for backwards // Expand variables in link library names. This is for backwards
// compatibility with very early CMake versions and should // compatibility with very early CMake versions and should
// eventually be removed. This code was moved here from the end of // eventually be removed. This code was moved here from the end of
// old source list processing code which was called just before this // old source list processing code which was called just before this
// method. // method.
for(LinkLibraryVectorType::iterator p = this->LinkLibraries.begin(); for(LinkLibraryVectorType::iterator p = this->LinkLibraries.begin();
p != this->LinkLibraries.end(); ++p) p != this->LinkLibraries.end(); ++p)
{ {
this->Makefile->ExpandVariablesInString(p->first, true, true); this->Makefile->ExpandVariablesInString(p->first, true, true);
} }
} }
typedef std::vector< std::string > LinkLine; typedef std::vector< std::string > LinkLine;
// The dependency map. // The dependency map.
DependencyMap dep_map; DependencyMap dep_map;
if ( this->OriginalLinkLibraries.size() == 0 ) if ( this->OriginalLinkLibraries.size() == 0 )
{ {
this->OriginalLinkLibraries = this->LinkLibraries; this->OriginalLinkLibraries = this->LinkLibraries;
} }
// 1. Build the dependency graph // 1. Build the dependency graph
// //
for(LinkLibraryVectorType::reverse_iterator lib for(LinkLibraryVectorType::reverse_iterator lib
= this->LinkLibraries.rbegin(); = this->LinkLibraries.rbegin();
lib != this->LinkLibraries.rend(); ++lib) lib != this->LinkLibraries.rend(); ++lib)
{ {
this->GatherDependencies( mf, *lib, dep_map); this->GatherDependencies( mf, *lib, dep_map);
} }
// 2. Remove any dependencies that are already satisfied in the original // 2. Remove any dependencies that are already satisfied in the original
// link line. // link line.
// //
for(LinkLibraryVectorType::iterator lib = this->LinkLibraries.begin(); for(LinkLibraryVectorType::iterator lib = this->LinkLibraries.begin();
lib != this->LinkLibraries.end(); ++lib) lib != this->LinkLibraries.end(); ++lib)
{ {
for( LinkLibraryVectorType::iterator lib2 = lib; for( LinkLibraryVectorType::iterator lib2 = lib;
lib2 != this->LinkLibraries.end(); ++lib2) lib2 != this->LinkLibraries.end(); ++lib2)
{ {
this->DeleteDependency( dep_map, *lib, *lib2); this->DeleteDependency( dep_map, *lib, *lib2);
} }
} }
// 3. Create the new link line by simply emitting any dependencies that are
// missing. Start from the back and keep adding.
//
std::set<DependencyMap::key_type> done, visited;
std::vector<DependencyMap::key_type> newLinkLibraries;
for(LinkLibraryVectorType::reverse_iterator lib =
this->LinkLibraries.rbegin();
lib != this->LinkLibraries.rend(); ++lib)
{
// skip zero size library entries, this may happen
// if a variable expands to nothing.
if (lib->first.size() != 0)
{
this->Emit( *lib, dep_map, done, visited, newLinkLibraries );
}
}
// 4. Add the new libraries to the link line. // 3. Create the new link line by simply emitting any dependencies that are
// // missing. Start from the back and keep adding.
for( std::vector<DependencyMap::key_type>::reverse_iterator k = //
newLinkLibraries.rbegin(); std::set<DependencyMap::key_type> done, visited;
k != newLinkLibraries.rend(); ++k ) std::vector<DependencyMap::key_type> newLinkLibraries;
{ for(LinkLibraryVectorType::reverse_iterator lib =
// get the llt from the dep_map this->LinkLibraries.rbegin();
this->LinkLibraries.push_back( std::make_pair(k->first,k->second) ); lib != this->LinkLibraries.rend(); ++lib)
} {
this->LinkLibrariesAnalyzed = true; // skip zero size library entries, this may happen
// if a variable expands to nothing.
if (lib->first.size() != 0)
{
this->Emit( *lib, dep_map, done, visited, newLinkLibraries );
}
}
// 4. Add the new libraries to the link line.
//
for( std::vector<DependencyMap::key_type>::reverse_iterator k =
newLinkLibraries.rbegin();
k != newLinkLibraries.rend(); ++k )
{
// get the llt from the dep_map
this->LinkLibraries.push_back( std::make_pair(k->first,k->second) );
}
this->LinkLibrariesAnalyzed = true;
} }
//----------------------------------------------------------------------------
void cmTarget::InsertDependency( DependencyMap& depMap, void cmTarget::InsertDependency( DependencyMap& depMap,
const LibraryID& lib, const LibraryID& lib,
const LibraryID& dep) const LibraryID& dep)
{ {
depMap[lib].push_back(dep); depMap[lib].push_back(dep);
} }
//----------------------------------------------------------------------------
void cmTarget::DeleteDependency( DependencyMap& depMap, void cmTarget::DeleteDependency( DependencyMap& depMap,
const LibraryID& lib, const LibraryID& lib,
const LibraryID& dep) const LibraryID& dep)
{ {
// Make sure there is an entry in the map for lib. If so, delete all // 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 // dependencies to dep. There may be repeated entries because of
@ -1047,7 +1054,7 @@ void cmTarget::DeleteDependency( DependencyMap& depMap,
{ {
DependencyList& depList = map_itr->second; DependencyList& depList = map_itr->second;
DependencyList::iterator itr; DependencyList::iterator itr;
while( (itr = std::find(depList.begin(), depList.end(), dep)) != while( (itr = std::find(depList.begin(), depList.end(), dep)) !=
depList.end() ) depList.end() )
{ {
depList.erase( itr ); depList.erase( itr );
@ -1055,6 +1062,7 @@ void cmTarget::DeleteDependency( DependencyMap& depMap,
} }
} }
//----------------------------------------------------------------------------
void cmTarget::Emit(const LibraryID lib, void cmTarget::Emit(const LibraryID lib,
const DependencyMap& dep_map, const DependencyMap& dep_map,
std::set<LibraryID>& emitted, std::set<LibraryID>& emitted,
@ -1117,7 +1125,7 @@ void cmTarget::Emit(const LibraryID lib,
} }
} }
//----------------------------------------------------------------------------
void cmTarget::GatherDependencies( const cmMakefile& mf, void cmTarget::GatherDependencies( const cmMakefile& mf,
const LibraryID& lib, const LibraryID& lib,
DependencyMap& dep_map) DependencyMap& dep_map)
@ -1173,11 +1181,11 @@ void cmTarget::GatherDependencies( const cmMakefile& mf,
end = depline.find( ";", start ); end = depline.find( ";", start );
} }
// cannot depend on itself // cannot depend on itself
this->DeleteDependency( dep_map, lib, lib); this->DeleteDependency( dep_map, lib, lib);
} }
} }
//----------------------------------------------------------------------------
void cmTarget::SetProperty(const char* prop, const char* value) void cmTarget::SetProperty(const char* prop, const char* value)
{ {
if (!prop) if (!prop)
@ -1192,11 +1200,13 @@ void cmTarget::SetProperty(const char* prop, const char* value)
this->Properties.SetProperty(prop, value, cmProperty::TARGET); this->Properties.SetProperty(prop, value, cmProperty::TARGET);
} }
//----------------------------------------------------------------------------
void cmTarget::MarkAsImported() void cmTarget::MarkAsImported()
{ {
this->IsImportedTarget = true; this->IsImportedTarget = true;
} }
//----------------------------------------------------------------------------
const char* cmTarget::GetDirectory(const char* config, bool implib) const char* cmTarget::GetDirectory(const char* config, bool implib)
{ {
if (this->IsImported()) if (this->IsImported())
@ -1209,6 +1219,7 @@ const char* cmTarget::GetDirectory(const char* config, bool implib)
} }
} }
//----------------------------------------------------------------------------
const char* cmTarget::ImportedGetDirectory(const char* config, bool) const char* cmTarget::ImportedGetDirectory(const char* config, bool)
{ {
const char* location=this->GetLocation(config); const char* location=this->GetLocation(config);
@ -1216,6 +1227,7 @@ const char* cmTarget::ImportedGetDirectory(const char* config, bool)
return directory.c_str(); return directory.c_str();
} }
//----------------------------------------------------------------------------
const char* cmTarget::NormalGetDirectory(const char* config, bool implib) const char* cmTarget::NormalGetDirectory(const char* config, bool implib)
{ {
if(config && *config) if(config && *config)
@ -1232,6 +1244,7 @@ const char* cmTarget::NormalGetDirectory(const char* config, bool implib)
} }
} }
//----------------------------------------------------------------------------
const char* cmTarget::GetLocation(const char* config) const char* cmTarget::GetLocation(const char* config)
{ {
if (this->IsImported()) if (this->IsImported())
@ -1244,6 +1257,7 @@ const char* cmTarget::GetLocation(const char* config)
} }
} }
//----------------------------------------------------------------------------
const char* cmTarget::ImportedGetLocation(const char* config) const char* cmTarget::ImportedGetLocation(const char* config)
{ {
if ((config) && (strlen(config))) if ((config) && (strlen(config)))
@ -1256,10 +1270,11 @@ const char* cmTarget::ImportedGetLocation(const char* config)
return configLocation; return configLocation;
} }
} }
return this->GetProperty("LOCATION"); return this->GetProperty("LOCATION");
} }
//----------------------------------------------------------------------------
const char* cmTarget::NormalGetLocation(const char* config) const char* cmTarget::NormalGetLocation(const char* config)
{ {
this->Location = this->GetDirectory(); this->Location = this->GetDirectory();
@ -1300,11 +1315,13 @@ void cmTarget::GetTargetVersion(int& major, int& minor)
} }
} }
//----------------------------------------------------------------------------
const char *cmTarget::GetProperty(const char* prop) const char *cmTarget::GetProperty(const char* prop)
{ {
return this->GetProperty(prop, cmProperty::TARGET); return this->GetProperty(prop, cmProperty::TARGET);
} }
//----------------------------------------------------------------------------
void cmTarget::ComputeObjectFiles() void cmTarget::ComputeObjectFiles()
{ {
if (this->IsImported()) if (this->IsImported())
@ -1319,7 +1336,7 @@ void cmTarget::ComputeObjectFiles()
std::string objectFiles; std::string objectFiles;
std::string objExtensionLookup1 = "CMAKE_"; std::string objExtensionLookup1 = "CMAKE_";
std::string objExtensionLookup2 = "_OUTPUT_EXTENSION"; std::string objExtensionLookup2 = "_OUTPUT_EXTENSION";
for(std::vector<std::string>::iterator d = dirs.begin(); for(std::vector<std::string>::iterator d = dirs.begin();
d != dirs.end(); ++d) d != dirs.end(); ++d)
{ {
@ -1352,7 +1369,7 @@ void cmTarget::ComputeObjectFiles()
#endif #endif
} }
//----------------------------------------------------------------------------
const char *cmTarget::GetProperty(const char* prop, const char *cmTarget::GetProperty(const char* prop,
cmProperty::ScopeType scope) cmProperty::ScopeType scope)
{ {
@ -1361,40 +1378,41 @@ const char *cmTarget::GetProperty(const char* prop,
return 0; return 0;
} }
// don't use GetLocation() for imported targets, because there this // don't use GetLocation() for imported targets, because there this
// calls GetProperty() to get the location... // calls GetProperty() to get the location...
if (!this->IsImported()) if (!this->IsImported())
{
// watch for special "computed" properties that are dependent on other
// properties or variables, always recompute them
if (!strcmp(prop,"LOCATION"))
{ {
// watch for special "computed" properties that are dependent on other // Set the LOCATION property of the target. Note that this
// properties or variables, always recompute them // cannot take into account the per-configuration name of the
if (!strcmp(prop,"LOCATION")) // target because the configuration type may not be known at
{ // CMake time. We should deprecate this feature and instead
// Set the LOCATION property of the target. Note that this cannot take // support transforming an executable target name given as the
// into account the per-configuration name of the target because the // command part of custom commands into the proper path at
// configuration type may not be known at CMake time. We should // build time. Alternatively we could put environment
// deprecate this feature and instead support transforming an executable // variable settings in all custom commands that hold the name
// target name given as the command part of custom commands into the // of the target for each configuration and then give a
// proper path at build time. Alternatively we could put environment // reference to the variable in the location.
// variable settings in all custom commands that hold the name of the this->SetProperty("LOCATION", this->GetLocation(0));
// target for each configuration and then give a reference to the
// variable in the location.
this->SetProperty("LOCATION", this->GetLocation(0));
}
// Per-configuration location can be computed.
int len = static_cast<int>(strlen(prop));
if(len > 9 && strcmp(prop+len-9, "_LOCATION") == 0)
{
std::string configName(prop, len-9);
this->SetProperty(prop, this->GetLocation(configName.c_str()));
}
if(strcmp(prop, "OBJECT_FILES") == 0)
{
this->ComputeObjectFiles();
}
} }
// Per-configuration location can be computed.
int len = static_cast<int>(strlen(prop));
if(len > 9 && strcmp(prop+len-9, "_LOCATION") == 0)
{
std::string configName(prop, len-9);
this->SetProperty(prop, this->GetLocation(configName.c_str()));
}
if(strcmp(prop, "OBJECT_FILES") == 0)
{
this->ComputeObjectFiles();
}
}
if (strcmp(prop,"IMPORTED") == 0) if (strcmp(prop,"IMPORTED") == 0)
{ {
return this->IsImported()?"TRUE":"FALSE"; return this->IsImported()?"TRUE":"FALSE";
@ -1436,20 +1454,22 @@ const char *cmTarget::GetProperty(const char* prop,
return 0; return 0;
} }
bool chain = false; bool chain = false;
const char *retVal = const char *retVal =
this->Properties.GetPropertyValue(prop, scope, chain); this->Properties.GetPropertyValue(prop, scope, chain);
if (chain) if (chain)
{ {
return this->Makefile->GetProperty(prop,scope); return this->Makefile->GetProperty(prop,scope);
} }
return retVal; return retVal;
} }
//----------------------------------------------------------------------------
bool cmTarget::GetPropertyAsBool(const char* prop) bool cmTarget::GetPropertyAsBool(const char* prop)
{ {
return cmSystemTools::IsOn(this->GetProperty(prop)); return cmSystemTools::IsOn(this->GetProperty(prop));
} }
//----------------------------------------------------------------------------
const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg) const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
{ {
if(this->GetProperty("HAS_CXX")) if(this->GetProperty("HAS_CXX"))
@ -1462,7 +1482,7 @@ const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
return linkerLang; return linkerLang;
} }
std::set<cmStdString> languages; std::set<cmStdString> languages;
for(std::vector<cmSourceFile*>::const_iterator i for(std::vector<cmSourceFile*>::const_iterator i
= this->SourceFiles.begin(); = this->SourceFiles.begin();
i != this->SourceFiles.end(); ++i) i != this->SourceFiles.end(); ++i)
{ {
@ -1477,12 +1497,12 @@ const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
} }
if(languages.size() == 1) if(languages.size() == 1)
{ {
const_cast<cmTarget*>(this)->SetProperty("LINKER_LANGUAGE", const_cast<cmTarget*>(this)->SetProperty("LINKER_LANGUAGE",
languages.begin()->c_str()); languages.begin()->c_str());
return this->GetProperty("LINKER_LANGUAGE"); return this->GetProperty("LINKER_LANGUAGE");
} }
const char* prefLang = 0; const char* prefLang = 0;
for(std::set<cmStdString>::const_iterator s = languages.begin(); for(std::set<cmStdString>::const_iterator s = languages.begin();
s != languages.end(); ++s) s != languages.end(); ++s)
{ {
const char* lpref = gg->GetLinkerPreference(s->c_str()); const char* lpref = gg->GetLinkerPreference(s->c_str());
@ -1512,10 +1532,11 @@ const char* cmTarget::GetLinkerLanguage(cmGlobalGenerator* gg)
return this->GetProperty("LINKER_LANGUAGE"); return this->GetProperty("LINKER_LANGUAGE");
} }
//----------------------------------------------------------------------------
const char* cmTarget::GetCreateRuleVariable() const char* cmTarget::GetCreateRuleVariable()
{ {
switch(this->GetType()) switch(this->GetType())
{ {
case cmTarget::STATIC_LIBRARY: case cmTarget::STATIC_LIBRARY:
return "_CREATE_STATIC_LIBRARY"; return "_CREATE_STATIC_LIBRARY";
case cmTarget::SHARED_LIBRARY: case cmTarget::SHARED_LIBRARY:
@ -1534,6 +1555,7 @@ const char* cmTarget::GetCreateRuleVariable()
return ""; return "";
} }
//----------------------------------------------------------------------------
const char* cmTarget::GetSuffixVariableInternal(TargetType type, const char* cmTarget::GetSuffixVariableInternal(TargetType type,
bool implib) bool implib)
{ {
@ -1564,6 +1586,7 @@ const char* cmTarget::GetSuffixVariableInternal(TargetType type,
} }
//----------------------------------------------------------------------------
const char* cmTarget::GetPrefixVariableInternal(TargetType type, const char* cmTarget::GetPrefixVariableInternal(TargetType type,
bool implib) bool implib)
{ {
@ -1640,12 +1663,13 @@ std::string cmTarget::GetFullNameInternal(TargetType type, const char* config,
return prefix+base+suffix; return prefix+base+suffix;
} }
//----------------------------------------------------------------------------
void cmTarget::GetFullNameInternal(TargetType type, void cmTarget::GetFullNameInternal(TargetType type,
const char* config, const char* config,
bool implib, bool implib,
std::string& outPrefix, std::string& outPrefix,
std::string& outBase, std::string& outBase,
std::string& outSuffix) std::string& outSuffix)
{ {
if (this->IsImported()) if (this->IsImported())
{ {
@ -1659,12 +1683,13 @@ void cmTarget::GetFullNameInternal(TargetType type,
} }
} }
//----------------------------------------------------------------------------
void cmTarget::ImportedGetFullNameInternal(TargetType , void cmTarget::ImportedGetFullNameInternal(TargetType ,
const char* config, const char* config,
bool , bool ,
std::string& outPrefix, std::string& outPrefix,
std::string& outBase, std::string& outBase,
std::string& outSuffix) std::string& outSuffix)
{ {
// find the basename, suffix and prefix from getLocation() // find the basename, suffix and prefix from getLocation()
// implib ? // implib ?
@ -1810,6 +1835,7 @@ void cmTarget::NormalGetFullNameInternal(TargetType type,
outSuffix = targetSuffix?targetSuffix:""; outSuffix = targetSuffix?targetSuffix:"";
} }
//----------------------------------------------------------------------------
void cmTarget::GetLibraryNames(std::string& name, void cmTarget::GetLibraryNames(std::string& name,
std::string& soName, std::string& soName,
std::string& realName, std::string& realName,
@ -1822,6 +1848,7 @@ void cmTarget::GetLibraryNames(std::string& name,
this->GetType(), config); this->GetType(), config);
} }
//----------------------------------------------------------------------------
void cmTarget::GetLibraryCleanNames(std::string& staticName, void cmTarget::GetLibraryCleanNames(std::string& staticName,
std::string& sharedName, std::string& sharedName,
std::string& sharedSOName, std::string& sharedSOName,
@ -1858,6 +1885,7 @@ void cmTarget::GetLibraryCleanNames(std::string& staticName,
} }
} }
//----------------------------------------------------------------------------
void cmTarget::GetLibraryNamesInternal(std::string& name, void cmTarget::GetLibraryNamesInternal(std::string& name,
std::string& soName, std::string& soName,
std::string& realName, std::string& realName,
@ -1955,6 +1983,7 @@ void cmTarget::GetLibraryNamesInternal(std::string& name,
pdbName = prefix+base+".pdb"; pdbName = prefix+base+".pdb";
} }
//----------------------------------------------------------------------------
void cmTarget::GetExecutableNames(std::string& name, void cmTarget::GetExecutableNames(std::string& name,
std::string& realName, std::string& realName,
std::string& impName, std::string& impName,
@ -1966,6 +1995,7 @@ void cmTarget::GetExecutableNames(std::string& name,
this->GetType(), config); this->GetType(), config);
} }
//----------------------------------------------------------------------------
void cmTarget::GetExecutableCleanNames(std::string& name, void cmTarget::GetExecutableCleanNames(std::string& name,
std::string& realName, std::string& realName,
std::string& impName, std::string& impName,
@ -1977,6 +2007,7 @@ void cmTarget::GetExecutableCleanNames(std::string& name,
cmTarget::EXECUTABLE, config); cmTarget::EXECUTABLE, config);
} }
//----------------------------------------------------------------------------
void cmTarget::GetExecutableNamesInternal(std::string& name, void cmTarget::GetExecutableNamesInternal(std::string& name,
std::string& realName, std::string& realName,
std::string& impName, std::string& impName,

80
Source/cmTarget.h
View File

@ -9,8 +9,8 @@
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information. PURPOSE. See the above copyright notices for more information.
=========================================================================*/ =========================================================================*/
@ -28,7 +28,7 @@ class cmGlobalGenerator;
/** \class cmTarget /** \class cmTarget
* \brief Represent a library or executable target loaded from a makefile. * \brief Represent a library or executable target loaded from a makefile.
* *
* cmTarget represents a target loaded from * cmTarget represents a target loaded from
* a makefile. * a makefile.
*/ */
class cmTarget class cmTarget
@ -46,36 +46,36 @@ public:
*/ */
TargetType GetType() const TargetType GetType() const
{ {
return this->TargetTypeValue; return this->TargetTypeValue;
} }
/** /**
* Set the target type * Set the target type
*/ */
void SetType(TargetType f, const char* name); void SetType(TargetType f, const char* name);
void MarkAsImported(); void MarkAsImported();
///! Set/Get the name of the target ///! Set/Get the name of the target
const char* GetName() const {return this->Name.c_str();} const char* GetName() const {return this->Name.c_str();}
///! Set the cmMakefile that owns this target ///! Set the cmMakefile that owns this target
void SetMakefile(cmMakefile *mf); void SetMakefile(cmMakefile *mf);
cmMakefile *GetMakefile() { return this->Makefile;}; cmMakefile *GetMakefile() { return this->Makefile;};
/** /**
* Get the list of the custom commands for this target * Get the list of the custom commands for this target
*/ */
std::vector<cmCustomCommand> &GetPreBuildCommands() std::vector<cmCustomCommand> &GetPreBuildCommands()
{return this->PreBuildCommands;} {return this->PreBuildCommands;}
std::vector<cmCustomCommand> &GetPreLinkCommands() std::vector<cmCustomCommand> &GetPreLinkCommands()
{return this->PreLinkCommands;} {return this->PreLinkCommands;}
std::vector<cmCustomCommand> &GetPostBuildCommands() std::vector<cmCustomCommand> &GetPostBuildCommands()
{return this->PostBuildCommands;} {return this->PostBuildCommands;}
///! Return the list of frameworks being linked to this target ///! Return the list of frameworks being linked to this target
std::vector<std::string> &GetFrameworks() {return this->Frameworks;} std::vector<std::string> &GetFrameworks() {return this->Frameworks;}
/** /**
* Get the list of the source files used by this target * Get the list of the source files used by this target
*/ */
@ -99,10 +99,10 @@ public:
typedef std::vector<LibraryID > LinkLibraryVectorType; typedef std::vector<LibraryID > LinkLibraryVectorType;
const LinkLibraryVectorType &GetLinkLibraries() const { const LinkLibraryVectorType &GetLinkLibraries() const {
return this->LinkLibraries;} return this->LinkLibraries;}
const LinkLibraryVectorType &GetOriginalLinkLibraries() const const LinkLibraryVectorType &GetOriginalLinkLibraries() const
{return this->OriginalLinkLibraries;} {return this->OriginalLinkLibraries;}
/** /**
* Clear the dependency information recorded for this target, if any. * Clear the dependency information recorded for this target, if any.
*/ */
@ -111,13 +111,13 @@ public:
// Check to see if a library is a framework and treat it different on Mac // Check to see if a library is a framework and treat it different on Mac
bool AddFramework(const std::string& lib, LinkLibraryType llt); bool AddFramework(const std::string& lib, LinkLibraryType llt);
void AddLinkLibrary(cmMakefile& mf, void AddLinkLibrary(cmMakefile& mf,
const char *target, const char* lib, const char *target, const char* lib,
LinkLibraryType llt); LinkLibraryType llt);
void AddLinkLibrary(const std::string& lib, void AddLinkLibrary(const std::string& lib,
LinkLibraryType llt); LinkLibraryType llt);
void MergeLinkLibraries( cmMakefile& mf, const char* selfname, void MergeLinkLibraries( cmMakefile& mf, const char* selfname,
const LinkLibraryVectorType& libs ); const LinkLibraryVectorType& libs );
const std::vector<std::string>& GetLinkDirectories(); const std::vector<std::string>& GetLinkDirectories();
@ -130,14 +130,14 @@ public:
*/ */
std::string GetInstallPath() {return this->InstallPath;} std::string GetInstallPath() {return this->InstallPath;}
void SetInstallPath(const char *name) {this->InstallPath = name;} void SetInstallPath(const char *name) {this->InstallPath = name;}
/** /**
* Set the path where this target (if it has a runtime part) should be * Set the path where this target (if it has a runtime part) should be
* installed. This is relative to INSTALL_PREFIX * installed. This is relative to INSTALL_PREFIX
*/ */
std::string GetRuntimeInstallPath() {return this->RuntimeInstallPath;} std::string GetRuntimeInstallPath() {return this->RuntimeInstallPath;}
void SetRuntimeInstallPath(const char *name) { void SetRuntimeInstallPath(const char *name) {
this->RuntimeInstallPath = name;} this->RuntimeInstallPath = name;}
/** /**
* Get/Set whether there is an install rule for this target. * Get/Set whether there is an install rule for this target.
@ -147,7 +147,7 @@ public:
/** Add a utility on which this project depends. A utility is an executable /** Add a utility on which this project depends. A utility is an executable
* name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE * name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE
* commands. It is not a full path nor does it have an extension. * commands. It is not a full path nor does it have an extension.
*/ */
void AddUtility(const char* u) { this->Utilities.insert(u);} void AddUtility(const char* u) { this->Utilities.insert(u);}
///! Get the utilities used by this target ///! Get the utilities used by this target
@ -160,7 +160,7 @@ public:
const char *GetProperty(const char *prop); const char *GetProperty(const char *prop);
const char *GetProperty(const char *prop, cmProperty::ScopeType scope); const char *GetProperty(const char *prop, cmProperty::ScopeType scope);
bool GetPropertyAsBool(const char *prop); bool GetPropertyAsBool(const char *prop);
bool IsImported() const {return this->IsImportedTarget;} bool IsImported() const {return this->IsImportedTarget;}
/** Get the directory in which this target will be built. If the /** Get the directory in which this target will be built. If the
@ -187,21 +187,21 @@ public:
///! Return the prefered linker language for this target ///! Return the prefered linker language for this target
const char* GetLinkerLanguage(cmGlobalGenerator*); const char* GetLinkerLanguage(cmGlobalGenerator*);
///! Return the rule variable used to create this type of target, ///! Return the rule variable used to create this type of target,
// need to add CMAKE_(LANG) for full name. // need to add CMAKE_(LANG) for full name.
const char* GetCreateRuleVariable(); const char* GetCreateRuleVariable();
/** Get the full name of the target according to the settings in its /** Get the full name of the target according to the settings in its
makefile. */ makefile. */
std::string GetFullName(const char* config=0, bool implib = false); std::string GetFullName(const char* config=0, bool implib = false);
void GetFullName(std::string& prefix, void GetFullName(std::string& prefix,
std::string& base, std::string& suffix, std::string& base, std::string& suffix,
const char* config=0, bool implib = false); const char* config=0, bool implib = false);
/** Get the name of the pdb file for the target. */ /** Get the name of the pdb file for the target. */
std::string GetPDBName(const char* config=0); std::string GetPDBName(const char* config=0);
/** Get the full path to the target according to the settings in its /** Get the full path to the target according to the settings in its
makefile and the configuration type. */ makefile and the configuration type. */
std::string GetFullPath(const char* config=0, bool implib = false); std::string GetFullPath(const char* config=0, bool implib = false);
@ -256,7 +256,7 @@ public:
// Define the properties // Define the properties
static void DefineProperties(cmake *cm); static void DefineProperties(cmake *cm);
// Compute the OBJECT_FILES property only when requested // Compute the OBJECT_FILES property only when requested
void ComputeObjectFiles(); void ComputeObjectFiles();
@ -310,9 +310,9 @@ private:
* Finds the dependencies for \a lib and inserts them into \a * Finds the dependencies for \a lib and inserts them into \a
* dep_map. * dep_map.
*/ */
void GatherDependencies( const cmMakefile& mf, void GatherDependencies( const cmMakefile& mf,
const LibraryID& lib, const LibraryID& lib,
DependencyMap& dep_map); DependencyMap& dep_map);
const char* GetSuffixVariableInternal(TargetType type, bool implib); const char* GetSuffixVariableInternal(TargetType type, bool implib);
const char* GetPrefixVariableInternal(TargetType type, bool implib); const char* GetPrefixVariableInternal(TargetType type, bool implib);
@ -321,7 +321,7 @@ private:
void GetFullNameInternal(TargetType type, const char* config, bool implib, void GetFullNameInternal(TargetType type, const char* config, bool implib,
std::string& outPrefix, std::string& outBase, std::string& outPrefix, std::string& outBase,
std::string& outSuffix); std::string& outSuffix);
void GetLibraryNamesInternal(std::string& name, void GetLibraryNamesInternal(std::string& name,
std::string& soName, std::string& soName,
std::string& realName, std::string& realName,
@ -345,17 +345,21 @@ private:
const char* ImportedGetLocation(const char* config); const char* ImportedGetLocation(const char* config);
const char* NormalGetLocation(const char* config); const char* NormalGetLocation(const char* config);
void NormalGetFullNameInternal(TargetType type, const char* config, bool implib, void NormalGetFullNameInternal(TargetType type, const char* config,
std::string& outPrefix, std::string& outBase, bool implib,
std::string& outSuffix); std::string& outPrefix,
void ImportedGetFullNameInternal(TargetType type, const char* config, bool implib, std::string& outBase,
std::string& outPrefix, std::string& outBase, std::string& outSuffix);
std::string& outSuffix); void ImportedGetFullNameInternal(TargetType type, const char* config,
bool implib,
std::string& outPrefix,
std::string& outBase,
std::string& outSuffix);
const char* ImportedGetDirectory(const char* config, bool implib); const char* ImportedGetDirectory(const char* config, bool implib);
const char* NormalGetDirectory(const char* config, bool implib); const char* NormalGetDirectory(const char* config, bool implib);
private: private:
std::string Name; std::string Name;
std::vector<cmCustomCommand> PreBuildCommands; std::vector<cmCustomCommand> PreBuildCommands;
@ -379,7 +383,7 @@ private:
std::string Location; std::string Location;
std::string ExportMacro; std::string ExportMacro;
std::set<cmStdString> Utilities; std::set<cmStdString> Utilities;
bool RecordDependencies; bool RecordDependencies;
cmPropertyMap Properties; cmPropertyMap Properties;
LinkLibraryVectorType OriginalLinkLibraries; LinkLibraryVectorType OriginalLinkLibraries;
bool DLLPlatform; bool DLLPlatform;