diff options
Diffstat (limited to 'Source/cmGeneratorTarget.h')
| -rw-r--r-- | Source/cmGeneratorTarget.h | 727 |
1 files changed, 727 insertions, 0 deletions
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h new file mode 100644 index 0000000..f9987aa --- /dev/null +++ b/Source/cmGeneratorTarget.h @@ -0,0 +1,727 @@ +/*============================================================================ + 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 "cmLinkItem.h" + +class cmCustomCommand; +class cmGlobalGenerator; +class cmLocalGenerator; +class cmMakefile; +class cmSourceFile; +class cmTarget; +class cmComputeLinkInformation; + +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 |