739 lines
28 KiB
C++
739 lines
28 KiB
C++
/*============================================================================
|
|
CMake - Cross Platform Makefile Generator
|
|
Copyright 2000-2012 Kitware, Inc., Insight Software Consortium
|
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
see accompanying file Copyright.txt for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the License for more information.
|
|
============================================================================*/
|
|
#ifndef cmGeneratorTarget_h
|
|
#define cmGeneratorTarget_h
|
|
|
|
#include <cmConfigure.h>
|
|
|
|
#include "cmLinkItem.h"
|
|
#include "cmListFileCache.h"
|
|
#include "cmPolicies.h"
|
|
#include "cmState.h"
|
|
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
class cmComputeLinkInformation;
|
|
class cmCustomCommand;
|
|
class cmGlobalGenerator;
|
|
class cmLocalGenerator;
|
|
class cmMakefile;
|
|
class cmSourceFile;
|
|
class cmTarget;
|
|
|
|
class cmGeneratorTarget
|
|
{
|
|
public:
|
|
cmGeneratorTarget(cmTarget*, cmLocalGenerator* lg);
|
|
~cmGeneratorTarget();
|
|
|
|
cmLocalGenerator* GetLocalGenerator() const;
|
|
|
|
bool IsImported() const;
|
|
bool IsImportedGloballyVisible() const;
|
|
const char* GetLocation(const std::string& config) const;
|
|
|
|
std::vector<cmCustomCommand> const& GetPreBuildCommands() const;
|
|
std::vector<cmCustomCommand> const& GetPreLinkCommands() const;
|
|
std::vector<cmCustomCommand> const& GetPostBuildCommands() const;
|
|
|
|
#define DECLARE_TARGET_POLICY(POLICY) \
|
|
cmPolicies::PolicyStatus GetPolicyStatus##POLICY() const \
|
|
{ \
|
|
return this->PolicyMap.Get(cmPolicies::POLICY); \
|
|
}
|
|
|
|
CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY)
|
|
|
|
#undef DECLARE_TARGET_POLICY
|
|
|
|
/** Get the location of the target in the build tree with a placeholder
|
|
referencing the configuration in the native build system. This
|
|
location is suitable for use as the LOCATION target property. */
|
|
const char* GetLocationForBuild() const;
|
|
|
|
cmComputeLinkInformation* GetLinkInformation(
|
|
const std::string& config) const;
|
|
|
|
cmState::TargetType GetType() const;
|
|
const std::string& GetName() const;
|
|
std::string GetExportName() const;
|
|
|
|
std::vector<std::string> GetPropertyKeys() const;
|
|
const char* GetProperty(const std::string& prop) const;
|
|
bool GetPropertyAsBool(const std::string& prop) const;
|
|
void GetSourceFiles(std::vector<cmSourceFile*>& files,
|
|
const std::string& config) const;
|
|
|
|
void GetObjectSources(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
const std::string& GetObjectName(cmSourceFile const* file);
|
|
|
|
bool HasExplicitObjectName(cmSourceFile const* file) const;
|
|
void AddExplicitObjectName(cmSourceFile const* sf);
|
|
|
|
void GetResxSources(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetIDLSources(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetExternalObjects(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetHeaderSources(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetExtraSources(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetCustomCommands(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetExpectedResxHeaders(std::set<std::string>&,
|
|
const std::string& config) const;
|
|
void GetAppManifest(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetManifests(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetCertificates(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetXamlSources(std::vector<cmSourceFile const*>&,
|
|
const std::string& config) const;
|
|
void GetExpectedXamlHeaders(std::set<std::string>&,
|
|
const std::string& config) const;
|
|
void GetExpectedXamlSources(std::set<std::string>&,
|
|
const std::string& config) const;
|
|
|
|
std::set<cmLinkItem> const& GetUtilityItems() const;
|
|
|
|
void ComputeObjectMapping();
|
|
|
|
const char* GetFeature(const std::string& feature,
|
|
const std::string& config) const;
|
|
bool GetFeatureAsBool(const std::string& feature,
|
|
const std::string& config) const;
|
|
|
|
bool IsLinkInterfaceDependentBoolProperty(const std::string& p,
|
|
const std::string& config) const;
|
|
bool IsLinkInterfaceDependentStringProperty(const std::string& p,
|
|
const std::string& config) const;
|
|
bool IsLinkInterfaceDependentNumberMinProperty(
|
|
const std::string& p, const std::string& config) const;
|
|
bool IsLinkInterfaceDependentNumberMaxProperty(
|
|
const std::string& p, const std::string& config) const;
|
|
|
|
bool GetLinkInterfaceDependentBoolProperty(const std::string& p,
|
|
const std::string& config) const;
|
|
|
|
const char* GetLinkInterfaceDependentStringProperty(
|
|
const std::string& p, const std::string& config) const;
|
|
const char* GetLinkInterfaceDependentNumberMinProperty(
|
|
const std::string& p, const std::string& config) const;
|
|
const char* GetLinkInterfaceDependentNumberMaxProperty(
|
|
const std::string& p, const std::string& config) const;
|
|
|
|
cmLinkInterface const* GetLinkInterface(
|
|
const std::string& config, const cmGeneratorTarget* headTarget) const;
|
|
void ComputeLinkInterface(const std::string& config,
|
|
cmOptionalLinkInterface& iface,
|
|
const cmGeneratorTarget* head) const;
|
|
|
|
cmLinkInterfaceLibraries const* GetLinkInterfaceLibraries(
|
|
const std::string& config, const cmGeneratorTarget* headTarget,
|
|
bool usage_requirements_only) const;
|
|
|
|
void ComputeLinkInterfaceLibraries(const std::string& config,
|
|
cmOptionalLinkInterface& iface,
|
|
const cmGeneratorTarget* head,
|
|
bool usage_requirements_only) const;
|
|
|
|
/** Get the full path to the target according to the settings in its
|
|
makefile and the configuration type. */
|
|
std::string GetFullPath(const std::string& config = "", bool implib = false,
|
|
bool realname = false) const;
|
|
std::string NormalGetFullPath(const std::string& config, bool implib,
|
|
bool realname) const;
|
|
std::string NormalGetRealName(const std::string& config) const;
|
|
|
|
/** @return the Mac App directory without the base */
|
|
std::string GetAppBundleDirectory(const std::string& config,
|
|
bool contentOnly) const;
|
|
|
|
/** Return whether this target is an executable Bundle, a framework
|
|
or CFBundle on Apple. */
|
|
bool IsBundleOnApple() const;
|
|
|
|
/** Get the full name of the target according to the settings in its
|
|
makefile. */
|
|
std::string GetFullName(const std::string& config = "",
|
|
bool implib = false) const;
|
|
|
|
/** @return the Mac framework directory without the base. */
|
|
std::string GetFrameworkDirectory(const std::string& config,
|
|
bool rootDir) const;
|
|
|
|
/** Return the framework version string. Undefined if
|
|
IsFrameworkOnApple returns false. */
|
|
std::string GetFrameworkVersion() const;
|
|
|
|
/** @return the Mac CFBundle directory without the base */
|
|
std::string GetCFBundleDirectory(const std::string& config,
|
|
bool contentOnly) const;
|
|
|
|
/** Return the install name directory for the target in the
|
|
* build tree. For example: "\@rpath/", "\@loader_path/",
|
|
* or "/full/path/to/library". */
|
|
std::string GetInstallNameDirForBuildTree(const std::string& config) const;
|
|
|
|
/** Return the install name directory for the target in the
|
|
* install tree. For example: "\@rpath/" or "\@loader_path/". */
|
|
std::string GetInstallNameDirForInstallTree() const;
|
|
|
|
cmListFileBacktrace GetBacktrace() const;
|
|
|
|
const std::vector<std::string>& GetLinkDirectories() const;
|
|
|
|
std::set<std::string> const& GetUtilities() const;
|
|
cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
|
|
|
|
bool LinkLanguagePropagatesToDependents() const
|
|
{
|
|
return this->GetType() == cmState::STATIC_LIBRARY;
|
|
}
|
|
|
|
/** Get the macro to define when building sources in this target.
|
|
If no macro should be defined null is returned. */
|
|
const char* GetExportMacro() const;
|
|
|
|
/** Get the soname of the target. Allowed only for a shared library. */
|
|
std::string GetSOName(const std::string& config) const;
|
|
|
|
void GetFullNameComponents(std::string& prefix, std::string& base,
|
|
std::string& suffix,
|
|
const std::string& config = "",
|
|
bool implib = false) const;
|
|
|
|
/** Append to @a base the mac content directory and return it. */
|
|
std::string BuildMacContentDirectory(const std::string& base,
|
|
const std::string& config = "",
|
|
bool contentOnly = true) const;
|
|
|
|
/** @return the mac content directory for this target. */
|
|
std::string GetMacContentDirectory(const std::string& config = CM_NULLPTR,
|
|
bool implib = false) const;
|
|
|
|
cmTarget* Target;
|
|
cmMakefile* Makefile;
|
|
cmLocalGenerator* LocalGenerator;
|
|
cmGlobalGenerator const* GlobalGenerator;
|
|
|
|
cmSourceFile const* GetModuleDefinitionFile(const std::string& config) const;
|
|
|
|
/** Return whether or not the target is for a DLL platform. */
|
|
bool IsDLLPlatform() const;
|
|
|
|
/** @return whether this target have a well defined output file name. */
|
|
bool HaveWellDefinedOutputFiles() const;
|
|
|
|
/** Link information from the transitive closure of the link
|
|
implementation and the interfaces of its dependencies. */
|
|
struct LinkClosure
|
|
{
|
|
// The preferred linker language.
|
|
std::string LinkerLanguage;
|
|
|
|
// Languages whose runtime libraries must be linked.
|
|
std::vector<std::string> Languages;
|
|
};
|
|
|
|
LinkClosure const* GetLinkClosure(const std::string& config) const;
|
|
void ComputeLinkClosure(const std::string& config, LinkClosure& lc) const;
|
|
|
|
cmLinkImplementation const* GetLinkImplementation(
|
|
const std::string& config) const;
|
|
|
|
void ComputeLinkImplementationLanguages(
|
|
const std::string& config, cmOptionalLinkImplementation& impl) const;
|
|
|
|
cmLinkImplementationLibraries const* GetLinkImplementationLibraries(
|
|
const std::string& config) const;
|
|
|
|
void ComputeLinkImplementationLibraries(const std::string& config,
|
|
cmOptionalLinkImplementation& impl,
|
|
const cmGeneratorTarget* head) const;
|
|
|
|
cmGeneratorTarget* FindTargetToLink(std::string const& name) const;
|
|
|
|
// Compute the set of languages compiled by the target. This is
|
|
// computed every time it is called because the languages can change
|
|
// when source file properties are changed and we do not have enough
|
|
// information to forward these property changes to the targets
|
|
// until we have per-target object file properties.
|
|
void GetLanguages(std::set<std::string>& languages,
|
|
std::string const& config) const;
|
|
|
|
void GetObjectLibrariesCMP0026(
|
|
std::vector<cmGeneratorTarget*>& objlibs) const;
|
|
|
|
std::string GetFullNameImported(const std::string& config,
|
|
bool implib) const;
|
|
|
|
bool GetConfigCommonSourceFiles(std::vector<cmSourceFile*>& files) const;
|
|
|
|
bool HaveBuildTreeRPATH(const std::string& config) const;
|
|
|
|
/** Full path with trailing slash to the top-level directory
|
|
holding object files for this target. Includes the build
|
|
time config name placeholder if needed for the generator. */
|
|
std::string ObjectDirectory;
|
|
|
|
void UseObjectLibraries(std::vector<std::string>& objs,
|
|
const std::string& config) const;
|
|
|
|
void GetAppleArchs(const std::string& config,
|
|
std::vector<std::string>& archVec) const;
|
|
|
|
/** Return the rule variable used to create this type of target. */
|
|
std::string GetCreateRuleVariable(std::string const& lang,
|
|
std::string const& config) const;
|
|
|
|
/** Get the include directories for this target. */
|
|
std::vector<std::string> GetIncludeDirectories(
|
|
const std::string& config, const std::string& lang) const;
|
|
|
|
void GetCompileOptions(std::vector<std::string>& result,
|
|
const std::string& config,
|
|
const std::string& language) const;
|
|
|
|
void GetCompileFeatures(std::vector<std::string>& features,
|
|
const std::string& config) const;
|
|
|
|
void GetCompileDefinitions(std::vector<std::string>& result,
|
|
const std::string& config,
|
|
const std::string& language) const;
|
|
|
|
bool IsSystemIncludeDirectory(const std::string& dir,
|
|
const std::string& config) const;
|
|
|
|
/** Add the target output files to the global generator manifest. */
|
|
void ComputeTargetManifest(const std::string& config) const;
|
|
|
|
/**
|
|
* Trace through the source files in this target and add al source files
|
|
* that they depend on, used by all generators
|
|
*/
|
|
void TraceDependencies();
|
|
|
|
/** Get the directory in which this target will be built. If the
|
|
configuration name is given then the generator will add its
|
|
subdirectory for that configuration. Otherwise just the canonical
|
|
output directory is given. */
|
|
std::string GetDirectory(const std::string& config = "",
|
|
bool implib = false) const;
|
|
|
|
/** Get the directory in which to place the target compiler .pdb file.
|
|
If the configuration name is given then the generator will add its
|
|
subdirectory for that configuration. Otherwise just the canonical
|
|
compiler pdb output directory is given. */
|
|
std::string GetCompilePDBDirectory(const std::string& config = "") const;
|
|
|
|
/** Get sources that must be built before the given source. */
|
|
std::vector<cmSourceFile*> const* GetSourceDepends(
|
|
cmSourceFile const* sf) const;
|
|
|
|
/** Return whether this target uses the default value for its output
|
|
directory. */
|
|
bool UsesDefaultOutputDir(const std::string& config, bool implib) const;
|
|
|
|
// Cache target output paths for each configuration.
|
|
struct OutputInfo
|
|
{
|
|
std::string OutDir;
|
|
std::string ImpDir;
|
|
std::string PdbDir;
|
|
bool empty() const
|
|
{
|
|
return OutDir.empty() && ImpDir.empty() && PdbDir.empty();
|
|
}
|
|
};
|
|
|
|
OutputInfo const* GetOutputInfo(const std::string& config) const;
|
|
|
|
/** Get the name of the pdb file for the target. */
|
|
std::string GetPDBName(const std::string& config = "") const;
|
|
|
|
/** Whether this library has soname enabled and platform supports it. */
|
|
bool HasSOName(const std::string& config) const;
|
|
|
|
struct CompileInfo
|
|
{
|
|
std::string CompilePdbDir;
|
|
};
|
|
|
|
CompileInfo const* GetCompileInfo(const std::string& config) const;
|
|
|
|
typedef std::map<std::string, CompileInfo> CompileInfoMapType;
|
|
mutable CompileInfoMapType CompileInfoMap;
|
|
|
|
bool IsNullImpliedByLinkLibraries(const std::string& p) const;
|
|
|
|
/** Get the name of the compiler pdb file for the target. */
|
|
std::string GetCompilePDBName(const std::string& config = "") const;
|
|
|
|
/** Get the path for the MSVC /Fd option for this target. */
|
|
std::string GetCompilePDBPath(const std::string& config = "") const;
|
|
|
|
// Get the target base name.
|
|
std::string GetOutputName(const std::string& config, bool implib) const;
|
|
|
|
void AddSource(const std::string& src);
|
|
void AddTracedSources(std::vector<std::string> const& srcs);
|
|
|
|
/**
|
|
* Flags for a given source file as used in this target. Typically assigned
|
|
* via SET_TARGET_PROPERTIES when the property is a list of source files.
|
|
*/
|
|
enum SourceFileType
|
|
{
|
|
SourceFileTypeNormal,
|
|
SourceFileTypePrivateHeader, // is in "PRIVATE_HEADER" target property
|
|
SourceFileTypePublicHeader, // is in "PUBLIC_HEADER" target property
|
|
SourceFileTypeResource, // is in "RESOURCE" target property *or*
|
|
// has MACOSX_PACKAGE_LOCATION=="Resources"
|
|
SourceFileTypeMacContent // has MACOSX_PACKAGE_LOCATION!="Resources"
|
|
};
|
|
struct SourceFileFlags
|
|
{
|
|
SourceFileFlags()
|
|
: Type(SourceFileTypeNormal)
|
|
, MacFolder(CM_NULLPTR)
|
|
{
|
|
}
|
|
SourceFileFlags(SourceFileFlags const& r)
|
|
: Type(r.Type)
|
|
, MacFolder(r.MacFolder)
|
|
{
|
|
}
|
|
SourceFileType Type;
|
|
const char* MacFolder; // location inside Mac content folders
|
|
};
|
|
void GetAutoUicOptions(std::vector<std::string>& result,
|
|
const std::string& config) const;
|
|
|
|
/** Get the names of the executable needed to generate a build rule
|
|
that takes into account executable version numbers. This should
|
|
be called only on an executable target. */
|
|
void GetExecutableNames(std::string& name, std::string& realName,
|
|
std::string& impName, std::string& pdbName,
|
|
const std::string& config) const;
|
|
|
|
/** 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(std::string& name, std::string& soName,
|
|
std::string& realName, std::string& impName,
|
|
std::string& pdbName, const std::string& config) const;
|
|
|
|
/**
|
|
* Compute whether this target must be relinked before installing.
|
|
*/
|
|
bool NeedRelinkBeforeInstall(const std::string& config) const;
|
|
|
|
/** Return true if builtin chrpath will work for this target */
|
|
bool IsChrpathUsed(const std::string& config) const;
|
|
|
|
/** Get the directory in which this targets .pdb files will be placed.
|
|
If the configuration name is given then the generator will add its
|
|
subdirectory for that configuration. Otherwise just the canonical
|
|
pdb output directory is given. */
|
|
std::string GetPDBDirectory(const std::string& config) const;
|
|
|
|
///! Return the preferred linker language for this target
|
|
std::string GetLinkerLanguage(const std::string& config = "") const;
|
|
|
|
/** Does this target have a GNU implib to convert to MS format? */
|
|
bool HasImplibGNUtoMS() const;
|
|
|
|
/** Convert the given GNU import library name (.dll.a) to a name with a new
|
|
extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}). */
|
|
bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out,
|
|
const char* newExt = CM_NULLPTR) const;
|
|
|
|
bool IsExecutableWithExports() const;
|
|
|
|
/** Return whether or not the target has a DLL import library. */
|
|
bool HasImportLibrary() const;
|
|
|
|
/** Get a build-tree directory in which to place target support files. */
|
|
std::string GetSupportDirectory() const;
|
|
|
|
/** Return whether this target may be used to link another target. */
|
|
bool IsLinkable() const;
|
|
|
|
/** Return whether this target is a shared library Framework on
|
|
Apple. */
|
|
bool IsFrameworkOnApple() const;
|
|
|
|
/** Return whether this target is an executable Bundle on Apple. */
|
|
bool IsAppBundleOnApple() const;
|
|
|
|
/** Return whether this target is a XCTest on Apple. */
|
|
bool IsXCTestOnApple() const;
|
|
|
|
/** Return whether this target is a CFBundle (plugin) on Apple. */
|
|
bool IsCFBundleOnApple() const;
|
|
|
|
struct SourceFileFlags GetTargetSourceFileFlags(
|
|
const cmSourceFile* sf) const;
|
|
|
|
struct ResxData
|
|
{
|
|
mutable std::set<std::string> ExpectedResxHeaders;
|
|
mutable std::vector<cmSourceFile const*> ResxSources;
|
|
};
|
|
|
|
struct XamlData
|
|
{
|
|
std::set<std::string> ExpectedXamlHeaders;
|
|
std::set<std::string> ExpectedXamlSources;
|
|
std::vector<cmSourceFile const*> XamlSources;
|
|
};
|
|
|
|
void ReportPropertyOrigin(const std::string& p, const std::string& result,
|
|
const std::string& report,
|
|
const std::string& compatibilityType) const;
|
|
|
|
class TargetPropertyEntry;
|
|
|
|
bool HaveInstallTreeRPATH() const;
|
|
|
|
/** Whether this library has \@rpath and platform supports it. */
|
|
bool HasMacOSXRpathInstallNameDir(const std::string& config) const;
|
|
|
|
/** Whether this library defaults to \@rpath. */
|
|
bool MacOSXRpathInstallNameDirDefault() const;
|
|
|
|
/** Test for special case of a third-party shared library that has
|
|
no soname at all. */
|
|
bool IsImportedSharedLibWithoutSOName(const std::string& config) const;
|
|
|
|
const char* ImportedGetLocation(const std::string& config) const;
|
|
|
|
/** Get the target major and minor version numbers interpreted from
|
|
the VERSION property. Version 0 is returned if the property is
|
|
not set or cannot be parsed. */
|
|
void GetTargetVersion(int& major, int& minor) const;
|
|
|
|
/** Get the target major, minor, and patch version numbers
|
|
interpreted from the VERSION or SOVERSION property. Version 0
|
|
is returned if the property is not set or cannot be parsed. */
|
|
void GetTargetVersion(bool soversion, int& major, int& minor,
|
|
int& patch) const;
|
|
|
|
std::string GetFortranModuleDirectory() const;
|
|
|
|
private:
|
|
std::string CreateFortranModuleDirectory() const;
|
|
mutable bool FortranModuleDirectoryCreated;
|
|
mutable std::string FortranModuleDirectory;
|
|
|
|
friend class cmTargetTraceDependencies;
|
|
struct SourceEntry
|
|
{
|
|
std::vector<cmSourceFile*> Depends;
|
|
};
|
|
typedef std::map<cmSourceFile const*, SourceEntry> SourceEntriesType;
|
|
SourceEntriesType SourceDepends;
|
|
mutable std::map<cmSourceFile const*, std::string> Objects;
|
|
std::set<cmSourceFile const*> ExplicitObjectName;
|
|
mutable std::map<std::string, std::vector<std::string> > SystemIncludesCache;
|
|
|
|
mutable std::string ExportMacro;
|
|
|
|
void ConstructSourceFileFlags() const;
|
|
mutable bool SourceFileFlagsConstructed;
|
|
mutable std::map<cmSourceFile const*, SourceFileFlags> SourceFlagsMap;
|
|
|
|
mutable std::map<std::string, bool> DebugCompatiblePropertiesDone;
|
|
|
|
std::string GetFullNameInternal(const std::string& config,
|
|
bool implib) const;
|
|
void GetFullNameInternal(const std::string& config, bool implib,
|
|
std::string& outPrefix, std::string& outBase,
|
|
std::string& outSuffix) const;
|
|
|
|
typedef std::map<std::string, LinkClosure> LinkClosureMapType;
|
|
mutable LinkClosureMapType LinkClosureMap;
|
|
|
|
// Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type.
|
|
const char* GetOutputTargetType(bool implib) const;
|
|
|
|
void ComputeVersionedName(std::string& vName, std::string const& prefix,
|
|
std::string const& base, std::string const& suffix,
|
|
std::string const& name,
|
|
const char* version) const;
|
|
|
|
struct CompatibleInterfacesBase
|
|
{
|
|
std::set<std::string> PropsBool;
|
|
std::set<std::string> PropsString;
|
|
std::set<std::string> PropsNumberMax;
|
|
std::set<std::string> PropsNumberMin;
|
|
};
|
|
CompatibleInterfacesBase const& GetCompatibleInterfaces(
|
|
std::string const& config) const;
|
|
|
|
struct CompatibleInterfaces : public CompatibleInterfacesBase
|
|
{
|
|
CompatibleInterfaces()
|
|
: Done(false)
|
|
{
|
|
}
|
|
bool Done;
|
|
};
|
|
mutable std::map<std::string, CompatibleInterfaces> CompatibleInterfacesMap;
|
|
|
|
typedef std::map<std::string, cmComputeLinkInformation*>
|
|
cmTargetLinkInformationMap;
|
|
mutable cmTargetLinkInformationMap LinkInformation;
|
|
|
|
void CheckPropertyCompatibility(cmComputeLinkInformation* info,
|
|
const std::string& config) const;
|
|
|
|
cmGeneratorTarget(cmGeneratorTarget const&);
|
|
void operator=(cmGeneratorTarget const&);
|
|
|
|
struct LinkImplClosure : public std::vector<cmGeneratorTarget const*>
|
|
{
|
|
LinkImplClosure()
|
|
: Done(false)
|
|
{
|
|
}
|
|
bool Done;
|
|
};
|
|
mutable std::map<std::string, LinkImplClosure> LinkImplClosureMap;
|
|
|
|
typedef std::map<std::string, cmHeadToLinkInterfaceMap> LinkInterfaceMapType;
|
|
mutable LinkInterfaceMapType LinkInterfaceMap;
|
|
mutable LinkInterfaceMapType LinkInterfaceUsageRequirementsOnlyMap;
|
|
|
|
cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceMap(
|
|
std::string const& config) const;
|
|
cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceUsageRequirementsMap(
|
|
std::string const& config) const;
|
|
|
|
// Cache import information from properties for each configuration.
|
|
struct ImportInfo
|
|
{
|
|
ImportInfo()
|
|
: NoSOName(false)
|
|
, Multiplicity(0)
|
|
{
|
|
}
|
|
bool NoSOName;
|
|
unsigned int Multiplicity;
|
|
std::string Location;
|
|
std::string SOName;
|
|
std::string ImportLibrary;
|
|
std::string Languages;
|
|
std::string Libraries;
|
|
std::string LibrariesProp;
|
|
std::string SharedDeps;
|
|
};
|
|
|
|
typedef std::map<std::string, ImportInfo> ImportInfoMapType;
|
|
mutable ImportInfoMapType ImportInfoMap;
|
|
void ComputeImportInfo(std::string const& desired_config,
|
|
ImportInfo& info) const;
|
|
ImportInfo const* GetImportInfo(const std::string& config) const;
|
|
|
|
/** Strip off leading and trailing whitespace from an item named in
|
|
the link dependencies of this target. */
|
|
std::string CheckCMP0004(std::string const& item) const;
|
|
|
|
cmLinkInterface const* GetImportLinkInterface(
|
|
const std::string& config, const cmGeneratorTarget* head,
|
|
bool usage_requirements_only) const;
|
|
|
|
typedef std::map<std::string, std::vector<cmSourceFile*> >
|
|
SourceFilesMapType;
|
|
mutable SourceFilesMapType SourceFilesMap;
|
|
|
|
std::vector<TargetPropertyEntry*> IncludeDirectoriesEntries;
|
|
std::vector<TargetPropertyEntry*> CompileOptionsEntries;
|
|
std::vector<TargetPropertyEntry*> CompileFeaturesEntries;
|
|
std::vector<TargetPropertyEntry*> CompileDefinitionsEntries;
|
|
std::vector<TargetPropertyEntry*> SourceEntries;
|
|
mutable std::set<std::string> LinkImplicitNullProperties;
|
|
|
|
void ExpandLinkItems(std::string const& prop, std::string const& value,
|
|
std::string const& config,
|
|
const cmGeneratorTarget* headTarget,
|
|
bool usage_requirements_only,
|
|
std::vector<cmLinkItem>& items,
|
|
bool& hadHeadSensitiveCondition) const;
|
|
void LookupLinkItems(std::vector<std::string> const& names,
|
|
std::vector<cmLinkItem>& items) const;
|
|
|
|
void GetSourceFiles(std::vector<std::string>& files,
|
|
const std::string& config) const;
|
|
|
|
struct HeadToLinkImplementationMap
|
|
: public std::map<cmGeneratorTarget const*, cmOptionalLinkImplementation>
|
|
{
|
|
};
|
|
typedef std::map<std::string, HeadToLinkImplementationMap> LinkImplMapType;
|
|
mutable LinkImplMapType LinkImplMap;
|
|
|
|
cmLinkImplementationLibraries const* GetLinkImplementationLibrariesInternal(
|
|
const std::string& config, const cmGeneratorTarget* head) const;
|
|
bool ComputeOutputDir(const std::string& config, bool implib,
|
|
std::string& out) const;
|
|
|
|
typedef std::map<std::string, OutputInfo> OutputInfoMapType;
|
|
mutable OutputInfoMapType OutputInfoMap;
|
|
|
|
typedef std::pair<std::string, bool> OutputNameKey;
|
|
typedef std::map<OutputNameKey, std::string> OutputNameMapType;
|
|
mutable OutputNameMapType OutputNameMap;
|
|
mutable std::set<cmLinkItem> UtilityItems;
|
|
cmPolicies::PolicyMap PolicyMap;
|
|
mutable bool PolicyWarnedCMP0022;
|
|
mutable bool DebugIncludesDone;
|
|
mutable bool DebugCompileOptionsDone;
|
|
mutable bool DebugCompileFeaturesDone;
|
|
mutable bool DebugCompileDefinitionsDone;
|
|
mutable bool DebugSourcesDone;
|
|
mutable bool LinkImplementationLanguageIsContextDependent;
|
|
mutable bool UtilityItemsDone;
|
|
bool DLLPlatform;
|
|
|
|
bool ComputePDBOutputDir(const std::string& kind, const std::string& config,
|
|
std::string& out) const;
|
|
|
|
public:
|
|
const std::vector<const cmGeneratorTarget*>& GetLinkImplementationClosure(
|
|
const std::string& config) const;
|
|
|
|
mutable std::map<std::string, std::string> MaxLanguageStandards;
|
|
std::map<std::string, std::string> const& GetMaxLanguageStandards() const
|
|
{
|
|
return this->MaxLanguageStandards;
|
|
}
|
|
|
|
struct StrictTargetComparison
|
|
{
|
|
bool operator()(cmGeneratorTarget const* t1,
|
|
cmGeneratorTarget const* t2) const;
|
|
};
|
|
};
|
|
|
|
#endif
|