/*============================================================================ 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 cmMakefile_h #define cmMakefile_h #include "cmCacheManager.h" #include "cmExecutionStatus.h" #include "cmListFileCache.h" #include "cmPolicies.h" #include "cmPropertyMap.h" #include "cmSystemTools.h" #include "cmTarget.h" #include "cmNewLineStyle.h" #include "cmGeneratorTarget.h" #include "cmake.h" #if defined(CMAKE_BUILD_WITH_CMAKE) #include "cmSourceGroup.h" #endif #include #include #if defined(CMAKE_BUILD_WITH_CMAKE) # include #endif class cmFunctionBlocker; class cmCommand; class cmInstallGenerator; class cmLocalGenerator; class cmMakeDepend; class cmSourceFile; class cmTest; class cmTestGenerator; class cmVariableWatch; class cmake; class cmMakefileCall; class cmCMakePolicyCommand; /** \class cmMakefile * \brief Process the input CMakeLists.txt file. * * Process and store into memory the input CMakeLists.txt file. * Each CMakeLists.txt file is parsed and the commands found there * are added into the build process. */ class cmMakefile { class Internals; cmsys::auto_ptr Internal; public: /** * Return the major and minor version of the cmake that * was used to write the currently loaded cache, note * this method will not work before the cache is loaded. */ unsigned int GetCacheMajorVersion() const; unsigned int GetCacheMinorVersion() const; /* Check for unused variables in this scope */ void CheckForUnusedVariables() const; /* Mark a variable as used */ void MarkVariableAsUsed(const std::string& var); /* return true if a variable has been initialized */ bool VariableInitialized(const std::string& ) const; /* return true if a variable has been used */ bool VariableUsed(const std::string& ) const; /** Return whether compatibility features needed for a version of the cache or lower should be enabled. */ bool NeedCacheCompatibility(int major, int minor) const; /** * Construct an empty makefile. */ cmMakefile(); cmMakefile(const cmMakefile& mf); /** * Destructor. */ ~cmMakefile(); /** * Read and parse a CMakeLists.txt file. */ bool ReadListFile(const char* listfile, const char* external= 0, std::string* fullPath= 0, bool noPolicyScope = true); /** * Add a function blocker to this makefile */ void AddFunctionBlocker(cmFunctionBlocker* fb); /** * Remove the function blocker whose scope ends with the given command. * This returns ownership of the function blocker object. */ cmsys::auto_ptr RemoveFunctionBlocker(cmFunctionBlocker* fb, const cmListFileFunction& lff); /** Push/pop a lexical (function blocker) barrier automatically. */ class LexicalPushPop { public: LexicalPushPop(cmMakefile* mf); ~LexicalPushPop(); void Quiet() { this->ReportError = false; } private: cmMakefile* Makefile; bool ReportError; }; friend class LexicalPushPop; /** * Try running cmake and building a file. This is used for dynalically * loaded commands, not as part of the usual build process. */ int TryCompile(const char *srcdir, const char *bindir, const std::string& projectName, const std::string& targetName, bool fast, const std::vector *cmakeArgs, std::string *output); bool GetIsSourceFileTryCompile() const; /** * Specify the makefile generator. This is platform/compiler * dependent, although the interface is through a generic * superclass. */ void SetLocalGenerator(cmLocalGenerator*); ///! Get the current makefile generator. cmLocalGenerator* GetLocalGenerator() const { return this->LocalGenerator;} /** * Help enforce global target name uniqueness. */ bool EnforceUniqueName(std::string const& name, std::string& msg, bool isCustom = false) const; /** * Perform FinalPass, Library dependency analysis etc before output of the * makefile. */ void ConfigureFinalPass(); /** * run the final pass on all commands. */ void FinalPass(); /** * Print the object state to std::cout. */ void Print() const; /** Add a custom command to the build. */ void AddCustomCommandToTarget(const std::string& target, const std::vector& depends, const cmCustomCommandLines& commandLines, cmTarget::CustomCommandType type, const char* comment, const char* workingDir, bool escapeOldStyle = true) const; cmSourceFile* AddCustomCommandToOutput( const std::vector& outputs, const std::vector& depends, const char* main_dependency, const cmCustomCommandLines& commandLines, const char* comment, const char* workingDir, bool replace = false, bool escapeOldStyle = true); cmSourceFile* AddCustomCommandToOutput( const std::string& output, const std::vector& depends, const char* main_dependency, const cmCustomCommandLines& commandLines, const char* comment, const char* workingDir, bool replace = false, bool escapeOldStyle = true); void AddCustomCommandOldStyle(const std::string& target, const std::vector& outputs, const std::vector& depends, const char* source, const cmCustomCommandLines& commandLines, const char* comment); /** * Add a define flag to the build. */ void AddDefineFlag(const char* definition); void RemoveDefineFlag(const char* definition); void AddCompileOption(const char* option); /** Create a new imported target with the name and type given. */ cmTarget* AddImportedTarget(const std::string& name, cmTarget::TargetType type, bool global); cmTarget* AddNewTarget(cmTarget::TargetType type, const std::string& name); /** * Add an executable to the build. */ cmTarget* AddExecutable(const char *exename, const std::vector &srcs, bool excludeFromAll = false); /** * Add a utility to the build. A utiltity target is a command that * is run every time the target is built. */ void AddUtilityCommand(const std::string& utilityName, bool excludeFromAll, const std::vector& depends, const char* workingDirectory, const char* command, const char* arg1=0, const char* arg2=0, const char* arg3=0, const char* arg4=0); cmTarget* AddUtilityCommand(const std::string& utilityName, bool excludeFromAll, const char* workingDirectory, const std::vector& depends, const cmCustomCommandLines& commandLines, bool escapeOldStyle = true, const char* comment = 0); /** * Add a link library to the build. */ void AddLinkLibrary(const std::string&); void AddLinkLibrary(const std::string&, cmTarget::LinkLibraryType type); void AddLinkLibraryForTarget(const std::string& tgt, const std::string&, cmTarget::LinkLibraryType type); void AddLinkDirectoryForTarget(const std::string& tgt, const std::string& d); /** * Add a link directory to the build. */ void AddLinkDirectory(const std::string&); const std::vector& GetLinkDirectories() const { return this->LinkDirectories; } void SetLinkDirectories(const std::vector& vec) { this->LinkDirectories = vec; } /** * Add a subdirectory to the build. */ void AddSubDirectory(const std::string&, bool excludeFromAll=false, bool preorder = false); void AddSubDirectory(const std::string& fullSrcDir, const std::string& fullBinDir, bool excludeFromAll, bool preorder, bool immediate); /** * Configure a subdirectory */ void ConfigureSubDirectory(cmLocalGenerator *); /** * Add an include directory to the build. */ void AddIncludeDirectories(const std::vector &incs, bool before = false); /** * Add a variable definition to the build. This variable * can be used in CMake to refer to lists, directories, etc. */ void AddDefinition(const std::string& name, const char* value); ///! Add a definition to this makefile and the global cmake cache. void AddCacheDefinition(const std::string& name, const char* value, const char* doc, cmCacheManager::CacheEntryType type, bool force = false); /** * Add bool variable definition to the build. */ void AddDefinition(const std::string& name, bool); /** * Remove a variable definition from the build. This is not valid * for cache entries, and will only affect the current makefile. */ void RemoveDefinition(const std::string& name); ///! Remove a definition from the cache. void RemoveCacheDefinition(const std::string& name); /** * Specify the name of the project for this build. */ void SetProjectName(const char*); /** * Get the name of the project for this build. */ const char* GetProjectName() const { return this->ProjectName.c_str(); } /** Get the configurations to be generated. */ std::string GetConfigurations(std::vector& configs, bool single = true) const; /** * Set the name of the library. */ cmTarget* AddLibrary(const std::string& libname, cmTarget::TargetType type, const std::vector &srcs, bool excludeFromAll = false); void AddAlias(const std::string& libname, cmTarget *tgt); #if defined(CMAKE_BUILD_WITH_CMAKE) /** * Add a root source group for consideration when adding a new source. */ void AddSourceGroup(const std::string& name, const char* regex=0); /** * Add a source group for consideration when adding a new source. * name is tokenized. */ void AddSourceGroup(const std::vector& name, const char* regex=0); #endif //@{ /** * Set, Push, Pop policy values for CMake. */ bool SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status); bool SetPolicy(const char *id, cmPolicies::PolicyStatus status); cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const; bool SetPolicyVersion(const char *version); void RecordPolicies(cmPolicies::PolicyMap& pm); //@} /** Helper class to push and pop policies automatically. */ class PolicyPushPop { public: PolicyPushPop(cmMakefile* m, bool weak = false, cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap()); ~PolicyPushPop(); void Quiet() { this->ReportError = false; } private: cmMakefile* Makefile; bool ReportError; }; friend class PolicyPushPop; /** * Get the Policies Instance */ cmPolicies *GetPolicies() const; /** * Add an auxiliary directory to the build. */ void AddExtraDirectory(const char* dir); /** * Add an auxiliary directory to the build. */ void MakeStartDirectoriesCurrent() { this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", this->cmStartDirectory.c_str()); this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", this->StartOutputDirectory.c_str()); } //@{ /** * Set/Get the home directory (or output directory) in the project. The * home directory is the top directory of the project. It is where * CMakeSetup or configure was run. Remember that CMake processes * CMakeLists files by recursing up the tree starting at the StartDirectory * and going up until it reaches the HomeDirectory. */ void SetHomeDirectory(const std::string& dir); const char* GetHomeDirectory() const { return this->cmHomeDirectory.c_str(); } void SetHomeOutputDirectory(const std::string& lib); const char* GetHomeOutputDirectory() const { return this->HomeOutputDirectory.c_str(); } //@} /** * Set CMAKE_SCRIPT_MODE_FILE variable when running a -P script. */ void SetScriptModeFile(const char* scriptfile); /** * Set CMAKE_ARGC, CMAKE_ARGV0 ... variables. */ void SetArgcArgv(const std::vector& args); //@{ /** * Set/Get the start directory (or output directory). The start directory * is the directory of the CMakeLists.txt file that started the current * round of processing. Remember that CMake processes CMakeLists files by * recursing up the tree starting at the StartDirectory and going up until * it reaches the HomeDirectory. */ void SetStartDirectory(const std::string& dir) { this->cmStartDirectory = dir; cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory); this->cmStartDirectory = cmSystemTools::CollapseFullPath(this->cmStartDirectory.c_str()); this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", this->cmStartDirectory.c_str()); } const char* GetStartDirectory() const { return this->cmStartDirectory.c_str(); } void SetStartOutputDirectory(const std::string& lib) { this->StartOutputDirectory = lib; cmSystemTools::ConvertToUnixSlashes(this->StartOutputDirectory); this->StartOutputDirectory = cmSystemTools::CollapseFullPath(this->StartOutputDirectory.c_str()); cmSystemTools::MakeDirectory(this->StartOutputDirectory.c_str()); this->AddDefinition("CMAKE_CURRENT_BINARY_DIR", this->StartOutputDirectory.c_str()); } const char* GetStartOutputDirectory() const { return this->StartOutputDirectory.c_str(); } //@} const char* GetCurrentDirectory() const { return this->cmStartDirectory.c_str(); } const char* GetCurrentOutputDirectory() const { return this->StartOutputDirectory.c_str(); } /* Get the current CMakeLists.txt file that is being processed. This * is just used in order to be able to 'branch' from one file to a second * transparently */ const char* GetCurrentListFile() const { return this->cmCurrentListFile.c_str(); } //@} /** * Set a regular expression that include files must match * in order to be considered as part of the depend information. */ void SetIncludeRegularExpression(const char* regex) { this->IncludeFileRegularExpression = regex; } const char* GetIncludeRegularExpression() const { return this->IncludeFileRegularExpression.c_str(); } /** * Set a regular expression that include files that are not found * must match in order to be considered a problem. */ void SetComplainRegularExpression(const std::string& regex) { this->ComplainFileRegularExpression = regex; } const char* GetComplainRegularExpression() const { return this->ComplainFileRegularExpression.c_str(); } /** * Get the list of targets */ cmTargets &GetTargets() { return this->Targets; } /** * Get the list of targets, const version */ const cmTargets &GetTargets() const { return this->Targets; } const std::vector &GetOwnedImportedTargets() const { return this->ImportedTargetsOwned; } const cmGeneratorTargetsType &GetGeneratorTargets() const { return this->GeneratorTargets; } void SetGeneratorTargets(const cmGeneratorTargetsType &targets) { this->GeneratorTargets = targets; } cmTarget* FindTarget(const std::string& name, bool excludeAliases = false) const; /** Find a target to use in place of the given name. The target returned may be imported or built within the project. */ cmTarget* FindTargetToUse(const std::string& name, bool excludeAliases = false) const; bool IsAlias(const std::string& name) const; cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const; /** * Mark include directories as system directories. */ void AddSystemIncludeDirectories(const std::set &incs); /** Expand out any arguements in the vector that have ; separated * strings into multiple arguements. A new vector is created * containing the expanded versions of all arguments in argsIn. * This method differes from the one in cmSystemTools in that if * the CmakeLists file is version 1.2 or earlier it will check for * source lists being used without ${} around them */ void ExpandSourceListArguments(std::vector const& argsIn, std::vector& argsOut, unsigned int startArgumentIndex) const; /** Get a cmSourceFile pointer for a given source name, if the name is * not found, then a null pointer is returned. */ cmSourceFile* GetSource(const std::string& sourceName) const; /** Get a cmSourceFile pointer for a given source name, if the name is * not found, then create the source file and return it. generated * indicates if it is a generated file, this is used in determining * how to create the source file instance e.g. name */ cmSourceFile* GetOrCreateSource(const std::string& sourceName, bool generated = false); /** * Obtain a list of auxiliary source directories. */ const std::vector& GetAuxSourceDirectories() const {return this->AuxSourceDirectories;} //@{ /** * Return a list of extensions associated with source and header * files */ const std::vector& GetSourceExtensions() const {return this->SourceFileExtensions;} const std::vector& GetHeaderExtensions() const {return this->HeaderFileExtensions;} //@} /** * Given a variable name, return its value (as a string). * If the variable is not found in this makefile instance, the * cache is then queried. */ const char* GetDefinition(const std::string&) const; const char* GetSafeDefinition(const std::string&) const; const char* GetRequiredDefinition(const std::string& name) const; bool IsDefinitionSet(const std::string&) const; /** * Get the list of all variables in the current space. If argument * cacheonly is specified and is greater than 0, then only cache * variables will be listed. */ std::vector GetDefinitions(int cacheonly=0) const; /** Test a boolean cache entry to see if it is true or false, * returns false if no entry defined. */ bool IsOn(const std::string& name) const; bool IsSet(const std::string& name) const; /** Return whether the target platform is 64-bit. */ bool PlatformIs64Bit() const; /** Retrieve soname flag for the specified language if supported */ const char* GetSONameFlag(const std::string& language) const; /** * Get a list of preprocessor define flags. */ const char* GetDefineFlags() const {return this->DefineFlags.c_str();} /** * Make sure CMake can write this file */ bool CanIWriteThisFile(const char* fileName) const; #if defined(CMAKE_BUILD_WITH_CMAKE) /** * Get the vector source groups. */ const std::vector& GetSourceGroups() const { return this->SourceGroups; } /** * Get the source group */ cmSourceGroup* GetSourceGroup(const std::vector&name) const; #endif /** * Get the vector of list files on which this makefile depends */ const std::vector& GetListFiles() const { return this->ListFiles; } ///! When the file changes cmake will be re-run from the build system. void AddCMakeDependFile(const std::string& file) { this->ListFiles.push_back(file);} void AddCMakeDependFilesFromUser(); std::string GetListFileStack() const; /** * Get the current context backtrace. */ bool GetBacktrace(cmListFileBacktrace& backtrace) const; /** * Get the vector of files created by this makefile */ const std::vector& GetOutputFiles() const { return this->OutputFiles; } void AddCMakeOutputFile(const std::string& file) { this->OutputFiles.push_back(file);} /** * Expand all defined variables in the string. * Defined variables come from the this->Definitions map. * They are expanded with ${var} where var is the * entry in the this->Definitions map. Also \@var\@ is * expanded to match autoconf style expansions. */ const char *ExpandVariablesInString(std::string& source) const; const char *ExpandVariablesInString(std::string& source, bool escapeQuotes, bool noEscapes, bool atOnly = false, const char* filename = 0, long line = -1, bool removeEmpty = false, bool replaceAt = true) const; /** * Remove any remaining variables in the string. Anything with ${var} or * \@var\@ will be removed. */ void RemoveVariablesInString(std::string& source, bool atOnly = false) const; /** * Expand variables in the makefiles ivars such as link directories etc */ void ExpandVariablesCMP0019(); /** * Replace variables and #cmakedefine lines in the given string. * See cmConfigureFileCommand for details. */ void ConfigureString(const std::string& input, std::string& output, bool atOnly, bool escapeQuotes) const; /** * Copy file but change lines acording to ConfigureString */ int ConfigureFile(const char* infile, const char* outfile, bool copyonly, bool atOnly, bool escapeQuotes, const cmNewLineStyle& = cmNewLineStyle()); #if defined(CMAKE_BUILD_WITH_CMAKE) /** * find what source group this source is in */ cmSourceGroup* FindSourceGroup(const char* source, std::vector &groups) const; #endif /** * Print a command's invocation */ void PrintCommandTrace(const cmListFileFunction& lff) const; /** * Execute a single CMake command. Returns true if the command * succeeded or false if it failed. */ bool ExecuteCommand(const cmListFileFunction& lff, cmExecutionStatus &status); /** Check if a command exists. */ bool CommandExists(const char* name) const; /** * Add a command to this cmake instance */ void AddCommand(cmCommand* ); ///! Enable support for named language, if nil then all languages are ///enabled. void EnableLanguage(std::vectorconst& languages, bool optional); /** * Set/Get the name of the parent directories CMakeLists file * given a current CMakeLists file name */ cmCacheManager *GetCacheManager() const; /** * Get the variable watch. This is used to determine when certain variables * are accessed. */ #ifdef CMAKE_BUILD_WITH_CMAKE cmVariableWatch* GetVariableWatch() const; #endif ///! Display progress or status message. void DisplayStatus(const char*, float) const; /** * Expand the given list file arguments into the full set after * variable replacement and list expansion. */ bool ExpandArguments(std::vector const& inArgs, std::vector& outArgs) const; /** * Get the instance */ cmake *GetCMakeInstance() const; /** * Get all the source files this makefile knows about */ const std::vector &GetSourceFiles() const {return this->SourceFiles;} std::vector &GetSourceFiles() {return this->SourceFiles;} /** * Is there a source file that has the provided source file as an output? * if so then return it */ cmSourceFile *GetSourceFileWithOutput(const std::string& outName) const; /** * Add a macro to the list of macros. The arguments should be name of the * macro and a documentation signature of it */ void AddMacro(const char* name, const char* signature); ///! Add a new cmTest to the list of tests for this makefile. cmTest* CreateTest(const std::string& testName); /** Get a cmTest pointer for a given test name, if the name is * not found, then a null pointer is returned. */ cmTest* GetTest(const std::string& testName) const; /** * Get a list of macros as a ; separated string */ void GetListOfMacros(std::string& macros) const; /** * Return a location of a file in cmake or custom modules directory */ std::string GetModulesFile(const char* name) const; ///! Set/Get a property of this directory 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, cmProperty::ScopeType scope) const; bool GetPropertyAsBool(const std::string& prop) const; const char* GetFeature(const std::string& feature, const std::string& config); // Get the properties cmPropertyMap &GetProperties() { return this->Properties; }; ///! Initialize a makefile from its parent void InitializeFromParent(); ///! Set/Get the preorder flag void SetPreOrder(bool p) { this->PreOrder = p; } bool GetPreOrder() const { return this->PreOrder; } void AddInstallGenerator(cmInstallGenerator* g) { if(g) this->InstallGenerators.push_back(g); } std::vector& GetInstallGenerators() { return this->InstallGenerators; } void AddTestGenerator(cmTestGenerator* g) { if(g) this->TestGenerators.push_back(g); } const std::vector& GetTestGenerators() const { return this->TestGenerators; } // Define the properties static void DefineProperties(cmake *cm); // push and pop variable scopes void PushScope(); void PopScope(); void RaiseScope(const std::string& var, const char *value); /** Helper class to push and pop scopes automatically. */ class ScopePushPop { public: ScopePushPop(cmMakefile* m): Makefile(m) { this->Makefile->PushScope(); } ~ScopePushPop() { this->Makefile->PopScope(); } private: cmMakefile* Makefile; }; void IssueMessage(cmake::MessageType t, std::string const& text) const; /** Set whether or not to report a CMP0000 violation. */ void SetCheckCMP0000(bool b) { this->CheckCMP0000 = b; } const std::vector& GetIncludeDirectoriesEntries() const { return this->IncludeDirectoriesEntries; } const std::vector& GetCompileOptionsEntries() const { return this->CompileOptionsEntries; } const std::vector& GetCompileDefinitionsEntries() const { return this->CompileDefinitionsEntries; } bool IsGeneratingBuildSystem() const { return this->GeneratingBuildSystem; } void SetGeneratingBuildSystem(){ this->GeneratingBuildSystem = true; } void AddQtUiFileWithOptions(cmSourceFile *sf); std::vector GetQtUiFilesWithOptions() const; std::set const & GetSystemIncludeDirectories() const { return this->SystemIncludeDirectories; } protected: // add link libraries and directories to the target void AddGlobalLinkInformation(const std::string& name, cmTarget& target); // Check for a an unused variable void CheckForUnused(const char* reason, const std::string& name) const; std::string Prefix; std::vector AuxSourceDirectories; // std::string cmStartDirectory; std::string StartOutputDirectory; std::string cmHomeDirectory; std::string HomeOutputDirectory; std::string cmCurrentListFile; std::string ProjectName; // project name // libraries, classes, and executables mutable cmTargets Targets; std::map AliasTargets; cmGeneratorTargetsType GeneratorTargets; std::vector SourceFiles; // Tests std::map Tests; // The link-library paths. Order matters, use std::vector (not std::set). std::vector LinkDirectories; // The set of include directories that are marked as system include // directories. std::set SystemIncludeDirectories; std::vector ListFiles; // list of command files loaded std::vector OutputFiles; // list of command files loaded cmTarget::LinkLibraryVectorType LinkLibraries; std::vector InstallGenerators; std::vector TestGenerators; std::string IncludeFileRegularExpression; std::string ComplainFileRegularExpression; std::vector SourceFileExtensions; std::vector HeaderFileExtensions; std::string DefineFlags; std::vector IncludeDirectoriesEntries; std::vector CompileOptionsEntries; std::vector CompileDefinitionsEntries; // Track the value of the computed DEFINITIONS property. void AddDefineFlag(const char*, std::string&); void RemoveDefineFlag(const char*, std::string::size_type, std::string&); std::string DefineFlagsOrig; #if defined(CMAKE_BUILD_WITH_CMAKE) std::vector SourceGroups; #endif std::vector FinalPassCommands; cmLocalGenerator* LocalGenerator; bool IsFunctionBlocked(const cmListFileFunction& lff, cmExecutionStatus &status); private: void Initialize(); bool ParseDefineFlag(std::string const& definition, bool remove); bool EnforceUniqueDir(const std::string& srcPath, const std::string& binPath) const; friend class cmMakeDepend; // make depend needs direct access // to the Sources array void PrintStringVector(const char* s, const std::vector >& v) const; void PrintStringVector(const char* s, const std::vector& v) const; void AddDefaultDefinitions(); typedef std::vector FunctionBlockersType; FunctionBlockersType FunctionBlockers; std::vector FunctionBlockerBarriers; void PushFunctionBlockerBarrier(); void PopFunctionBlockerBarrier(bool reportError = true); typedef std::map StringStringMap; StringStringMap MacrosMap; std::map SubDirectoryOrder; mutable cmsys::RegularExpression cmDefineRegex; mutable cmsys::RegularExpression cmDefine01Regex; mutable cmsys::RegularExpression cmAtVarRegex; cmPropertyMap Properties; // should this makefile be processed before or after processing the parent bool PreOrder; // Unused variable flags bool WarnUnused; bool CheckSystemVars; // stack of list files being read std::deque ListFileStack; // stack of commands being invoked. struct CallStackEntry { cmListFileContext const* Context; cmExecutionStatus* Status; }; typedef std::deque CallStackType; CallStackType CallStack; friend class cmMakefileCall; std::vector ImportedTargetsOwned; std::map ImportedTargets; // Internal policy stack management. void PushPolicy(bool weak = false, cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap()); void PopPolicy(); void PushPolicyBarrier(); void PopPolicyBarrier(bool reportError = true); friend class cmCMakePolicyCommand; class IncludeScope; friend class IncludeScope; // stack of policy settings struct PolicyStackEntry: public cmPolicies::PolicyMap { typedef cmPolicies::PolicyMap derived; PolicyStackEntry(bool w = false): derived(), Weak(w) {} PolicyStackEntry(derived const& d, bool w = false): derived(d), Weak(w) {} PolicyStackEntry(PolicyStackEntry const& r): derived(r), Weak(r.Weak) {} bool Weak; }; typedef std::vector PolicyStackType; PolicyStackType PolicyStack; std::vector PolicyBarriers; cmPolicies::PolicyStatus GetPolicyStatusInternal(cmPolicies::PolicyID id) const; bool CheckCMP0000; // Enforce rules about CMakeLists.txt files. void EnforceDirectoryLevelRules() const; bool GeneratingBuildSystem; /** * Old version of GetSourceFileWithOutput(const std::string&) kept for * backward-compatibility. It implements a linear search and support * relative file paths. It is used as a fall back by * GetSourceFileWithOutput(const std::string&). */ cmSourceFile *LinearGetSourceFileWithOutput(const std::string& cname) const; // A map for fast output to input look up. #if defined(CMAKE_BUILD_WITH_CMAKE) typedef cmsys::hash_map OutputToSourceMap; #else typedef std::map OutputToSourceMap; #endif OutputToSourceMap OutputToSource; void UpdateOutputToSourceMap(std::vector const& outputs, cmSourceFile* source); void UpdateOutputToSourceMap(std::string const& output, cmSourceFile* source); std::vector QtUiFilesWithOptions; }; //---------------------------------------------------------------------------- // Helper class to make sure the call stack is valid. class cmMakefileCall { public: cmMakefileCall(cmMakefile* mf, cmListFileContext const& lfc, cmExecutionStatus& status): Makefile(mf) { cmMakefile::CallStackEntry entry = {&lfc, &status}; this->Makefile->CallStack.push_back(entry); } ~cmMakefileCall() { this->Makefile->CallStack.pop_back(); } private: cmMakefile* Makefile; }; #endif