summaryrefslogtreecommitdiffstats
path: root/Source/cmTarget.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/cmTarget.cxx')
-rw-r--r--Source/cmTarget.cxx580
1 files changed, 491 insertions, 89 deletions
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 274c3af..0fb6f7b 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -154,6 +154,96 @@ void cmTarget::DefineProperties(cmake *cm)
"(such as \".lib\") on an import library name.");
cm->DefineProperty
+ ("IMPORTED", cmProperty::TARGET,
+ "Read-only indication of whether a target is IMPORTED.",
+ "The boolean value of this property is true for targets created with "
+ "the IMPORTED option to add_executable or add_library. "
+ "It is false for targets built within the project.");
+
+ cm->DefineProperty
+ ("IMPORTED_CONFIGURATIONS", cmProperty::TARGET,
+ "Configurations provided for an IMPORTED target.",
+ "Lists configuration names available for an IMPORTED target. "
+ "The names correspond to configurations defined in the project from "
+ "which the target is imported. "
+ "If the importing project uses a different set of configurations "
+ "the names may be mapped using the MAP_IMPORTED_CONFIG_<CONFIG> "
+ "property. "
+ "Ignored for non-imported targets.");
+
+ cm->DefineProperty
+ ("IMPORTED_ENABLE_EXPORTS", cmProperty::TARGET,
+ "Enable linking to an IMPORTED executable target.",
+ "Indicates that an IMPORTED executable target exports symbols for "
+ "use by plugin modules. "
+ "This is the imported target equivalent of the ENABLE_EXPORTS "
+ "property.");
+
+ cm->DefineProperty
+ ("IMPORTED_IMPLIB", cmProperty::TARGET,
+ "Full path to the import library for an IMPORTED target.",
+ "Specifies the location of the \".lib\" part of a windows DLL. "
+ "Ignored for non-imported targets.");
+
+ cm->DefineProperty
+ ("IMPORTED_IMPLIB_<CONFIG>", cmProperty::TARGET,
+ "Per-configuration version of IMPORTED_IMPLIB property.",
+ "This property is used when loading settings for the <CONFIG> "
+ "configuration of an imported target. "
+ "Configuration names correspond to those provided by the project "
+ "from which the target is imported.");
+
+ cm->DefineProperty
+ ("IMPORTED_LINK_LIBRARIES", cmProperty::TARGET,
+ "Transitive link dependencies of an IMPORTED target.",
+ "Lists dependencies that must be linked when an IMPORTED library "
+ "target is linked to another target. "
+ "Ignored for non-imported targets.");
+
+ cm->DefineProperty
+ ("IMPORTED_LINK_LIBRARIES_<CONFIG>", cmProperty::TARGET,
+ "Per-configuration version of IMPORTED_LINK_LIBRARIES property.",
+ "This property is used when loading settings for the <CONFIG> "
+ "configuration of an imported target. "
+ "Configuration names correspond to those provided by the project "
+ "from which the target is imported.");
+
+ cm->DefineProperty
+ ("IMPORTED_LOCATION", cmProperty::TARGET,
+ "Full path to the main file on disk for an IMPORTED target.",
+ "Specifies the location of an IMPORTED target file on disk. "
+ "For executables this is the location of the executable file. "
+ "For static libraries and modules this is the location of the "
+ "library or module. "
+ "For shared libraries on non-DLL platforms this is the location of "
+ "the shared library. "
+ "For DLLs this is the location of the \".dll\" part of the library. "
+ "Ignored for non-imported targets.");
+
+ cm->DefineProperty
+ ("IMPORTED_LOCATION_<CONFIG>", cmProperty::TARGET,
+ "Per-configuration version of IMPORTED_LOCATION property.",
+ "This property is used when loading settings for the <CONFIG> "
+ "configuration of an imported target. "
+ "Configuration names correspond to those provided by the project "
+ "from which the target is imported.");
+
+ cm->DefineProperty
+ ("IMPORTED_SONAME", cmProperty::TARGET,
+ "The \"soname\" of an IMPORTED target of shared library type.",
+ "Specifies the \"soname\" embedded in an imported shared library. "
+ "This is meaningful only on platforms supporting the feature. "
+ "Ignored for non-imported targets.");
+
+ cm->DefineProperty
+ ("IMPORTED_SONAME_<CONFIG>", cmProperty::TARGET,
+ "Per-configuration version of IMPORTED_SONAME property.",
+ "This property is used when loading settings for the <CONFIG> "
+ "configuration of an imported target. "
+ "Configuration names correspond to those provided by the project "
+ "from which the target is imported.");
+
+ cm->DefineProperty
("EXCLUDE_FROM_ALL", cmProperty::TARGET,
"Exclude the target from the all target.",
"A property on a target that indicates if the target is excluded "
@@ -206,11 +296,37 @@ void cmTarget::DefineProperties(cmake *cm)
cm->DefineProperty
("LOCATION", cmProperty::TARGET,
- "Where a target will be written on disk.",
- "A read only property on a target that indicates where that target "
- "will be written. For libraries and executables this will be where "
- "the file is written on disk. This property is computed based on a "
- "number of other settings.");
+ "Deprecated. Use LOCATION_<CONFIG> or avoid altogether.",
+ "This property is provided for compatibility with CMake 2.4 and below. "
+ "It was meant to get the location of an executable target's output file "
+ "for use in add_custom_command. "
+ "In CMake 2.6 and above add_custom_command automatically recognizes a "
+ "target name in its COMMAND and DEPENDS options and computes the "
+ "target location. Therefore this property need not be used. "
+ "This property is not defined for IMPORTED targets because they "
+ "were not available in CMake 2.4 or below anyway.");
+
+ cm->DefineProperty
+ ("LOCATION_<CONFIG>", cmProperty::TARGET,
+ "Read-only property providing a target location on disk.",
+ "A read-only property that indicates where a target's main file is "
+ "located on disk for the configuration <CONFIG>. "
+ "The property is defined only for library and executable targets.");
+
+ cm->DefineProperty
+ ("MAP_IMPORTED_CONFIG_<CONFIG>", cmProperty::TARGET,
+ "Map from project configuration to IMPORTED target's configuration.",
+ "List configurations of an imported target that may be used for "
+ "the current project's <CONFIG> configuration. "
+ "Targets imported from another project may not provide the same set "
+ "of configuration names available in the current project. "
+ "Setting this property tells CMake what imported configurations are "
+ "suitable for use when building the <CONFIG> configuration. "
+ "The first configuration in the list found to be provided by the "
+ "imported target is selected. If no matching configurations are "
+ "available the imported target is considered to be not found. "
+ "This property is ignored for non-imported targets.",
+ false /* TODO: make this chained */ );
cm->DefineProperty
("OUTPUT_NAME", cmProperty::TARGET,
@@ -481,6 +597,25 @@ void cmTarget::SetMakefile(cmMakefile* mf)
}
//----------------------------------------------------------------------------
+bool cmTarget::IsExecutableWithExports()
+{
+ if(this->GetType() == cmTarget::EXECUTABLE)
+ {
+ if(this->IsImported())
+ {
+ // The "IMPORTED_" namespace is used for properties exported
+ // from the project providing imported targets.
+ return this->GetPropertyAsBool("IMPORTED_ENABLE_EXPORTS");
+ }
+ else
+ {
+ return this->GetPropertyAsBool("ENABLE_EXPORTS");
+ }
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
class cmTargetTraceDependencies
{
public:
@@ -603,8 +738,7 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
}
// Check for a non-imported target with this name.
- if(cmTarget* t =
- this->GlobalGenerator->FindTarget(0, util.c_str(), false))
+ if(cmTarget* t = this->GlobalGenerator->FindTarget(0, util.c_str()))
{
// If we find the target and the dep was given as a full path,
// then make sure it was not a full path to something else, and
@@ -671,8 +805,7 @@ cmTargetTraceDependencies
{
std::string const& command = *cit->begin();
// Look for a non-imported target with this name.
- if(cmTarget* t =
- this->GlobalGenerator->FindTarget(0, command.c_str(), false))
+ if(cmTarget* t = this->GlobalGenerator->FindTarget(0, command.c_str()))
{
if(t->GetType() == cmTarget::EXECUTABLE)
{
@@ -1287,6 +1420,13 @@ void cmTarget::SetProperty(const char* prop, const char* value)
}
this->Properties.SetProperty(prop, value, cmProperty::TARGET);
+
+ // If imported information is being set, wipe out cached
+ // information.
+ if(this->IsImported() && strncmp(prop, "IMPORTED", 8) == 0)
+ {
+ this->ImportInfoMap.clear();
+ }
}
//----------------------------------------------------------------------------
@@ -1297,6 +1437,13 @@ void cmTarget::AppendProperty(const char* prop, const char* value)
return;
}
this->Properties.AppendProperty(prop, value, cmProperty::TARGET);
+
+ // If imported information is being set, wipe out cached
+ // information.
+ if(this->IsImported() && strncmp(prop, "IMPORTED", 8) == 0)
+ {
+ this->ImportInfoMap.clear();
+ }
}
//----------------------------------------------------------------------------
@@ -1319,10 +1466,11 @@ 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 implib)
{
- const char* location=this->GetLocation(config);
- this->Directory = cmSystemTools::GetFilenamePath(location);
+ this->Directory =
+ cmSystemTools::GetFilenamePath(
+ this->ImportedGetFullPath(config, implib));
return this->Directory.c_str();
}
@@ -1360,18 +1508,8 @@ const char* cmTarget::GetLocation(const char* config)
//----------------------------------------------------------------------------
const char* cmTarget::ImportedGetLocation(const char* config)
{
- if ((config) && (strlen(config)))
- {
- std::string propertyName=cmSystemTools::UpperCase(config);
- propertyName+="_LOCATION";
- const char* configLocation=this->GetProperty(propertyName.c_str());
- if ((configLocation) && (strlen(configLocation)))
- {
- return configLocation;
- }
- }
-
- return this->GetProperty("LOCATION");
+ this->Location = this->ImportedGetFullPath(config, false);
+ return this->Location.c_str();
}
//----------------------------------------------------------------------------
@@ -1484,38 +1622,41 @@ const char *cmTarget::GetProperty(const char* prop,
return 0;
}
- // don't use GetLocation() for imported targets, because there this
- // calls GetProperty() to get the location...
- if (!this->IsImported())
+ // Watch for special "computed" properties that are dependent on
+ // other properties or variables. Always recompute them.
+ if(this->GetType() == cmTarget::EXECUTABLE ||
+ this->GetType() == cmTarget::STATIC_LIBRARY ||
+ this->GetType() == cmTarget::SHARED_LIBRARY ||
+ this->GetType() == cmTarget::MODULE_LIBRARY)
{
- // watch for special "computed" properties that are dependent on other
- // properties or variables, always recompute them
- if (!strcmp(prop,"LOCATION"))
+ if(!this->IsImported() && strcmp(prop,"LOCATION") == 0)
{
// Set the LOCATION property of the target. Note that this
// cannot take into account the per-configuration name of the
// target because the configuration type may not be known at
- // CMake time. We should deprecate this feature and instead
- // support transforming an executable target name given as the
- // command part of custom commands into the proper path at
- // build time. Alternatively we could put environment
- // variable settings in all custom commands that hold the name
- // of the target for each configuration and then give a
- // reference to the variable in the location.
+ // CMake time. It is now deprecated as described in the
+ // documentation.
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)
+ // Support "LOCATION_<CONFIG>".
+ if(strncmp(prop, "LOCATION_", 9) == 0)
{
- std::string configName(prop, len-9);
+ std::string configName = prop+9;
this->SetProperty(prop, this->GetLocation(configName.c_str()));
}
-
- if(strcmp(prop, "OBJECT_FILES") == 0)
+ else
{
- this->ComputeObjectFiles();
+ // Support "<CONFIG>_LOCATION" for compatiblity.
+ int len = static_cast<int>(strlen(prop));
+ if(len > 9 && strcmp(prop+len-9, "_LOCATION") == 0)
+ {
+ std::string configName(prop, len-9);
+ if(configName != "IMPORTED")
+ {
+ this->SetProperty(prop, this->GetLocation(configName.c_str()));
+ }
+ }
}
}
@@ -1750,15 +1891,57 @@ std::string cmTarget::GetPDBName(const char* config)
}
//----------------------------------------------------------------------------
+std::string cmTarget::GetSOName(const char* config)
+{
+ if(this->IsImported())
+ {
+ // Lookup the imported soname.
+ if(cmTarget::ImportInfo const* info = this->GetImportInfo(config))
+ {
+ return info->SOName;
+ }
+ else
+ {
+ return "";
+ }
+ }
+ else
+ {
+ // Compute the soname that will be built.
+ std::string name;
+ std::string soName;
+ std::string realName;
+ std::string impName;
+ std::string pdbName;
+ this->GetLibraryNames(name, soName, realName, impName, pdbName, config);
+ return soName;
+ }
+}
+
+//----------------------------------------------------------------------------
std::string cmTarget::GetFullName(const char* config, bool implib)
{
- return this->GetFullNameInternal(this->GetType(), config, implib);
+ if(this->IsImported())
+ {
+ return this->GetFullNameImported(config, implib);
+ }
+ else
+ {
+ return this->GetFullNameInternal(this->GetType(), config, implib);
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string cmTarget::GetFullNameImported(const char* config, bool implib)
+{
+ return cmSystemTools::GetFilenameName(
+ this->ImportedGetFullPath(config, implib));
}
//----------------------------------------------------------------------------
-void cmTarget::GetFullName(std::string& prefix, std::string& base,
- std::string& suffix, const char* config,
- bool implib)
+void cmTarget::GetFullNameComponents(std::string& prefix, std::string& base,
+ std::string& suffix, const char* config,
+ bool implib)
{
this->GetFullNameInternal(this->GetType(), config, implib,
prefix, base, suffix);
@@ -1767,6 +1950,19 @@ void cmTarget::GetFullName(std::string& prefix, std::string& base,
//----------------------------------------------------------------------------
std::string cmTarget::GetFullPath(const char* config, bool implib)
{
+ if(this->IsImported())
+ {
+ return this->ImportedGetFullPath(config, implib);
+ }
+ else
+ {
+ return this->NormalGetFullPath(config, implib);
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string cmTarget::NormalGetFullPath(const char* config, bool implib)
+{
// Start with the output directory for the target.
std::string fpath = this->GetDirectory(config, implib);
fpath += "/";
@@ -1777,8 +1973,31 @@ std::string cmTarget::GetFullPath(const char* config, bool implib)
}
//----------------------------------------------------------------------------
-std::string cmTarget::GetFullNameInternal(TargetType type, const char* config,
- bool implib)
+std::string cmTarget::ImportedGetFullPath(const char* config, bool implib)
+{
+ if(cmTarget::ImportInfo const* info = this->GetImportInfo(config))
+ {
+ if(implib)
+ {
+ return info->ImportLibrary;
+ }
+ else
+ {
+ return info->Location;
+ }
+ }
+ else
+ {
+ std::string result = this->GetName();
+ result += "-NOTFOUND";
+ return result;
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmTarget::GetFullNameInternal(TargetType type, const char* config,
+ bool implib)
{
std::string prefix;
std::string base;
@@ -1795,43 +2014,6 @@ void cmTarget::GetFullNameInternal(TargetType type,
std::string& outBase,
std::string& outSuffix)
{
- if (this->IsImported())
- {
- this->ImportedGetFullNameInternal(type, config, implib,
- outPrefix, outBase, outSuffix);
- }
- else
- {
- this->NormalGetFullNameInternal(type, config, implib,
- outPrefix, outBase, outSuffix);
- }
-}
-
-//----------------------------------------------------------------------------
-void cmTarget::ImportedGetFullNameInternal(TargetType ,
- const char* config,
- bool ,
- std::string& outPrefix,
- std::string& outBase,
- std::string& outSuffix)
-{
- // find the basename, suffix and prefix from getLocation()
- // implib ?
- std::string location=this->GetLocation(config);
- outBase=cmSystemTools::GetFilenameWithoutExtension(location);
- outSuffix = cmSystemTools::GetFilenameExtension(location);
- outPrefix = "";
-}
-
-
-//----------------------------------------------------------------------------
-void cmTarget::NormalGetFullNameInternal(TargetType type,
- const char* config,
- bool implib,
- std::string& outPrefix,
- std::string& outBase,
- std::string& outSuffix)
-{
// Use just the target name for non-main target types.
if(type != cmTarget::STATIC_LIBRARY &&
type != cmTarget::SHARED_LIBRARY &&
@@ -2019,6 +2201,14 @@ void cmTarget::GetLibraryNamesInternal(std::string& name,
TargetType type,
const char* config)
{
+ // This should not be called for imported targets.
+ // TODO: Split cmTarget into a class hierarchy to get compile-time
+ // enforcement of the limited imported target API.
+ if(this->IsImported())
+ {
+ abort();
+ }
+
// Construct the name of the soname flag variable for this language.
const char* ll =
this->GetLinkerLanguage(
@@ -2140,6 +2330,14 @@ void cmTarget::GetExecutableNamesInternal(std::string& name,
TargetType type,
const char* config)
{
+ // This should not be called for imported targets.
+ // TODO: Split cmTarget into a class hierarchy to get compile-time
+ // enforcement of the limited imported target API.
+ if(this->IsImported())
+ {
+ abort();
+ }
+
// This versioning is supported only for executables and then only
// when the platform supports symbolic links.
#if defined(_WIN32) && !defined(__CYGWIN__)
@@ -2554,8 +2752,7 @@ const char* cmTarget::GetExportMacro()
// Define the symbol for targets that export symbols.
if(this->GetType() == cmTarget::SHARED_LIBRARY ||
this->GetType() == cmTarget::MODULE_LIBRARY ||
- this->GetType() == cmTarget::EXECUTABLE &&
- this->GetPropertyAsBool("ENABLE_EXPORTS"))
+ this->IsExecutableWithExports())
{
if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL"))
{
@@ -2618,3 +2815,208 @@ bool cmTarget::IsChrpathAvailable()
return true;
}
+
+//----------------------------------------------------------------------------
+cmTarget::ImportInfo const*
+cmTarget::GetImportInfo(const char* config)
+{
+ // There is no imported information for non-imported targets.
+ if(!this->IsImported())
+ {
+ return 0;
+ }
+
+ // Lookup/compute/cache the import information for this
+ // configuration.
+ std::string config_upper;
+ if(config && *config)
+ {
+ config_upper = cmSystemTools::UpperCase(config);
+ }
+ else
+ {
+ config_upper = "NOCONFIG";
+ }
+ ImportInfoMapType::const_iterator i =
+ this->ImportInfoMap.find(config_upper);
+ if(i == this->ImportInfoMap.end())
+ {
+ ImportInfo info;
+ this->ComputeImportInfo(config_upper, info);
+ ImportInfoMapType::value_type entry(config_upper, info);
+ i = this->ImportInfoMap.insert(entry).first;
+ }
+
+ // If the location is empty then the target is not available for
+ // this configuration.
+ if(i->second.Location.empty())
+ {
+ return 0;
+ }
+
+ // Return the import information.
+ return &i->second;
+}
+
+//----------------------------------------------------------------------------
+void cmTarget::ComputeImportInfo(std::string const& desired_config,
+ ImportInfo& info)
+{
+ // This method finds information about an imported target from its
+ // properties. The "IMPORTED_" namespace is reserved for properties
+ // defined by the project exporting the target.
+
+ // Track the configuration-specific property suffix.
+ std::string suffix = "_";
+ suffix += desired_config;
+
+ // Look for a mapping from the current project's configuration to
+ // the imported project's configuration.
+ std::vector<std::string> mappedConfigs;
+ {
+ std::string mapProp = "MAP_IMPORTED_CONFIG_";
+ mapProp += desired_config;
+ if(const char* mapValue = this->GetProperty(mapProp.c_str()))
+ {
+ cmSystemTools::ExpandListArgument(mapValue, mappedConfigs);
+ }
+ }
+
+ // If a mapping was found, check its configurations.
+ const char* loc = 0;
+ for(std::vector<std::string>::const_iterator mci = mappedConfigs.begin();
+ !loc && mci != mappedConfigs.end(); ++mci)
+ {
+ // Look for this configuration.
+ std::string mcUpper = cmSystemTools::UpperCase(mci->c_str());
+ std::string locProp = "IMPORTED_LOCATION_";
+ locProp += mcUpper;
+ loc = this->GetProperty(locProp.c_str());
+
+ // If it was found, use it for all properties below.
+ if(loc)
+ {
+ suffix = "_";
+ suffix += mcUpper;
+ }
+ }
+
+ // If we needed to find one of the mapped configurations but did not
+ // then the target is not found. The project does not want any
+ // other configuration.
+ if(!mappedConfigs.empty() && !loc)
+ {
+ return;
+ }
+
+ // If we have not yet found it then there are no mapped
+ // configurations. Look for an exact-match.
+ if(!loc)
+ {
+ std::string locProp = "IMPORTED_LOCATION";
+ locProp += suffix;
+ loc = this->GetProperty(locProp.c_str());
+ }
+
+ // If we have not yet found it then there are no mapped
+ // configurations and no exact match.
+ if(!loc)
+ {
+ // The suffix computed above is not useful.
+ suffix = "";
+
+ // Look for a configuration-less location. This may be set by
+ // manually-written code.
+ loc = this->GetProperty("IMPORTED_LOCATION");
+ }
+
+ // If we have not yet found it then the project is willing to try
+ // any available configuration.
+ if(!loc)
+ {
+ std::vector<std::string> availableConfigs;
+ if(const char* iconfigs = this->GetProperty("IMPORTED_CONFIGURATIONS"))
+ {
+ cmSystemTools::ExpandListArgument(iconfigs, availableConfigs);
+ }
+ for(std::vector<std::string>::const_iterator
+ aci = availableConfigs.begin();
+ !loc && aci != availableConfigs.end(); ++aci)
+ {
+ suffix = "_";
+ suffix += cmSystemTools::UpperCase(availableConfigs[0]);
+ std::string locProp = "IMPORTED_LOCATION";
+ locProp += suffix;
+ loc = this->GetProperty(locProp.c_str());
+ }
+ }
+
+ // If we have not yet found it then the target is not available.
+ if(!loc)
+ {
+ return;
+ }
+
+ // A provided configuration has been chosen. Load the
+ // configuration's properties.
+ info.Location = loc;
+
+ // Get the soname.
+ if(this->GetType() == cmTarget::SHARED_LIBRARY)
+ {
+ std::string soProp = "IMPORTED_SONAME";
+ soProp += suffix;
+ if(const char* config_soname = this->GetProperty(soProp.c_str()))
+ {
+ info.SOName = config_soname;
+ }
+ else if(const char* soname = this->GetProperty("IMPORTED_SONAME"))
+ {
+ info.SOName = soname;
+ }
+ }
+
+ // Get the import library.
+ if(this->GetType() == cmTarget::SHARED_LIBRARY ||
+ this->IsExecutableWithExports())
+ {
+ std::string impProp = "IMPORTED_IMPLIB";
+ impProp += suffix;
+ if(const char* config_implib = this->GetProperty(impProp.c_str()))
+ {
+ info.ImportLibrary = config_implib;
+ }
+ else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB"))
+ {
+ info.ImportLibrary = implib;
+ }
+ }
+
+ // Get the link dependencies.
+ {
+ std::string linkProp = "IMPORTED_LINK_LIBRARIES";
+ linkProp += suffix;
+ if(const char* config_libs = this->GetProperty(linkProp.c_str()))
+ {
+ cmSystemTools::ExpandListArgument(config_libs, info.LinkLibraries);
+ }
+ else if(const char* libs = this->GetProperty("IMPORTED_LINK_LIBRARIES"))
+ {
+ cmSystemTools::ExpandListArgument(libs, info.LinkLibraries);
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+std::vector<std::string> const*
+cmTarget::GetImportedLinkLibraries(const char* config)
+{
+ if(cmTarget::ImportInfo const* info = this->GetImportInfo(config))
+ {
+ return &info->LinkLibraries;
+ }
+ else
+ {
+ return 0;
+ }
+}