CMake/Source/cmMakefile.h

961 lines
31 KiB
C
Raw Normal View History

/*============================================================================
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
2001-01-11 22:47:38 +03:00
#include "cmStandardIncludes.h"
#include "cmAlgorithms.h"
#include "cmExecutionStatus.h"
#include "cmExpandedCommandArgument.h"
#include "cmListFileCache.h"
#include "cmNewLineStyle.h"
#include "cmState.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
2008-03-11 17:29:56 +03:00
#include "cmake.h"
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmSourceGroup.h"
#endif
#include <cm_auto_ptr.hxx>
#include <cmsys/RegularExpression.hxx>
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
#include <unordered_map>
#else
#include <cmsys/hash_map.hxx>
#endif
#endif
#include <stack>
2001-04-20 01:39:03 +04:00
class cmFunctionBlocker;
2001-01-18 19:20:24 +03:00
class cmCommand;
class cmInstallGenerator;
class cmSourceFile;
class cmTest;
class cmTestGenerator;
2003-01-08 20:59:52 +03:00
class cmVariableWatch;
class cmake;
class cmMakefileCall;
class cmCMakePolicyCommand;
class cmGeneratorExpressionEvaluationFile;
class cmExportBuildFileGenerator;
2001-01-11 22:47:38 +03:00
/** \class cmMakefile
* \brief Process the input CMakeLists.txt file.
*
* Process and store into memory the input CMakeLists.txt file.
2001-01-18 19:20:24 +03:00
* Each CMakeLists.txt file is parsed and the commands found there
2001-01-11 22:47:38 +03:00
* are added into the build process.
*/
class cmMakefile
{
public:
/* 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;
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Construct an empty makefile.
*/
cmMakefile(cmGlobalGenerator* globalGenerator,
const cmState::Snapshot& snapshot);
2001-01-11 22:47:38 +03:00
/**
* Destructor.
*/
2002-08-24 00:13:34 +04:00
~cmMakefile();
2001-01-11 22:47:38 +03:00
2015-06-21 21:02:16 +03:00
bool ReadListFile(const char* filename);
2015-06-21 21:02:16 +03:00
bool ReadDependentFile(const char* filename, bool noPolicyScope = true);
2015-06-21 21:02:16 +03:00
bool ProcessBuildsystemFile(const char* filename);
2001-01-11 22:47:38 +03:00
2001-04-20 01:39:03 +04:00
/**
* Add a function blocker to this makefile
*/
void AddFunctionBlocker(cmFunctionBlocker* fb);
/// @return whether we are processing the top CMakeLists.txt file.
bool IsRootMakefile() const;
/**
* Remove the function blocker whose scope ends with the given command.
* This returns ownership of the function blocker object.
*/
CM_AUTO_PTR<cmFunctionBlocker> RemoveFunctionBlocker(
cmFunctionBlocker* fb, const cmListFileFunction& lff);
/**
* Try running cmake and building a file. This is used for dynalically
* loaded commands, not as part of the usual build process.
*/
2014-02-25 02:38:30 +04:00
int TryCompile(const std::string& srcdir, const std::string& bindir,
const std::string& projectName, const std::string& targetName,
bool fast, const std::vector<std::string>* cmakeArgs,
std::string& output);
2011-10-13 21:51:18 +04:00
bool GetIsSourceFileTryCompile() const;
/**
* Help enforce global target name uniqueness.
*/
bool EnforceUniqueName(std::string const& name, std::string& msg,
bool isCustom = false) const;
2001-01-11 22:47:38 +03:00
/**
* Perform FinalPass, Library dependency analysis etc before output of the
2011-10-13 21:51:18 +04:00
* makefile.
2001-01-11 22:47:38 +03:00
*/
void ConfigureFinalPass();
2011-10-13 21:51:18 +04:00
/**
* run the final pass on all commands.
*/
void FinalPass();
2011-10-13 21:51:18 +04:00
/** Add a custom command to the build. */
2014-02-07 02:31:47 +04:00
void AddCustomCommandToTarget(const std::string& target,
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
const std::vector<std::string>& byproducts,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines,
cmTarget::CustomCommandType type,
const char* comment, const char* workingDir,
bool escapeOldStyle = true,
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
bool uses_terminal = false);
cmSourceFile* AddCustomCommandToOutput(
const std::vector<std::string>& outputs,
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
const std::vector<std::string>& byproducts,
const std::vector<std::string>& depends,
const std::string& main_dependency,
const cmCustomCommandLines& commandLines, const char* comment,
const char* workingDir, bool replace = false, bool escapeOldStyle = true,
bool uses_terminal = false);
cmSourceFile* AddCustomCommandToOutput(
const std::string& output, const std::vector<std::string>& depends,
const std::string& main_dependency,
const cmCustomCommandLines& commandLines, const char* comment,
const char* workingDir, bool replace = false, bool escapeOldStyle = true,
bool uses_terminal = false);
2014-02-07 02:31:47 +04:00
void AddCustomCommandOldStyle(const std::string& target,
const std::vector<std::string>& outputs,
const std::vector<std::string>& depends,
const std::string& source,
const cmCustomCommandLines& commandLines,
const char* comment);
2001-01-11 22:47:38 +03:00
/**
* Add a define flag to the build.
*/
void AddDefineFlag(const char* definition);
void RemoveDefineFlag(const char* definition);
void AddCompileOption(const char* option);
2001-01-11 22:47:38 +03:00
/** Create a new imported target with the name and type given. */
2014-02-07 02:31:47 +04:00
cmTarget* AddImportedTarget(const std::string& name,
cmState::TargetType type, bool global);
cmTarget* AddNewTarget(cmState::TargetType type, const std::string& name);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Add an executable to the build.
*/
cmTarget* AddExecutable(const char* exename,
const std::vector<std::string>& srcs,
2007-03-12 17:26:59 +03:00
bool excludeFromAll = false);
2001-01-11 22:47:38 +03:00
/**
* Add a utility to the build. A utiltity target is a command that
* is run every time the target is built.
*/
2016-06-27 23:44:16 +03:00
cmTarget* AddUtilityCommand(
const std::string& utilityName, bool excludeFromAll,
const std::vector<std::string>& depends, const char* workingDirectory,
const char* command, const char* arg1 = CM_NULLPTR,
const char* arg2 = CM_NULLPTR, const char* arg3 = CM_NULLPTR,
const char* arg4 = CM_NULLPTR);
cmTarget* AddUtilityCommand(
const std::string& utilityName, bool excludeFromAll,
const char* workingDirectory, const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines, bool escapeOldStyle = true,
2016-06-27 23:44:16 +03:00
const char* comment = CM_NULLPTR, bool uses_terminal = false);
cmTarget* AddUtilityCommand(
const std::string& utilityName, bool excludeFromAll,
const char* workingDirectory, const std::vector<std::string>& byproducts,
const std::vector<std::string>& depends,
const cmCustomCommandLines& commandLines, bool escapeOldStyle = true,
2016-06-27 23:44:16 +03:00
const char* comment = CM_NULLPTR, bool uses_terminal = false);
2001-01-11 22:47:38 +03:00
/**
* Add a link library to the build.
*/
2014-02-07 02:31:47 +04:00
void AddLinkLibrary(const std::string&);
void AddLinkLibrary(const std::string&, cmTargetLinkLibraryType type);
2014-02-07 02:31:47 +04:00
void AddLinkLibraryForTarget(const std::string& tgt, const std::string&,
cmTargetLinkLibraryType type);
2014-02-07 02:31:47 +04:00
void AddLinkDirectoryForTarget(const std::string& tgt, const std::string& d);
2001-01-11 22:47:38 +03:00
/**
* Add a subdirectory to the build.
*/
void AddSubDirectory(const std::string& fullSrcDir,
const std::string& fullBinDir, bool excludeFromAll,
bool immediate);
2001-01-11 22:47:38 +03:00
void Configure();
/**
* Configure a subdirectory
*/
void ConfigureSubDirectory(cmMakefile* mf);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Add an include directory to the build.
*/
void AddIncludeDirectories(const std::vector<std::string>& incs,
bool before = false);
2001-01-11 22:47:38 +03:00
/**
* 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, cmState::CacheEntryType type,
2008-11-22 00:32:39 +03:00
bool force = false);
2001-01-11 22:47:38 +03:00
2001-04-24 20:40:37 +04:00
/**
2011-10-13 21:51:18 +04:00
* Add bool variable definition to the build.
2001-04-24 20:40:37 +04:00
*/
void AddDefinition(const std::string& name, bool);
2001-04-24 20:40:37 +04:00
2002-09-18 18:39:41 +04:00
/**
* 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);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
/**
* Specify the name of the project for this build.
*/
void SetProjectName(std::string const& name);
2001-01-11 22:47:38 +03:00
/** Get the configurations to be generated. */
std::string GetConfigurations(std::vector<std::string>& configs,
bool single = true) const;
2001-01-11 22:47:38 +03:00
/**
* Set the name of the library.
*/
cmTarget* AddLibrary(const std::string& libname, cmState::TargetType type,
const std::vector<std::string>& srcs,
bool excludeFromAll = false);
void AddAlias(const std::string& libname, const std::string& tgt);
2001-01-11 22:47:38 +03:00
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
* Add a root source group for consideration when adding a new source.
*/
2016-06-27 23:44:16 +03:00
void AddSourceGroup(const std::string& name, const char* regex = CM_NULLPTR);
/**
* Add a source group for consideration when adding a new source.
* name is tokenized.
*/
2011-10-13 21:51:18 +04:00
void AddSourceGroup(const std::vector<std::string>& name,
2016-06-27 23:44:16 +03:00
const char* regex = CM_NULLPTR);
2006-03-22 17:58:11 +03:00
#endif
//@{
/**
2011-10-13 21:51:18 +04:00
* 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);
~PolicyPushPop();
private:
cmMakefile* Makefile;
};
friend class PolicyPushPop;
/**
* Determine if the given context, name pair has already been reported
* in context of CMP0054.
*/
bool HasCMP0054AlreadyBeenReported(const cmListFileContext& context) const;
2011-10-13 21:51:18 +04:00
bool IgnoreErrorsCMP0061() const;
const char* GetHomeDirectory() const;
const char* GetHomeOutputDirectory() const;
/**
* 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<std::string>& args);
const char* GetCurrentSourceDirectory() const;
const char* GetCurrentBinaryDirectory() const;
2001-04-30 18:52:58 +04:00
2001-02-15 21:30:13 +03:00
//@}
2011-10-13 21:51:18 +04:00
/**
* 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->SetProperty("INCLUDE_REGULAR_EXPRESSION", regex);
}
2014-01-22 17:38:10 +04:00
const char* GetIncludeRegularExpression() const
{
return this->GetProperty("INCLUDE_REGULAR_EXPRESSION");
}
2011-10-13 21:51:18 +04:00
/**
* 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();
}
2001-01-11 22:47:38 +03:00
/**
* Get the list of targets
2001-01-11 22:47:38 +03:00
*/
cmTargets& GetTargets() { return this->Targets; }
/**
* Get the list of targets, const version
*/
const cmTargets& GetTargets() const { return this->Targets; }
const std::vector<cmTarget*>& GetOwnedImportedTargets() const
{
return this->ImportedTargetsOwned;
}
std::vector<cmTarget*> GetImportedTargets() const;
2001-01-11 22:47:38 +03:00
cmTarget* FindLocalNonAliasTarget(const std::string& name) const;
2001-01-11 22:47:38 +03:00
/** 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;
2006-04-11 20:51:20 +04:00
std::map<std::string, std::string> GetAliasTargets() const
{
return this->AliasTargets;
}
/**
* Mark include directories as system directories.
*/
void AddSystemIncludeDirectories(const std::set<std::string>& incs);
/** 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;
2003-06-03 18:30:23 +04:00
/** 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* CreateSource(const std::string& sourceName,
bool generated = false);
2003-06-03 18:30:23 +04:00
/** Get a cmSourceFile pointer for a given source name, if the name is
2011-10-13 21:51:18 +04:00
* not found, then create the source file and return it. generated
2003-06-03 18:30:23 +04:00
* 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,
2003-06-03 18:30:23 +04:00
bool generated = false);
2001-01-11 22:47:38 +03:00
/**
* 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<std::string> GetDefinitions() const;
2011-10-13 21:51:18 +04:00
/**
* Test a boolean variable to see if it is true or false.
* If the variable is not found in this makefile instance, the
* cache is then queried.
* Returns false if no entry defined.
*/
bool IsOn(const std::string& name) const;
bool IsSet(const std::string& name) const;
2001-01-11 22:47:38 +03:00
/** Return whether the target platform is 32-bit. */
bool PlatformIs32Bit() const;
/** Return whether the target platform is 64-bit. */
bool PlatformIs64Bit() const;
/** Return whether the target platform is Apple iOS. */
bool PlatformIsAppleIos() const;
Support building shared libraries or modules without soname (#13155) Add a boolean target property NO_SONAME which may be used to disable soname for the specified shared library or module even if the platform supports it. This property should be useful for private shared libraries or various plugins which live in private directories and have not been designed to be found or loaded globally. Replace references to <CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG> and hard-coded -install_name flags with a conditional <SONAME_FLAG> which is expanded to the value of the CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG definition as long as soname supports is enabled for the target in question. Keep expanding CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG in rules in case third party projects still use it. Such projects would not yet use NO_SONAME so the adjacent <TARGET_SONAME> will always be expanded. Make <TARGET_INSTALLNAME_DIR> NO_SONAME aware as well. Since -install_name is soname on OS X, this should not be a problem if this variable is expanded only if soname is enabled. The Ninja generator performs rule variable substitution only once globally per rule to put its own placeholders. Final substitution is performed by ninja at build time. Therefore we cannot conditionally replace the soname placeholders on a per-target basis. Rather than omitting $SONAME from rules.ninja, simply do not write its contents for targets which have NO_SONAME. Since 3 variables are affected by NO_SONAME ($SONAME, $SONAME_FLAG, $INSTALLNAME_DIR), set them only if soname is enabled.
2012-04-22 17:42:55 +04:00
/** Retrieve soname flag for the specified language if supported */
const char* GetSONameFlag(const std::string& language) const;
Support building shared libraries or modules without soname (#13155) Add a boolean target property NO_SONAME which may be used to disable soname for the specified shared library or module even if the platform supports it. This property should be useful for private shared libraries or various plugins which live in private directories and have not been designed to be found or loaded globally. Replace references to <CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG> and hard-coded -install_name flags with a conditional <SONAME_FLAG> which is expanded to the value of the CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG definition as long as soname supports is enabled for the target in question. Keep expanding CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG in rules in case third party projects still use it. Such projects would not yet use NO_SONAME so the adjacent <TARGET_SONAME> will always be expanded. Make <TARGET_INSTALLNAME_DIR> NO_SONAME aware as well. Since -install_name is soname on OS X, this should not be a problem if this variable is expanded only if soname is enabled. The Ninja generator performs rule variable substitution only once globally per rule to put its own placeholders. Final substitution is performed by ninja at build time. Therefore we cannot conditionally replace the soname placeholders on a per-target basis. Rather than omitting $SONAME from rules.ninja, simply do not write its contents for targets which have NO_SONAME. Since 3 variables are affected by NO_SONAME ($SONAME, $SONAME_FLAG, $INSTALLNAME_DIR), set them only if soname is enabled.
2012-04-22 17:42:55 +04:00
/**
2001-01-11 22:47:38 +03:00
* 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;
2011-10-13 21:51:18 +04:00
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
* Get the vector source groups.
*/
const std::vector<cmSourceGroup>& GetSourceGroups() const
{
return this->SourceGroups;
}
2001-04-30 18:52:58 +04:00
2002-10-05 02:16:13 +04:00
/**
* Get the source group
*/
cmSourceGroup* GetSourceGroup(const std::vector<std::string>& name) const;
2006-03-22 17:58:11 +03:00
#endif
2002-10-05 02:16:13 +04:00
2001-04-30 18:52:58 +04:00
/**
* Get the vector of list files on which this makefile depends
*/
const std::vector<std::string>& 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 FormatListFileStack() const;
/**
* Get the current context backtrace.
*/
cmListFileBacktrace GetBacktrace() const;
cmListFileBacktrace GetBacktrace(cmCommandContext const& lfc) const;
cmListFileContext GetExecutionContext() const;
/**
* Get the vector of files created by this makefile
*/
const std::vector<std::string>& GetOutputFiles() const
{
return this->OutputFiles;
}
void AddCMakeOutputFile(const std::string& file)
{
this->OutputFiles.push_back(file);
}
2011-10-13 21:51:18 +04:00
/**
2011-10-13 21:51:18 +04:00
* Expand all defined variables in the string.
2006-03-15 19:02:08 +03:00
* Defined variables come from the this->Definitions map.
* They are expanded with ${var} where var is the
2011-03-20 16:22:39 +03:00
* 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,
2016-06-27 23:44:16 +03:00
const char* filename = CM_NULLPTR,
long line = -1, bool removeEmpty = false,
bool replaceAt = false) const;
/**
* Remove any remaining variables in the string. Anything with ${var} or
2011-03-20 16:22:39 +03:00
* \@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;
2004-03-09 15:50:45 +03:00
/**
* 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());
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
/**
* find what source group this source is in
*/
cmSourceGroup* FindSourceGroup(const char* source,
std::vector<cmSourceGroup>& groups) const;
2006-03-22 17:58:11 +03:00
#endif
/**
* Print a command's invocation
*/
void PrintCommandTrace(const cmListFileFunction& lff) const;
2001-07-26 00:53:13 +04:00
/**
* Execute a single CMake command. Returns true if the command
* succeeded or false if it failed.
2001-07-26 00:53:13 +04:00
*/
2011-10-13 21:51:18 +04:00
bool ExecuteCommand(const cmListFileFunction& lff,
cmExecutionStatus& status);
2006-05-12 20:29:09 +04:00
///! Enable support for named language, if nil then all languages are
/// enabled.
void EnableLanguage(std::vector<std::string> const& languages,
bool optional);
cmState* GetState() const;
/**
* Get the variable watch. This is used to determine when certain variables
* are accessed.
*/
#ifdef CMAKE_BUILD_WITH_CMAKE
2003-01-08 20:59:52 +03:00
cmVariableWatch* GetVariableWatch() const;
#endif
///! Display progress or status message.
void DisplayStatus(const char*, float) const;
2011-10-13 21:51:18 +04:00
/**
* Expand the given list file arguments into the full set after
* variable replacement and list expansion.
*/
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<std::string>& outArgs,
2016-06-27 23:44:16 +03:00
const char* filename = CM_NULLPTR) const;
bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
std::vector<cmExpandedCommandArgument>& outArgs,
2016-06-27 23:44:16 +03:00
const char* filename = CM_NULLPTR) const;
/**
* Get the instance
2011-10-13 21:51:18 +04:00
*/
cmake* GetCMakeInstance() const;
cmGlobalGenerator* GetGlobalGenerator() const;
2003-06-03 18:30:23 +04:00
/**
* Get all the source files this makefile knows about
*/
const std::vector<cmSourceFile*>& GetSourceFiles() const
{
return this->SourceFiles;
}
std::vector<cmSourceFile*>& GetSourceFiles() { return this->SourceFiles; }
2003-06-03 18:30:23 +04:00
/**
* 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 new cmTest to the list of tests for this makefile.
2014-02-04 06:20:33 +04:00
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.
*/
2014-02-04 06:20:33 +04:00
cmTest* GetTest(const std::string& testName) const;
/**
* Return a location of a file in cmake or custom modules directory
*/
std::string GetModulesFile(const char* name) const;
2011-10-13 21:51:18 +04:00
///! 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, bool chain) const;
bool GetPropertyAsBool(const std::string& prop) const;
std::vector<std::string> GetPropertyKeys() const;
///! Initialize a makefile from its parent
void InitializeFromParent(cmMakefile* parent);
2011-10-13 21:51:18 +04:00
void AddInstallGenerator(cmInstallGenerator* g)
{
if (g) {
this->InstallGenerators.push_back(g);
}
}
std::vector<cmInstallGenerator*>& GetInstallGenerators()
{
return this->InstallGenerators;
}
void AddTestGenerator(cmTestGenerator* g)
{
if (g) {
this->TestGenerators.push_back(g);
}
}
const std::vector<cmTestGenerator*>& GetTestGenerators() const
{
return this->TestGenerators;
}
class FunctionPushPop
{
public:
FunctionPushPop(cmMakefile* mf, std::string const& fileName,
cmPolicies::PolicyMap const& pm);
~FunctionPushPop();
void Quiet() { this->ReportError = false; }
private:
cmMakefile* Makefile;
bool ReportError;
};
class MacroPushPop
{
public:
MacroPushPop(cmMakefile* mf, std::string const& fileName,
cmPolicies::PolicyMap const& pm);
~MacroPushPop();
void Quiet() { this->ReportError = false; }
private:
cmMakefile* Makefile;
bool ReportError;
};
void PushFunctionScope(std::string const& fileName,
cmPolicies::PolicyMap const& pm);
void PopFunctionScope(bool reportError);
void PushMacroScope(std::string const& fileName,
cmPolicies::PolicyMap const& pm);
void PopMacroScope(bool reportError);
2007-12-03 21:35:41 +03:00
void PushScope();
void PopScope();
void RaiseScope(const std::string& var, const char* value);
2007-12-03 21:35:41 +03:00
// push and pop loop scopes
void PushLoopBlockBarrier();
void PopLoopBlockBarrier();
/** 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; }
cmStringRange GetIncludeDirectoriesEntries() const;
cmBacktraceRange GetIncludeDirectoriesBacktraces() const;
cmStringRange GetCompileOptionsEntries() const;
cmBacktraceRange GetCompileOptionsBacktraces() const;
cmStringRange GetCompileDefinitionsEntries() const;
cmBacktraceRange GetCompileDefinitionsBacktraces() const;
void AddQtUiFileWithOptions(cmSourceFile* sf);
std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const;
std::set<std::string> const& GetSystemIncludeDirectories() const
{
return this->SystemIncludeDirectories;
}
bool PolicyOptionalWarningEnabled(std::string const& var);
bool AddRequiredTargetFeature(cmTarget* target, const std::string& feature,
2016-06-27 23:44:16 +03:00
std::string* error = CM_NULLPTR) const;
bool CompileFeatureKnown(cmTarget const* target, const std::string& feature,
std::string& lang, std::string* error) const;
const char* CompileFeaturesAvailable(const std::string& lang,
std::string* error) const;
bool HaveStandardAvailable(cmTarget const* target, std::string const& lang,
const std::string& feature) const;
bool IsLaterStandard(std::string const& lang, std::string const& lhs,
std::string const& rhs);
void PushLoopBlock();
void PopLoopBlock();
bool IsLoopBlock() const;
void ClearMatches();
void StoreMatches(cmsys::RegularExpression& re);
cmState::Snapshot GetStateSnapshot() const;
const char* GetDefineFlagsCMP0059() const;
std::string GetExecutionFilePath() const;
void EnforceDirectoryLevelRules() const;
void AddEvaluationFile(const std::string& inputFile,
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputName,
CM_AUTO_PTR<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const;
std::vector<cmExportBuildFileGenerator*> GetExportBuildFileGenerators()
const;
void RemoveExportBuildFileGeneratorCMP0024(cmExportBuildFileGenerator* gen);
void AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen);
protected:
// add link libraries and directories to the target
2014-02-07 02:31:47 +04:00
void AddGlobalLinkInformation(const std::string& name, cmTarget& target);
2010-09-14 23:22:31 +04:00
// Check for a an unused variable
void LogUnused(const char* reason, const std::string& name) const;
2010-09-14 23:22:31 +04:00
mutable std::set<cmListFileContext> CMP0054ReportedIds;
// libraries, classes, and executables
2013-11-19 14:47:36 +04:00
mutable cmTargets Targets;
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
typedef std::unordered_map<std::string, cmTarget*> TargetMap;
#else
typedef cmsys::hash_map<std::string, cmTarget*> TargetMap;
#endif
#else
typedef std::map<std::string, cmTarget*> TargetMap;
#endif
std::map<std::string, std::string> AliasTargets;
2006-03-15 19:02:08 +03:00
std::vector<cmSourceFile*> SourceFiles;
// Tests
std::map<std::string, cmTest*> Tests;
2011-10-13 21:51:18 +04:00
// The link-library paths. Order matters, use std::vector (not std::set).
2006-03-15 19:02:08 +03:00
std::vector<std::string> LinkDirectories;
// The set of include directories that are marked as system include
// directories.
std::set<std::string> SystemIncludeDirectories;
std::vector<std::string> ListFiles;
std::vector<std::string> OutputFiles;
2011-10-13 21:51:18 +04:00
2006-03-15 19:02:08 +03:00
cmTarget::LinkLibraryVectorType LinkLibraries;
std::vector<cmInstallGenerator*> InstallGenerators;
std::vector<cmTestGenerator*> TestGenerators;
2006-03-15 19:02:08 +03:00
std::string ComplainFileRegularExpression;
std::string DefineFlags;
2006-03-22 17:58:11 +03:00
// 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;
2006-03-22 17:58:11 +03:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
2006-03-15 19:02:08 +03:00
std::vector<cmSourceGroup> SourceGroups;
2006-03-22 17:58:11 +03:00
#endif
std::vector<cmCommand*> FinalPassCommands;
cmGlobalGenerator* GlobalGenerator;
2011-10-13 21:51:18 +04:00
bool IsFunctionBlocked(const cmListFileFunction& lff,
cmExecutionStatus& status);
2011-10-13 21:51:18 +04:00
2001-01-11 22:47:38 +03:00
private:
cmMakefile(const cmMakefile& mf);
cmMakefile& operator=(const cmMakefile& mf);
2001-01-11 22:47:38 +03:00
cmState::Snapshot StateSnapshot;
cmListFileBacktrace: Refactor storage to provide efficient value semantics Since commit v3.4.0-rc1~321^2~2 (Genex: Store a backtrace, not a pointer to one, 2015-07-08) we treat cmListFileBacktrace instances as lightweight values. This was true at the time only because the backtrace information was kept in the cmState snapshot hierarchy. However, that forced us to accumulate a lot of otherwise short-lived snapshots just to have the backtrace fields available for reference by cmListFileBacktrace instances. Recent refactoring made backtrace instances independent of the snapshot hierarchy to avoid accumulating short-lived snapshots. This came at the cost of making backtrace values heavy again, leading to lots of string coying and slower execution. Fix this by refactoring cmListFileBacktrace to provide value semantics with efficient shared storage underneath. Teach cmMakefile to maintain its call stack using an instance of cmListFileBacktrace. This approach allows the current backtrace to be efficiently saved whenever it is needed. Also teach cmListFileBacktrace the notion of a file-level scope. This is useful for messages about the whole file (e.g. during parsing) that are not specific to any line within it. Push the CMakeLists.txt scope for each directory and never pop it. This ensures that we always have some context information and simplifies cmMakefile::IssueMessage. Push/pop a file-level scope as each included file is processed. This supersedes cmParseFileScope and improves diagnostic message context information in a few places. Fix the corresponding test cases to expect the improved output.
2016-04-14 18:24:08 +03:00
cmListFileBacktrace Backtrace;
void ReadListFile(cmListFile const& listFile,
const std::string& filenametoread);
bool ParseDefineFlag(std::string const& definition, bool remove);
bool EnforceUniqueDir(const std::string& srcPath,
const std::string& binPath) const;
typedef std::vector<cmFunctionBlocker*> FunctionBlockersType;
FunctionBlockersType FunctionBlockers;
std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers;
void PushFunctionBlockerBarrier();
void PopFunctionBlockerBarrier(bool reportError = true);
std::stack<int> LoopBlockCounter;
mutable cmsys::RegularExpression cmDefineRegex;
mutable cmsys::RegularExpression cmDefine01Regex;
mutable cmsys::RegularExpression cmAtVarRegex;
mutable cmsys::RegularExpression cmNamedCurly;
std::vector<cmMakefile*> UnConfiguredDirectories;
std::vector<cmExportBuildFileGenerator*> ExportBuildFileGenerators;
std::vector<cmGeneratorExpressionEvaluationFile*> EvaluationFiles;
std::vector<cmExecutionStatus*> ExecutionStatusStack;
friend class cmMakefileCall;
friend class cmParseFileScope;
std::vector<cmTarget*> ImportedTargetsOwned;
TargetMap ImportedTargets;
// Internal policy stack management.
void PushPolicy(bool weak = false,
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
void PopPolicy();
void PopSnapshot(bool reportError = true);
friend class cmCMakePolicyCommand;
class IncludeScope;
friend class IncludeScope;
class ListFileScope;
friend class ListFileScope;
class BuildsystemFileScope;
friend class BuildsystemFileScope;
// CMP0053 == old
cmake::MessageType ExpandVariablesInStringOld(
std::string& errorstr, std::string& source, bool escapeQuotes,
bool noEscapes, bool atOnly, const char* filename, long line,
bool removeEmpty, bool replaceAt) const;
// CMP0053 == new
cmake::MessageType ExpandVariablesInStringNew(
std::string& errorstr, std::string& source, bool escapeQuotes,
bool noEscapes, bool atOnly, const char* filename, long line,
bool removeEmpty, bool replaceAt) const;
/**
* 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)
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
typedef std::unordered_map<std::string, cmSourceFile*> OutputToSourceMap;
#else
typedef cmsys::hash_map<std::string, cmSourceFile*> OutputToSourceMap;
#endif
#else
typedef std::map<std::string, cmSourceFile*> OutputToSourceMap;
#endif
OutputToSourceMap OutputToSource;
void UpdateOutputToSourceMap(std::vector<std::string> const& outputs,
cmSourceFile* source);
void UpdateOutputToSourceMap(std::string const& output,
cmSourceFile* source);
std::vector<cmSourceFile*> QtUiFilesWithOptions;
bool AddRequiredTargetCFeature(cmTarget* target, const std::string& feature,
2016-06-27 23:44:16 +03:00
std::string* error = CM_NULLPTR) const;
bool AddRequiredTargetCxxFeature(cmTarget* target,
const std::string& feature,
2016-06-27 23:44:16 +03:00
std::string* error = CM_NULLPTR) const;
void CheckNeededCLanguage(const std::string& feature, bool& needC90,
bool& needC99, bool& needC11) const;
void CheckNeededCxxLanguage(const std::string& feature, bool& needCxx98,
bool& needCxx11, bool& needCxx14) const;
bool HaveCStandardAvailable(cmTarget const* target,
const std::string& feature) const;
bool HaveCxxStandardAvailable(cmTarget const* target,
const std::string& feature) const;
void CheckForUnusedVariables() const;
// Unused variable flags
bool WarnUnused;
bool CheckSystemVars;
bool CheckCMP0000;
bool IsSourceFileTryCompile;
mutable bool SuppressWatches;
};
#endif