diff options
Diffstat (limited to 'Source/cmGlobalGenerator.h')
| -rw-r--r-- | Source/cmGlobalGenerator.h | 595 |
1 files changed, 386 insertions, 209 deletions
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index 80916ae59..871178be1 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -1,39 +1,43 @@ -/*============================================================================ - 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. -============================================================================*/ - +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ #ifndef cmGlobalGenerator_h #define cmGlobalGenerator_h -#include "cmStandardIncludes.h" - -#include "cmTarget.h" // For cmTargets -#include "cmTargetDepend.h" // For cmTargetDependSet -#include "cmSystemTools.h" // for cmSystemTools::OutputOption -#include "cmExportSetMap.h" // For cmExportSetMap -#include "cmGeneratorTarget.h" -#include "cmGeneratorExpression.h" +#include "cmConfigure.h" + +#include <iosfwd> +#include <map> +#include <set> +#include <string> +#include <utility> +#include <vector> + +#include "cmCustomCommandLines.h" +#include "cmExportSetMap.h" +#include "cmStateSnapshot.h" +#include "cmSystemTools.h" +#include "cmTarget.h" +#include "cmTargetDepend.h" +#include "cm_codecvt.hxx" +#include "cm_unordered_map.hxx" + +#if defined(CMAKE_BUILD_WITH_CMAKE) +#include "cmFileLockPool.h" +#endif -class cmake; +class cmExportBuildFileGenerator; +class cmExternalMakefileProjectGenerator; class cmGeneratorTarget; -class cmGeneratorExpressionEvaluationFile; -class cmMakefile; +class cmLinkLineComputer; class cmLocalGenerator; -class cmExternalMakefileProjectGenerator; -class cmTarget; -class cmInstallTargetGenerator; -class cmInstallFilesGenerator; +class cmMakefile; +class cmOutputConverter; +class cmSourceFile; +class cmStateDirectory; +class cmake; /** \class cmGlobalGenerator - * \brief Responable for overseeing the generation process for the entire tree + * \brief Responsible for overseeing the generation process for the entire tree * * Subclasses of this class generate makefiles for various * platforms. @@ -42,18 +46,36 @@ class cmGlobalGenerator { public: ///! Free any memory allocated with the GlobalGenerator - cmGlobalGenerator(); + cmGlobalGenerator(cmake* cm); virtual ~cmGlobalGenerator(); - ///! Create a local generator appropriate to this Global Generator - virtual cmLocalGenerator *CreateLocalGenerator(); + virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf); ///! Get the name for this generator - virtual const char *GetName() const { return "Generic"; }; + virtual std::string GetName() const { return "Generic"; } + + /** Check whether the given name matches the current generator. */ + virtual bool MatchesGeneratorName(const std::string& name) const + { + return this->GetName() == name; + } + + /** Get encoding used by generator for makefile files */ + virtual codecvt::Encoding GetMakefileEncoding() const + { + return codecvt::None; + } + + /** Tell the generator about the target system. */ + virtual bool SetSystemName(std::string const&, cmMakefile*) { return true; } + + /** Set the generator-specific platform name. Returns true if platform + is supported and false otherwise. */ + virtual bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf); /** Set the generator-specific toolset name. Returns true if toolset is supported and false otherwise. */ - virtual bool SetGeneratorToolset(std::string const& ts); + virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf); /** * Create LocalGenerators and process the CMakeLists files. This does not @@ -61,6 +83,20 @@ public: */ virtual void Configure(); + bool Compute(); + virtual void AddExtraIDETargets() {} + + enum TargetTypes + { + AllTargets, + ImportedOnly + }; + + void CreateImportedGenerationObjects( + cmMakefile* mf, std::vector<std::string> const& targets, + std::vector<cmGeneratorTarget const*>& exports); + void CreateGenerationObjects(TargetTypes targetTypes = AllTargets); + /** * Generate the all required files for building this project/tree. This * basically creates a series of LocalGenerators for each directory and @@ -68,41 +104,47 @@ public: */ virtual void Generate(); + virtual cmLinkLineComputer* CreateLinkLineComputer( + cmOutputConverter* outputConverter, + cmStateDirectory const& stateDir) const; + + cmLinkLineComputer* CreateMSVC60LinkLineComputer( + cmOutputConverter* outputConverter, + cmStateDirectory const& stateDir) const; + /** * Set/Get and Clear the enabled languages. */ - void SetLanguageEnabled(const char*, cmMakefile* mf); - bool GetLanguageEnabled(const char*) const; + void SetLanguageEnabled(const std::string&, cmMakefile* mf); + bool GetLanguageEnabled(const std::string&) const; void ClearEnabledLanguages(); - void GetEnabledLanguages(std::vector<std::string>& lang); + void GetEnabledLanguages(std::vector<std::string>& lang) const; /** - * Try to determine system infomation such as shared library + * Try to determine system information such as shared library * extension, pthreads, byte order etc. */ - virtual void EnableLanguage(std::vector<std::string>const& languages, - cmMakefile *, bool optional); + virtual void EnableLanguage(std::vector<std::string> const& languages, + cmMakefile*, bool optional); /** * Resolve the CMAKE_<lang>_COMPILER setting for the given language. * Intended to be called from EnableLanguage. */ - void ResolveLanguageCompiler(const std::string &lang, cmMakefile *mf, - bool optional); + void ResolveLanguageCompiler(const std::string& lang, cmMakefile* mf, + bool optional) const; /** - * Try to determine system infomation, get it from another generator + * Try to determine system information, get it from another generator */ - virtual void EnableLanguagesFromGenerator(cmGlobalGenerator *gen, - cmMakefile* mf); + void EnableLanguagesFromGenerator(cmGlobalGenerator* gen, cmMakefile* mf); /** * Try running cmake and building a file. This is used for dynamically * loaded commands, not as part of the usual build process. */ - virtual int TryCompile(const char *srcdir, const char *bindir, - const char *projectName, const char *targetName, - bool fast, std::string *output, cmMakefile* mf); - + int TryCompile(const std::string& srcdir, const std::string& bindir, + const std::string& projectName, const std::string& targetName, + bool fast, std::string& output, cmMakefile* mf); /** * Build a file given the following information. This is a more direct call @@ -110,59 +152,68 @@ public: * empty then all is assumed. clean indicates if a "make clean" should be * done first. */ - int Build(const char *srcdir, const char *bindir, - const char *projectName, const char *targetName, - std::string *output, - const char *makeProgram, const char *config, - bool clean, bool fast, - double timeout, - cmSystemTools::OutputOption outputflag=cmSystemTools::OUTPUT_NONE, - const char* extraOptions = 0, + int Build(const std::string& srcdir, const std::string& bindir, + const std::string& projectName, const std::string& targetName, + std::string& output, const std::string& makeProgram, + const std::string& config, bool clean, bool fast, bool verbose, + double timeout, cmSystemTools::OutputOption outputflag = + cmSystemTools::OUTPUT_NONE, std::vector<std::string> const& nativeOptions = - std::vector<std::string>()); - - virtual std::string GenerateBuildCommand( - const char* makeProgram, - const char *projectName, const char *projectDir, - const char* additionalOptions, - const char *targetName, const char* config, - bool ignoreErrors, bool fast); + std::vector<std::string>()); + virtual void GenerateBuildCommand( + std::vector<std::string>& makeCommand, const std::string& makeProgram, + const std::string& projectName, const std::string& projectDir, + const std::string& targetName, const std::string& config, bool fast, + bool verbose, + std::vector<std::string> const& makeOptions = std::vector<std::string>()); - ///! Set the CMake instance - void SetCMakeInstance(cmake *cm); + /** Generate a "cmake --build" call for a given target and config. */ + std::string GenerateCMakeBuildCommand(const std::string& target, + const std::string& config, + const std::string& native, + bool ignoreErrors); ///! Get the CMake instance - cmake *GetCMakeInstance() { return this->CMakeInstance; } - const cmake *GetCMakeInstance() const { return this->CMakeInstance; } + cmake* GetCMakeInstance() const { return this->CMakeInstance; } void SetConfiguredFilesPath(cmGlobalGenerator* gen); - const std::vector<cmLocalGenerator *>& GetLocalGenerators() const { - return this->LocalGenerators;} + const std::vector<cmMakefile*>& GetMakefiles() const + { + return this->Makefiles; + } + const std::vector<cmLocalGenerator*>& GetLocalGenerators() const + { + return this->LocalGenerators; + } - cmLocalGenerator* GetCurrentLocalGenerator() - {return this->CurrentLocalGenerator;} + cmMakefile* GetCurrentMakefile() const { return this->CurrentMakefile; } - void SetCurrentLocalGenerator(cmLocalGenerator* lg) - {this->CurrentLocalGenerator = lg;} + void SetCurrentMakefile(cmMakefile* mf) { this->CurrentMakefile = mf; } - void AddLocalGenerator(cmLocalGenerator *lg); + void AddMakefile(cmMakefile* mf); ///! Set an generator for an "external makefile based project" void SetExternalMakefileProjectGenerator( - cmExternalMakefileProjectGenerator *extraGenerator); + cmExternalMakefileProjectGenerator* extraGenerator); - const char* GetExtraGeneratorName() const; + std::string GetExtraGeneratorName() const; void AddInstallComponent(const char* component); - const std::set<cmStdString>* GetInstallComponents() const - { return &this->InstallComponents; } + const std::set<std::string>* GetInstallComponents() const + { + return &this->InstallComponents; + } + + cmExportSetMap& GetExportSets() { return this->ExportSets; } - cmExportSetMap& GetExportSets() {return this->ExportSets;} + const char* GetGlobalSetting(std::string const& name) const; + bool GlobalSettingIsOn(std::string const& name) const; + const char* GetSafeGlobalSetting(std::string const& name) const; /** Add a file to the manifest of generated targets for a configuration. */ - void AddToManifest(const char* config, std::string const& f); + void AddToManifest(std::string const& f); void EnableInstallTarget(); @@ -172,17 +223,21 @@ public: bool GetToolSupportsColor() const { return this->ToolSupportsColor; } ///! return the language for the given extension - const char* GetLanguageFromExtension(const char* ext); + std::string GetLanguageFromExtension(const char* ext) const; ///! is an extension to be ignored - bool IgnoreFile(const char* ext); - ///! What is the preference for linkers and this language (None or Prefered) - int GetLinkerPreference(const char* lang); + bool IgnoreFile(const char* ext) const; + ///! What is the preference for linkers and this language (None or Preferred) + int GetLinkerPreference(const std::string& lang) const; ///! What is the object file extension for a given source file? - const char* GetLanguageOutputExtension(cmSourceFile const&); + std::string GetLanguageOutputExtension(cmSourceFile const&) const; ///! What is the configurations directory variable called? virtual const char* GetCMakeCFGIntDir() const { return "."; } + ///! expand CFGIntDir for a configuration + virtual std::string ExpandCFGIntDir(const std::string& str, + const std::string& config) const; + /** Get whether the generator should use a script for link commands. */ bool GetUseLinkScript() const { return this->UseLinkScript; } @@ -193,71 +248,73 @@ public: /* * Determine what program to use for building the project. */ - void FindMakeProgram(cmMakefile*); + virtual bool FindMakeProgram(cmMakefile*); ///! Find a target by name by searching the local generators. - cmTarget* FindTarget(const char* project, const char* name, - bool excludeAliases = false); + cmTarget* FindTarget(const std::string& name, + bool excludeAliases = false) const; + + cmGeneratorTarget* FindGeneratorTarget(const std::string& name) const; - void AddAlias(const char *name, cmTarget *tgt); - bool IsAlias(const char *name); + void AddAlias(const std::string& name, const std::string& tgtName); + bool IsAlias(const std::string& name) const; /** Determine if a name resolves to a framework on disk or a built target that is a framework. */ - bool NameResolvesToFramework(const std::string& libname); + bool NameResolvesToFramework(const std::string& libname) const; - /** If check to see if the target is linked to by any other - target in the project */ - bool IsDependedOn(const char* project, cmTarget* target); + cmMakefile* FindMakefile(const std::string& start_dir) const; ///! Find a local generator by its startdirectory - cmLocalGenerator* FindLocalGenerator(const char* start_dir); + cmLocalGenerator* FindLocalGenerator(const std::string& start_dir) const; /** Append the subdirectory for the given configuration. If anything is appended the given prefix and suffix will be appended around it, which is useful for leading or trailing slashes. */ - virtual void AppendDirectoryForConfig(const char* prefix, - const char* config, - const char* suffix, + virtual void AppendDirectoryForConfig(const std::string& prefix, + const std::string& config, + const std::string& suffix, std::string& dir); - /** Get the manifest of all targets that will be built for each - configuration. This is valid during generation only. */ - cmTargetManifest const& GetTargetManifest() const - { return this->TargetManifest; } - - /** Get the content of a directory. Directory listings are loaded - from disk at most once and cached. During the generation step - the content will include the target files to be built even if + /** Get the content of a directory. Directory listings are cached + and re-loaded from disk only when modified. During the generation + step the content will include the target files to be built even if they do not yet exist. */ - std::set<cmStdString> const& GetDirectoryContent(std::string const& dir, + std::set<std::string> const& GetDirectoryContent(std::string const& dir, bool needDisk = true); - void AddTarget(cmTarget* t); + void IndexTarget(cmTarget* t); + void IndexGeneratorTarget(cmGeneratorTarget* gt); + + static bool IsReservedTarget(std::string const& name); + + virtual const char* GetAllTargetName() const { return "ALL_BUILD"; } + virtual const char* GetInstallTargetName() const { return "INSTALL"; } + virtual const char* GetInstallLocalTargetName() const { return CM_NULLPTR; } + virtual const char* GetInstallStripTargetName() const { return CM_NULLPTR; } + virtual const char* GetPreinstallTargetName() const { return CM_NULLPTR; } + virtual const char* GetTestTargetName() const { return "RUN_TESTS"; } + virtual const char* GetPackageTargetName() const { return "PACKAGE"; } + virtual const char* GetPackageSourceTargetName() const { return CM_NULLPTR; } + virtual const char* GetEditCacheTargetName() const { return CM_NULLPTR; } + virtual const char* GetRebuildCacheTargetName() const { return CM_NULLPTR; } + virtual const char* GetCleanTargetName() const { return CM_NULLPTR; } - virtual const char* GetAllTargetName() const { return "ALL_BUILD"; } - virtual const char* GetInstallTargetName() const { return "INSTALL"; } - virtual const char* GetInstallLocalTargetName() const { return 0; } - virtual const char* GetInstallStripTargetName() const { return 0; } - virtual const char* GetPreinstallTargetName() const { return 0; } - virtual const char* GetTestTargetName() const { return "RUN_TESTS"; } - virtual const char* GetPackageTargetName() const { return "PACKAGE"; } - virtual const char* GetPackageSourceTargetName() const { return 0; } - virtual const char* GetEditCacheTargetName() const { return 0; } - virtual const char* GetRebuildCacheTargetName() const { return 0; } - virtual const char* GetCleanTargetName() const { return 0; } + // Lookup edit_cache target command preferred by this generator. + virtual std::string GetEditCacheCommand() const { return ""; } // Class to track a set of dependencies. typedef cmTargetDependSet TargetDependSet; // what targets does the specified target depend on directly // via a target_link_libraries or add_dependencies - TargetDependSet const& GetTargetDirectDepends(cmTarget & target); + TargetDependSet const& GetTargetDirectDepends( + const cmGeneratorTarget* target); - /** Get per-target generator information. */ - cmGeneratorTarget* GetGeneratorTarget(cmTarget*) const; - - const std::map<cmStdString, std::vector<cmLocalGenerator*> >& GetProjectMap() - const {return this->ProjectMap;} + const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap() + const + { + return this->ProjectMap; + } // track files replaced during a Generate void FileReplacedDuringGenerate(const std::string& filename); @@ -267,122 +324,212 @@ public: std::string const& content); /** Return whether the given binary directory is unused. */ - bool BinaryDirectoryIsNew(const char* dir) - { + bool BinaryDirectoryIsNew(const std::string& dir) + { return this->BinaryDirectories.insert(dir).second; - } - /** Supported systems creates a GUID for the given name */ - virtual void CreateGUID(const char*) {} + } /** Return true if the generated build tree may contain multiple builds. i.e. "Can I build Debug and Release in the same tree?" */ - virtual bool IsMultiConfig() { return false; } + virtual bool IsMultiConfig() const { return false; } + + /** Return true if we know the exact location of object files. + If false, store the reason in the given string. + This is meaningful only after EnableLanguage has been called. */ + virtual bool HasKnownObjectFileLocation(std::string*) const { return true; } + + virtual bool UseFolderProperty() const; + + virtual bool IsIPOSupported() const { return false; } - std::string GetSharedLibFlagsForLanguage(std::string const& lang); + /** Return whether the generator should use EFFECTIVE_PLATFORM_NAME. This is + relevant for mixed macOS and iOS builds. */ + virtual bool UseEffectivePlatformName(cmMakefile*) const { return false; } + + /** Return whether the "Resources" folder prefix should be stripped from + MacFolder. */ + virtual bool ShouldStripResourcePath(cmMakefile*) const; + + std::string GetSharedLibFlagsForLanguage(std::string const& lang) const; /** Generate an <output>.rule file path for a given command output. */ virtual std::string GenerateRuleFile(std::string const& output) const; static std::string EscapeJSON(const std::string& s); - void AddEvaluationFile(const std::string &inputFile, - cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName, - cmMakefile *makefile, - cmsys::auto_ptr<cmCompiledGeneratorExpression> condition, - bool inputIsContent); - void ProcessEvaluationFiles(); + std::map<std::string, cmExportBuildFileGenerator*>& GetBuildExportSets() + { + return this->BuildExportSets; + } + void AddBuildExportSet(cmExportBuildFileGenerator*); + void AddBuildExportExportSet(cmExportBuildFileGenerator*); + bool IsExportedTargetsFile(const std::string& filename) const; + bool GenerateImportFile(const std::string& file); + cmExportBuildFileGenerator* GetExportedTargetsFile( + const std::string& filename) const; + void AddCMP0042WarnTarget(const std::string& target); + void AddCMP0068WarnTarget(const std::string& target); + + virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const; + + bool GenerateCPackPropertiesFile(); + + void CreateEvaluationSourceFiles(std::string const& config) const; + + void SetFilenameTargetDepends( + cmSourceFile* sf, std::set<cmGeneratorTarget const*> const& tgts); + const std::set<const cmGeneratorTarget*>& GetFilenameTargetDepends( + cmSourceFile* sf) const; + +#if defined(CMAKE_BUILD_WITH_CMAKE) + cmFileLockPool& GetFileLockPool() { return FileLockPool; } +#endif + + bool GetConfigureDoneCMP0026() const + { + return this->ConfigureDoneCMP0026AndCMP0024; + } + + std::string MakeSilentFlag; + protected: typedef std::vector<cmLocalGenerator*> GeneratorVector; // for a project collect all its targets by following depend // information, and also collect all the targets - virtual void GetTargetSets(TargetDependSet& projectTargets, - TargetDependSet& originalTargets, - cmLocalGenerator* root, GeneratorVector const&); - virtual bool IsRootOnlyTarget(cmTarget* target); - void AddTargetDepends(cmTarget* target, TargetDependSet& projectTargets); - void SetLanguageEnabledFlag(const char* l, cmMakefile* mf); - void SetLanguageEnabledMaps(const char* l, cmMakefile* mf); - void FillExtensionToLanguageMap(const char* l, cmMakefile* mf); + void GetTargetSets(TargetDependSet& projectTargets, + TargetDependSet& originalTargets, cmLocalGenerator* root, + GeneratorVector const&); + bool IsRootOnlyTarget(cmGeneratorTarget* target) const; + void AddTargetDepends(const cmGeneratorTarget* target, + TargetDependSet& projectTargets); + void SetLanguageEnabledFlag(const std::string& l, cmMakefile* mf); + void SetLanguageEnabledMaps(const std::string& l, cmMakefile* mf); + void FillExtensionToLanguageMap(const std::string& l, cmMakefile* mf); + virtual bool CheckLanguages(std::vector<std::string> const& languages, + cmMakefile* mf) const; + virtual void PrintCompilerAdvice(std::ostream& os, std::string const& lang, + const char* envVar) const; virtual bool ComputeTargetDepends(); - virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS(); + virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const; - bool CheckTargets(); - void CreateAutomocTargets(); + std::vector<const cmGeneratorTarget*> CreateQtAutoGeneratorsTargets(); + std::string SelectMakeProgram(const std::string& makeProgram, + const std::string& makeDefault = "") const; // Fill the ProjectMap, this must be called after LocalGenerators // has been populated. void FillProjectMap(); - void CheckLocalGenerators(); - bool IsExcluded(cmLocalGenerator* root, cmLocalGenerator* gen); - bool IsExcluded(cmLocalGenerator* root, cmTarget& target); - void FillLocalGeneratorToTargetMap(); - void CreateDefaultGlobalTargets(cmTargets* targets); - cmTarget CreateGlobalTarget(const char* name, const char* message, - const cmCustomCommandLines* commandLines, - std::vector<std::string> depends, const char* workingDir); + void CheckTargetProperties(); + bool IsExcluded(cmStateSnapshot const& root, + cmStateSnapshot const& snp) const; + bool IsExcluded(cmLocalGenerator* root, cmLocalGenerator* gen) const; + bool IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target) const; + virtual void InitializeProgressMarks() {} + + struct GlobalTargetInfo + { + std::string Name; + std::string Message; + cmCustomCommandLines CommandLines; + std::vector<std::string> Depends; + std::string WorkingDir; + bool UsesTerminal; + GlobalTargetInfo() + : UsesTerminal(false) + { + } + }; - bool NeedSymbolicMark; - bool UseLinkScript; - bool ForceUnixPaths; - bool ToolSupportsColor; - cmStdString FindMakeProgramFile; - cmStdString ConfiguredFilesPath; - cmake *CMakeInstance; - std::vector<cmLocalGenerator *> LocalGenerators; - cmLocalGenerator* CurrentLocalGenerator; + void CreateDefaultGlobalTargets(std::vector<GlobalTargetInfo>& targets); + + void AddGlobalTarget_Package(std::vector<GlobalTargetInfo>& targets); + void AddGlobalTarget_PackageSource(std::vector<GlobalTargetInfo>& targets); + void AddGlobalTarget_Test(std::vector<GlobalTargetInfo>& targets); + void AddGlobalTarget_EditCache(std::vector<GlobalTargetInfo>& targets); + void AddGlobalTarget_RebuildCache(std::vector<GlobalTargetInfo>& targets); + void AddGlobalTarget_Install(std::vector<GlobalTargetInfo>& targets); + cmTarget CreateGlobalTarget(GlobalTargetInfo const& gti, cmMakefile* mf); + + std::string FindMakeProgramFile; + std::string ConfiguredFilesPath; + cmake* CMakeInstance; + std::vector<cmMakefile*> Makefiles; + std::vector<cmLocalGenerator*> LocalGenerators; + cmMakefile* CurrentMakefile; // map from project name to vector of local generators in that project - std::map<cmStdString, std::vector<cmLocalGenerator*> > ProjectMap; - std::map<cmLocalGenerator*, std::set<cmTarget *> > LocalGeneratorToTargetMap; + std::map<std::string, std::vector<cmLocalGenerator*> > ProjectMap; // Set of named installation components requested by the project. - std::set<cmStdString> InstallComponents; - bool InstallTargetEnabled; + std::set<std::string> InstallComponents; // Sets of named target exports cmExportSetMap ExportSets; + std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets; + std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets; + + std::map<std::string, std::string> AliasTargets; - // Manifest of all targets that will be built for each configuration. - // This is computed just before local generators generate. - cmTargetManifest TargetManifest; + cmTarget* FindTargetImpl(std::string const& name) const; - // All targets in the entire project. - std::map<cmStdString,cmTarget *> TotalTargets; - std::map<cmStdString,cmTarget *> AliasTargets; - std::map<cmStdString,cmTarget *> ImportedTargets; - std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles; + cmGeneratorTarget* FindGeneratorTargetImpl(std::string const& name) const; + cmGeneratorTarget* FindImportedGeneratorTargetImpl( + std::string const& name) const; - virtual const char* GetPredefinedTargetsFolder(); - virtual bool UseFolderProperty(); - void EnableMinGWLanguage(cmMakefile *mf); + const char* GetPredefinedTargetsFolder(); private: + typedef CM_UNORDERED_MAP<std::string, cmTarget*> TargetMap; + typedef CM_UNORDERED_MAP<std::string, cmGeneratorTarget*> GeneratorTargetMap; + typedef CM_UNORDERED_MAP<std::string, cmMakefile*> MakefileMap; + // Map efficiently from target name to cmTarget instance. + // Do not use this structure for looping over all targets. + // It contains both normal and globally visible imported targets. + TargetMap TargetSearchIndex; + GeneratorTargetMap GeneratorTargetSearchIndex; + + // Map efficiently from source directory path to cmMakefile instance. + // Do not use this structure for looping over all directories. + // It may not contain all of them (see note in IndexMakefile method). + MakefileMap MakefileSearchIndex; + cmMakefile* TryCompileOuterMakefile; - float FirstTimeProgress; // If you add a new map here, make sure it is copied // in EnableLanguagesFromGenerator - std::map<cmStdString, bool> IgnoreExtensions; - std::map<cmStdString, bool> LanguageEnabled; - std::set<cmStdString> LanguagesReady; // Ready for try_compile - std::map<cmStdString, cmStdString> OutputExtensions; - std::map<cmStdString, cmStdString> LanguageToOutputExtension; - std::map<cmStdString, cmStdString> ExtensionToLanguage; - std::map<cmStdString, int> LanguageToLinkerPreference; - std::map<cmStdString, cmStdString> LanguageToOriginalSharedLibFlags; + std::map<std::string, bool> IgnoreExtensions; + std::set<std::string> LanguagesReady; // Ready for try_compile + std::set<std::string> LanguagesInProgress; + std::map<std::string, std::string> OutputExtensions; + std::map<std::string, std::string> LanguageToOutputExtension; + std::map<std::string, std::string> ExtensionToLanguage; + std::map<std::string, int> LanguageToLinkerPreference; + std::map<std::string, std::string> LanguageToOriginalSharedLibFlags; // Record hashes for rules and outputs. - struct RuleHash { char Data[32]; }; - std::map<cmStdString, RuleHash> RuleHashes; + struct RuleHash + { + char Data[32]; + }; + std::map<std::string, RuleHash> RuleHashes; void CheckRuleHashes(); void CheckRuleHashes(std::string const& pfile, std::string const& home); void WriteRuleHashes(std::string const& pfile); void WriteSummary(); - void WriteSummary(cmTarget* target); - void FinalizeTargetCompileDefinitions(); + void WriteSummary(cmGeneratorTarget* target); + void FinalizeTargetCompileInfo(); + + virtual void ForceLinkerLanguages(); + + void CreateLocalGenerators(); + + void CheckCompilerIdCompatibility(cmMakefile* mf, + std::string const& lang) const; + + void ComputeBuildFileGenerators(); cmExternalMakefileProjectGenerator* ExtraGenerator; @@ -390,28 +537,58 @@ private: std::vector<std::string> FilesReplacedDuringGenerate; // Store computed inter-target dependencies. - typedef std::map<cmTarget *, TargetDependSet> TargetDependMap; + typedef std::map<cmGeneratorTarget const*, TargetDependSet> TargetDependMap; TargetDependMap TargetDependencies; - // Per-target generator information. - cmGeneratorTargetsType GeneratorTargets; - void CreateGeneratorTargets(); - void ClearGeneratorTargets(); - virtual void ComputeTargetObjects(cmGeneratorTarget* gt) const; + friend class cmake; + void CreateGeneratorTargets( + TargetTypes targetTypes, cmMakefile* mf, cmLocalGenerator* lg, + std::map<cmTarget*, cmGeneratorTarget*> const& importedMap); + void CreateGeneratorTargets(TargetTypes targetTypes); + + void ClearGeneratorMembers(); + + void IndexMakefile(cmMakefile* mf); + + virtual const char* GetBuildIgnoreErrorsFlag() const { return CM_NULLPTR; } // Cache directory content and target files to be built. - struct DirectoryContent: public std::set<cmStdString> + struct DirectoryContent { - typedef std::set<cmStdString> derived; - bool LoadedFromDisk; - DirectoryContent(): LoadedFromDisk(false) {} - DirectoryContent(DirectoryContent const& dc): - derived(dc), LoadedFromDisk(dc.LoadedFromDisk) {} + long LastDiskTime; + std::set<std::string> All; + std::set<std::string> Generated; + DirectoryContent() + : LastDiskTime(-1) + { + } }; - std::map<cmStdString, DirectoryContent> DirectoryContentMap; + std::map<std::string, DirectoryContent> DirectoryContentMap; // Set of binary directories on disk. - std::set<cmStdString> BinaryDirectories; + std::set<std::string> BinaryDirectories; + + // track targets to issue CMP0042 warning for. + std::set<std::string> CMP0042WarnTargets; + // track targets to issue CMP0068 warning for. + std::set<std::string> CMP0068WarnTargets; + + mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*> > + FilenameTargetDepends; + +#if defined(CMAKE_BUILD_WITH_CMAKE) + // Pool of file locks + cmFileLockPool FileLockPool; +#endif + +protected: + float FirstTimeProgress; + bool NeedSymbolicMark; + bool UseLinkScript; + bool ForceUnixPaths; + bool ToolSupportsColor; + bool InstallTargetEnabled; + bool ConfigureDoneCMP0026AndCMP0024; }; #endif |