diff options
Diffstat (limited to 'Source/cmTarget.h')
| -rw-r--r-- | Source/cmTarget.h | 856 |
1 files changed, 856 insertions, 0 deletions
diff --git a/Source/cmTarget.h b/Source/cmTarget.h new file mode 100644 index 0000000..ddd9859 --- /dev/null +++ b/Source/cmTarget.h @@ -0,0 +1,856 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2009 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 cmTarget_h +#define cmTarget_h + +#include "cmCustomCommand.h" +#include "cmPropertyMap.h" +#include "cmPolicies.h" +#include "cmListFileCache.h" + +#include <cmsys/auto_ptr.hxx> +#if defined(CMAKE_BUILD_WITH_CMAKE) +#include <cmsys/hash_map.hxx> +#endif + +#define CM_FOR_EACH_TARGET_POLICY(F) \ + F(CMP0003) \ + F(CMP0004) \ + F(CMP0008) \ + F(CMP0020) \ + F(CMP0021) \ + F(CMP0022) \ + F(CMP0027) \ + F(CMP0038) \ + F(CMP0041) \ + F(CMP0042) \ + F(CMP0046) \ + F(CMP0052) + +class cmake; +class cmMakefile; +class cmSourceFile; +class cmGlobalGenerator; +class cmComputeLinkInformation; +class cmListFileBacktrace; +class cmTarget; +class cmGeneratorTarget; +class cmTargetTraceDependencies; + +// Basic information about each link item. +class cmLinkItem: public std::string +{ + typedef std::string std_string; +public: + cmLinkItem(): std_string(), Target(0) {} + cmLinkItem(const std_string& n, + cmTarget const* t): std_string(n), Target(t) {} + cmLinkItem(cmLinkItem const& r): std_string(r), Target(r.Target) {} + cmTarget const* Target; +}; +class cmLinkImplItem: public cmLinkItem +{ +public: + cmLinkImplItem(): cmLinkItem(), Backtrace(0), FromGenex(false) {} + cmLinkImplItem(std::string const& n, + cmTarget const* t, + cmListFileBacktrace const& bt, + bool fromGenex): + cmLinkItem(n, t), Backtrace(bt), FromGenex(fromGenex) {} + cmLinkImplItem(cmLinkImplItem const& r): + cmLinkItem(r), Backtrace(r.Backtrace), FromGenex(r.FromGenex) {} + cmListFileBacktrace Backtrace; + bool FromGenex; +}; + +struct cmTargetLinkInformationMap: + public std::map<std::string, cmComputeLinkInformation*> +{ + typedef std::map<std::string, cmComputeLinkInformation*> derived; + cmTargetLinkInformationMap() {} + cmTargetLinkInformationMap(cmTargetLinkInformationMap const& r); + ~cmTargetLinkInformationMap(); +}; + +class cmTargetInternals; +class cmTargetInternalPointer +{ +public: + cmTargetInternalPointer(); + cmTargetInternalPointer(cmTargetInternalPointer const& r); + ~cmTargetInternalPointer(); + cmTargetInternalPointer& operator=(cmTargetInternalPointer const& r); + cmTargetInternals* operator->() const { return this->Pointer; } + cmTargetInternals* Get() const { return this->Pointer; } +private: + cmTargetInternals* Pointer; +}; + +/** \class cmTarget + * \brief Represent a library or executable target loaded from a makefile. + * + * cmTarget represents a target loaded from + * a makefile. + */ +class cmTarget +{ +public: + cmTarget(); + enum TargetType { EXECUTABLE, STATIC_LIBRARY, + SHARED_LIBRARY, MODULE_LIBRARY, + OBJECT_LIBRARY, UTILITY, GLOBAL_TARGET, + INTERFACE_LIBRARY, + UNKNOWN_LIBRARY}; + static const char* GetTargetTypeName(TargetType targetType); + enum CustomCommandType { PRE_BUILD, PRE_LINK, POST_BUILD }; + + /** + * Return the type of target. + */ + TargetType GetType() const + { + return this->TargetTypeValue; + } + + /** + * Set the target type + */ + void SetType(TargetType f, const std::string& name); + + void MarkAsImported(); + + ///! Set/Get the name of the target + const std::string& GetName() const {return this->Name;} + std::string GetExportName() const; + + ///! Set the cmMakefile that owns this target + void SetMakefile(cmMakefile *mf); + cmMakefile *GetMakefile() const { return this->Makefile;} + +#define DECLARE_TARGET_POLICY(POLICY) \ + cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \ + { return this->PolicyStatus ## POLICY; } + + CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY) + +#undef DECLARE_TARGET_POLICY + + /** + * Get the list of the custom commands for this target + */ + std::vector<cmCustomCommand> const &GetPreBuildCommands() const + {return this->PreBuildCommands;} + std::vector<cmCustomCommand> const &GetPreLinkCommands() const + {return this->PreLinkCommands;} + std::vector<cmCustomCommand> const &GetPostBuildCommands() const + {return this->PostBuildCommands;} + void AddPreBuildCommand(cmCustomCommand const &cmd) + {this->PreBuildCommands.push_back(cmd);} + void AddPreLinkCommand(cmCustomCommand const &cmd) + {this->PreLinkCommands.push_back(cmd);} + void AddPostBuildCommand(cmCustomCommand const &cmd) + {this->PostBuildCommands.push_back(cmd);} + + /** + * Get the list of the source files used by this target + */ + void GetSourceFiles(std::vector<cmSourceFile*> &files, + const std::string& config) const; + bool GetConfigCommonSourceFiles(std::vector<cmSourceFile*>& files) const; + + /** + * Add sources to the target. + */ + void AddSources(std::vector<std::string> const& srcs); + void AddTracedSources(std::vector<std::string> const& srcs); + cmSourceFile* AddSourceCMP0049(const std::string& src); + cmSourceFile* AddSource(const std::string& src); + + enum LinkLibraryType {GENERAL, DEBUG, OPTIMIZED}; + + //* how we identify a library, by name and type + typedef std::pair<std::string, LinkLibraryType> LibraryID; + + typedef std::vector<LibraryID > LinkLibraryVectorType; + const LinkLibraryVectorType &GetOriginalLinkLibraries() const + {return this->OriginalLinkLibraries;} + + /** Compute the link type to use for the given configuration. */ + LinkLibraryType ComputeLinkType(const std::string& config) const; + + /** + * Clear the dependency information recorded for this target, if any. + */ + void ClearDependencyInformation(cmMakefile& mf, const std::string& target); + + // Check to see if a library is a framework and treat it different on Mac + bool NameResolvesToFramework(const std::string& libname) const; + void AddLinkLibrary(cmMakefile& mf, + const std::string& target, const std::string& lib, + LinkLibraryType llt); + enum TLLSignature { + KeywordTLLSignature, + PlainTLLSignature + }; + bool PushTLLCommandTrace(TLLSignature signature); + void GetTllSignatureTraces(std::ostringstream &s, TLLSignature sig) const; + + void MergeLinkLibraries( cmMakefile& mf, const std::string& selfname, + const LinkLibraryVectorType& libs ); + + const std::vector<std::string>& GetLinkDirectories() const; + + void AddLinkDirectory(const std::string& d); + + /** + * Set the path where this target should be installed. This is relative to + * INSTALL_PREFIX + */ + std::string GetInstallPath() const {return this->InstallPath;} + void SetInstallPath(const char *name) {this->InstallPath = name;} + + /** + * Set the path where this target (if it has a runtime part) should be + * installed. This is relative to INSTALL_PREFIX + */ + std::string GetRuntimeInstallPath() const {return this->RuntimeInstallPath;} + void SetRuntimeInstallPath(const char *name) { + this->RuntimeInstallPath = name; } + + /** + * Get/Set whether there is an install rule for this target. + */ + bool GetHaveInstallRule() const { return this->HaveInstallRule; } + void SetHaveInstallRule(bool h) { this->HaveInstallRule = h; } + + /** 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 + * commands. It is not a full path nor does it have an extension. + */ + void AddUtility(const std::string& u, cmMakefile *makefile = 0); + ///! Get the utilities used by this target + std::set<std::string>const& GetUtilities() const { return this->Utilities; } + std::set<cmLinkItem>const& GetUtilityItems() const; + cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; + + /** Finalize the target at the end of the Configure step. */ + void FinishConfigure(); + + ///! Set/Get a property of this target file + void SetProperty(const std::string& prop, const char *value); + void AppendProperty(const std::string& prop, const char* value, + bool asString=false); + const char *GetProperty(const std::string& prop) const; + const char *GetProperty(const std::string& prop, cmMakefile* context) const; + bool GetPropertyAsBool(const std::string& prop) const; + void CheckProperty(const std::string& prop, cmMakefile* context) const; + + const char* GetFeature(const std::string& feature, + const std::string& config) const; + bool GetFeatureAsBool(const std::string& feature, + const std::string& config) const; + + bool IsImported() const {return this->IsImportedTarget;} + + void GetObjectLibrariesCMP0026(std::vector<cmTarget*>& objlibs) const; + + /** The link interface specifies transitive library dependencies and + other information needed by targets that link to this target. */ + struct LinkInterfaceLibraries + { + // Libraries listed in the interface. + std::vector<cmLinkItem> Libraries; + }; + struct LinkInterface: public LinkInterfaceLibraries + { + // Languages whose runtime libraries must be linked. + std::vector<std::string> Languages; + + // Shared library dependencies needed for linking on some platforms. + std::vector<cmLinkItem> SharedDeps; + + // Number of repetitions of a strongly connected component of two + // or more static libraries. + int Multiplicity; + + // Libraries listed for other configurations. + // Needed only for OLD behavior of CMP0003. + std::vector<cmLinkItem> WrongConfigLibraries; + + bool ImplementationIsInterface; + + LinkInterface(): Multiplicity(0), ImplementationIsInterface(false) {} + }; + + /** Get the link interface for the given configuration. Returns 0 + if the target cannot be linked. */ + LinkInterface const* GetLinkInterface(const std::string& config, + cmTarget const* headTarget) const; + LinkInterfaceLibraries const* + GetLinkInterfaceLibraries(const std::string& config, + cmTarget const* headTarget, + bool usage_requirements_only) const; + + std::vector<cmTarget const*> const& + GetLinkImplementationClosure(const std::string& config) const; + + struct CompatibleInterfaces + { + std::set<std::string> PropsBool; + std::set<std::string> PropsString; + std::set<std::string> PropsNumberMax; + std::set<std::string> PropsNumberMin; + }; + CompatibleInterfaces const& + GetCompatibleInterfaces(std::string const& config) const; + + /** The link implementation specifies the direct library + dependencies needed by the object files of the target. */ + struct LinkImplementationLibraries + { + // Libraries linked directly in this configuration. + std::vector<cmLinkImplItem> Libraries; + + // Libraries linked directly in other configurations. + // Needed only for OLD behavior of CMP0003. + std::vector<cmLinkItem> WrongConfigLibraries; + }; + struct LinkImplementation: public LinkImplementationLibraries + { + // Languages whose runtime libraries must be linked. + std::vector<std::string> Languages; + }; + LinkImplementation const* + GetLinkImplementation(const std::string& config) const; + + LinkImplementationLibraries const* + GetLinkImplementationLibraries(const std::string& config) 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; + + cmTarget const* FindTargetToLink(std::string const& name) 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; + + /** 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 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; + + /** 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 the location of the target in the build tree for the given + configuration. */ + const char* GetLocation(const std::string& config) const; + + /** 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; + + /** 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; + + ///! Return the preferred linker language for this target + std::string GetLinkerLanguage(const std::string& config = "") 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; + void GetFullNameComponents(std::string& prefix, + std::string& base, std::string& suffix, + const std::string& config="", + bool implib = false) const; + + /** Get the name of the pdb file for the target. */ + std::string GetPDBName(const std::string& config) 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; + + /** Whether this library has soname enabled and platform supports it. */ + bool HasSOName(const std::string& config) const; + + /** Get the soname of the target. Allowed only for a shared library. */ + std::string GetSOName(const std::string& config) 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; + + /** 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; + + /** 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; + + /** 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; + + /** 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 = 0) const; + + /** + * Compute whether this target must be relinked before installing. + */ + bool NeedRelinkBeforeInstall(const std::string& config) const; + + bool HaveBuildTreeRPATH(const std::string& config) const; + bool HaveInstallTreeRPATH() const; + + /** Return true if builtin chrpath will work for this target */ + bool IsChrpathUsed(const std::string& config) 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; + + cmComputeLinkInformation* + GetLinkInformation(const std::string& config) const; + + // Get the properties + cmPropertyMap &GetProperties() const { return this->Properties; } + + bool GetMappedConfig(std::string const& desired_config, + const char** loc, + const char** imp, + std::string& suffix) const; + + // Define the properties + static void DefineProperties(cmake *cm); + + /** Get the macro to define when building sources in this target. + If no macro should be defined null is returned. */ + const char* GetExportMacro() const; + + void GetCompileDefinitions(std::vector<std::string> &result, + const std::string& config) 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; + + /** Return whether this target is an executable with symbol exports + enabled. */ + bool IsExecutableWithExports() const; + + /** Return whether this target may be used to link another target. */ + bool IsLinkable() const; + + /** Return whether or not the target is for a DLL platform. */ + bool IsDLLPlatform() const { return this->DLLPlatform; } + + /** Return whether or not the target has a DLL import library. */ + bool HasImportLibrary() const; + + /** Return whether this target is a shared library Framework on + Apple. */ + bool IsFrameworkOnApple() const; + + /** Return whether this target is a CFBundle (plugin) on Apple. */ + bool IsCFBundleOnApple() const; + + /** Return whether this target is an executable Bundle on Apple. */ + bool IsAppBundleOnApple() const; + + /** Return whether this target is an executable Bundle, a framework + or CFBundle on Apple. */ + bool IsBundleOnApple() const; + + /** Return the framework version string. Undefined if + IsFrameworkOnApple returns false. */ + std::string GetFrameworkVersion() const; + + /** Get a backtrace from the creation of the target. */ + cmListFileBacktrace const& GetBacktrace() const; + + /** Get a build-tree directory in which to place target support files. */ + std::string GetSupportDirectory() const; + + /** Return whether this target uses the default value for its output + directory. */ + bool UsesDefaultOutputDir(const std::string& config, bool implib) const; + + /** @return the mac content directory for this target. */ + std::string GetMacContentDirectory(const std::string& config, + bool implib) const; + + /** @return whether this target have a well defined output file name. */ + bool HaveWellDefinedOutputFiles() const; + + /** @return the Mac framework directory without the base. */ + std::string GetFrameworkDirectory(const std::string& config, + bool rootDir) const; + + /** @return the Mac CFBundle directory without the base */ + std::string GetCFBundleDirectory(const std::string& config, + bool contentOnly) const; + + /** @return the Mac App directory without the base */ + std::string GetAppBundleDirectory(const std::string& config, + bool contentOnly) const; + + std::vector<std::string> GetIncludeDirectories( + const std::string& config) const; + void InsertInclude(const cmValueWithOrigin &entry, + bool before = false); + void InsertCompileOption(const cmValueWithOrigin &entry, + bool before = false); + void InsertCompileDefinition(const cmValueWithOrigin &entry); + + void AppendBuildInterfaceIncludes(); + + void GetCompileOptions(std::vector<std::string> &result, + const std::string& config) const; + void GetAutoUicOptions(std::vector<std::string> &result, + const std::string& config) const; + void GetCompileFeatures(std::vector<std::string> &features, + const std::string& config) const; + + bool IsNullImpliedByLinkLibraries(const std::string &p) 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; + + std::string GetDebugGeneratorExpressions(const std::string &value, + cmTarget::LinkLibraryType llt) const; + + void AddSystemIncludeDirectories(const std::set<std::string> &incs); + void AddSystemIncludeDirectories(const std::vector<std::string> &incs); + std::set<std::string> const & GetSystemIncludeDirectories() const + { return this->SystemIncludeDirectories; } + + bool LinkLanguagePropagatesToDependents() const + { return this->TargetTypeValue == STATIC_LIBRARY; } + + void ReportPropertyOrigin(const std::string &p, + const std::string &result, + const std::string &report, + const std::string &compatibilityType) const; + + std::map<std::string, std::string> const& + GetMaxLanguageStandards() const + { + return this->MaxLanguageStandards; + } + +#if defined(_WIN32) && !defined(__CYGWIN__) + const LinkLibraryVectorType &GetLinkLibrariesForVS6() const { + return this->LinkLibrariesForVS6;} +#endif + +private: + bool HandleLocationPropertyPolicy(cmMakefile* context) const; + + // The set of include directories that are marked as system include + // directories. + std::set<std::string> SystemIncludeDirectories; + + std::vector<std::pair<TLLSignature, cmListFileBacktrace> > TLLCommands; + +#if defined(_WIN32) && !defined(__CYGWIN__) + /** + * A list of direct dependencies. Use in conjunction with DependencyMap. + */ + typedef std::vector< LibraryID > DependencyList; + + /** + * This map holds the dependency graph. map[x] returns a set of + * direct dependencies of x. Note that the direct depenencies are + * ordered. This is necessary to handle direct dependencies that + * themselves have no dependency information. + */ + typedef std::map< LibraryID, DependencyList > DependencyMap; + + /** + * Inserts \a dep at the end of the dependency list of \a lib. + */ + void InsertDependencyForVS6( DependencyMap& depMap, + const LibraryID& lib, + const LibraryID& dep); + + /* + * Deletes \a dep from the dependency list of \a lib. + */ + void DeleteDependencyForVS6( DependencyMap& depMap, + const LibraryID& lib, + const LibraryID& dep); + + /** + * Emits the library \a lib and all its dependencies into link_line. + * \a emitted keeps track of the libraries that have been emitted to + * avoid duplicates--it is more efficient than searching + * link_line. \a visited is used detect cycles. Note that \a + * link_line is in reverse order, in that the dependencies of a + * library are listed before the library itself. + */ + void EmitForVS6( const LibraryID lib, + const DependencyMap& dep_map, + std::set<LibraryID>& emitted, + std::set<LibraryID>& visited, + DependencyList& link_line); + + /** + * Finds the dependencies for \a lib and inserts them into \a + * dep_map. + */ + void GatherDependenciesForVS6( const cmMakefile& mf, + const LibraryID& lib, + DependencyMap& dep_map); + + void AnalyzeLibDependenciesForVS6( const cmMakefile& mf ); +#endif + + const char* GetSuffixVariableInternal(bool implib) const; + const char* GetPrefixVariableInternal(bool implib) const; + 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; + + // Use a makefile variable to set a default for the given property. + // If the variable is not defined use the given default instead. + void SetPropertyDefault(const std::string& property, + const char* default_value); + + // Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type. + const char* GetOutputTargetType(bool implib) const; + + // Get the target base name. + std::string GetOutputName(const std::string& config, bool implib) const; + + std::string GetFullNameImported(const std::string& config, + bool implib) const; + + std::string ImportedGetFullPath(const std::string& config, + bool implib) const; + std::string NormalGetFullPath(const std::string& config, bool implib, + bool realname) const; + + /** Get the real name of the target. Allowed only for non-imported + targets. When a library or executable file is versioned this is + the full versioned name. If the target is not versioned this is + the same as GetFullName. */ + std::string NormalGetRealName(const std::string& config) 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) const; + + void GetSourceFiles(std::vector<std::string> &files, + const std::string& config) const; +private: + std::string Name; + std::vector<cmCustomCommand> PreBuildCommands; + std::vector<cmCustomCommand> PreLinkCommands; + std::vector<cmCustomCommand> PostBuildCommands; + TargetType TargetTypeValue; + LinkLibraryVectorType PrevLinkedLibraries; +#if defined(_WIN32) && !defined(__CYGWIN__) + LinkLibraryVectorType LinkLibrariesForVS6; + bool LinkLibrariesForVS6Analyzed; +#endif + std::vector<std::string> LinkDirectories; + std::set<std::string> LinkDirectoriesEmmitted; + bool HaveInstallRule; + std::string InstallPath; + std::string RuntimeInstallPath; + mutable std::string ExportMacro; + std::set<std::string> Utilities; + std::map<std::string, cmListFileBacktrace> UtilityBacktraces; + bool RecordDependencies; + mutable cmPropertyMap Properties; + LinkLibraryVectorType OriginalLinkLibraries; + bool DLLPlatform; + bool IsAndroid; + bool IsApple; + bool IsImportedTarget; + mutable bool DebugIncludesDone; + mutable std::map<std::string, bool> DebugCompatiblePropertiesDone; + mutable bool DebugCompileOptionsDone; + mutable bool DebugCompileDefinitionsDone; + mutable bool DebugSourcesDone; + mutable bool DebugCompileFeaturesDone; + mutable std::set<std::string> LinkImplicitNullProperties; + mutable std::map<std::string, std::string> MaxLanguageStandards; + bool BuildInterfaceIncludesAppended; + + // Cache target output paths for each configuration. + struct OutputInfo; + OutputInfo const* GetOutputInfo(const std::string& config) const; + bool + ComputeOutputDir(const std::string& config, + bool implib, std::string& out) const; + bool ComputePDBOutputDir(const std::string& kind, const std::string& config, + std::string& out) const; + + // Cache import information from properties for each configuration. + struct ImportInfo; + ImportInfo const* GetImportInfo(const std::string& config) const; + void ComputeImportInfo(std::string const& desired_config, + ImportInfo& info) const; + + // Cache target compile paths for each configuration. + struct CompileInfo; + CompileInfo const* GetCompileInfo(const std::string& config) const; + + mutable cmTargetLinkInformationMap LinkInformation; + void CheckPropertyCompatibility(cmComputeLinkInformation *info, + const std::string& config) const; + + LinkInterface const* + GetImportLinkInterface(const std::string& config, cmTarget const* head, + bool usage_requirements_only) const; + + LinkImplementationLibraries const* + GetLinkImplementationLibrariesInternal(const std::string& config, + cmTarget const* head) const; + void ComputeLinkClosure(const std::string& config, LinkClosure& lc) const; + + void ExpandLinkItems(std::string const& prop, std::string const& value, + std::string const& config, cmTarget const* 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; + + std::string ProcessSourceItemCMP0049(const std::string& s); + + void ClearLinkMaps(); + + void MaybeInvalidatePropertyCache(const std::string& prop); + + void ProcessSourceExpression(std::string const& expr); + + // The cmMakefile instance that owns this target. This should + // always be set. + cmMakefile* Makefile; + + // Policy status recorded when target was created. +#define TARGET_POLICY_MEMBER(POLICY) \ + cmPolicies::PolicyStatus PolicyStatus ## POLICY; + + CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_MEMBER) + +#undef TARGET_POLICY_MEMBER + + // Internal representation details. + friend class cmTargetInternals; + friend class cmGeneratorTarget; + friend class cmTargetTraceDependencies; + cmTargetInternalPointer Internal; + + 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; + + mutable bool LinkImplementationLanguageIsContextDependent; +}; + +#ifdef CMAKE_BUILD_WITH_CMAKE +typedef cmsys::hash_map<std::string,cmTarget> cmTargets; +#else +typedef std::map<std::string,cmTarget> cmTargets; +#endif + +class cmTargetSet: public std::set<std::string> {}; +class cmTargetManifest: public std::map<std::string, cmTargetSet> {}; + +#endif |