reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2025-02-23 05:22:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
CMake/Source/cmState.h

258 lines
9.6 KiB
C
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 15:01:08 -04:00
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
#ifndef cmState_h
#define cmState_h
Use quotes for non-system includes Automate with: git grep -l '#include <cm_' -- Source \ | xargs sed -i 's/#include <\(cm_.*\)>/#include "\1"/g' git grep -l '#include <cmsys/' -- Source \ | xargs sed -i 's/#include <\(cmsys\/.*\)>/#include "\1"/g' git grep -l '#include <cm[A-Z]' -- Source \ | xargs sed -i 's/#include <\(cm[A-Z].*\)>/#include "\1"/g'
2017-04-11 22:00:21 +02:00
#include "cmConfigure.h" // IWYU pragma: keep
Source: Stabilize include order Each source file has a logical first include file. Include it in an isolated block so that tools that sort includes do not move them.
2016-04-29 09:40:20 -04:00
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
#include <functional>
Fix several include-what-you-use findings
2016-11-05 21:40:14 +01:00
#include <map>
IWYU: Fix handling of <memory> standard header An old workaround for `std::allocator_traits<>::value_type` lints from IWYU on `std::vector<>` usage breaks IWYU's handling of `<memory>`. Convert the workaround to use the same approach we already use for a workaround of `std::__decay_and_strip<>::::__type` lints. Then update the `<memory>` inclusions to follow the now-correct IWYU lints.
2019-07-10 11:38:48 -04:00
#include <memory>
Fix several include-what-you-use findings
2016-11-05 21:40:14 +01:00
#include <set>
#include <string>
#include <vector>
fix a batch of include-what-you-use violations
2016-08-17 01:08:13 +02:00
#include "cmDefinitions.h"
Format include directive blocks and ordering with clang-format Sort include directives within each block (separated by a blank line) in lexicographic order (except to prioritize `sys/types.h` first). First run `clang-format` with the config file: --- SortIncludes: false ... Commit the result temporarily. Then run `clang-format` again with: --- SortIncludes: true IncludeCategories: - Regex: 'sys/types.h' Priority: -1 ... Commit the result temporarily. Start a new branch and cherry-pick the second commit. Manually resolve conflicts to preserve indentation of re-ordered includes. This cleans up the include ordering without changing any other style. Use the following command to run `clang-format`: $ git ls-files -z -- \ '*.c' '*.cc' '*.cpp' '*.cxx' '*.h' '*.hh' '*.hpp' '*.hxx' | egrep -z -v '(Lexer|Parser|ParserHelper)\.' | egrep -z -v '^Source/cm_sha2' | egrep -z -v '^Source/(kwsys|CursesDialog/form)/' | egrep -z -v '^Utilities/(KW|cm).*/' | egrep -z -v '^Tests/Module/GenerateExportHeader' | egrep -z -v '^Tests/RunCMake/CommandLine/cmake_depends/test_UTF-16LE.h' | xargs -0 clang-format -i This selects source files that do not come from a third-party. Inspired-by: Daniel Pfeifer <daniel@pfeifer-mail.de>
2016-04-29 10:53:13 -04:00
#include "cmLinkedTree.h"
Add cmGlobVerificationManager class, integrate with cmake and cmState
2018-02-14 11:26:35 -05:00
#include "cmListFileCache.h"
cmState: introduce methods for adding builtin commands
2017-05-10 21:05:29 +02:00
#include "cmPolicies.h"
fix a batch of include-what-you-use violations
2016-08-17 01:08:13 +02:00
#include "cmProperty.h"
Format include directive blocks and ordering with clang-format Sort include directives within each block (separated by a blank line) in lexicographic order (except to prioritize `sys/types.h` first). First run `clang-format` with the config file: --- SortIncludes: false ... Commit the result temporarily. Then run `clang-format` again with: --- SortIncludes: true IncludeCategories: - Regex: 'sys/types.h' Priority: -1 ... Commit the result temporarily. Start a new branch and cherry-pick the second commit. Manually resolve conflicts to preserve indentation of re-ordered includes. This cleans up the include ordering without changing any other style. Use the following command to run `clang-format`: $ git ls-files -z -- \ '*.c' '*.cc' '*.cpp' '*.cxx' '*.h' '*.hh' '*.hpp' '*.hxx' | egrep -z -v '(Lexer|Parser|ParserHelper)\.' | egrep -z -v '^Source/cm_sha2' | egrep -z -v '^Source/(kwsys|CursesDialog/form)/' | egrep -z -v '^Utilities/(KW|cm).*/' | egrep -z -v '^Tests/Module/GenerateExportHeader' | egrep -z -v '^Tests/RunCMake/CommandLine/cmake_depends/test_UTF-16LE.h' | xargs -0 clang-format -i This selects source files that do not come from a third-party. Inspired-by: Daniel Pfeifer <daniel@pfeifer-mail.de>
2016-04-29 10:53:13 -04:00
#include "cmPropertyDefinitionMap.h"
#include "cmPropertyMap.h"
Fix several include-what-you-use findings
2016-11-05 21:40:14 +01:00
#include "cmStatePrivate.h"
cmState: Move extracted declarations to a separate file
2016-10-18 21:28:48 +02:00
#include "cmStateTypes.h"
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
fix a batch of include-what-you-use violations
2016-08-17 01:08:13 +02:00
class cmCacheManager;
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 12:30:26 +02:00
class cmCommand;
Add cmGlobVerificationManager class, integrate with cmake and cmState
2018-02-14 11:26:35 -05:00
class cmGlobVerificationManager;
fix a batch of include-what-you-use violations
2016-08-17 01:08:13 +02:00
class cmPropertyDefinition;
cmState: Move Snapshot type to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 21:28:47 +02:00
class cmStateSnapshot;
cmCacheManager: Truncate values containing newlines Fixes #16098.
2018-01-09 15:56:40 -05:00
class cmMessenger;
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
class cmExecutionStatus;
cmState: Move Directory class to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 21:28:47 +02:00
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
class cmState
{
cmState: Move Snapshot type to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 21:28:47 +02:00
friend class cmStateSnapshot;
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
public:
cmState: Port away from cmake instance.
2015-10-10 15:42:02 +02:00
cmState();
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 12:30:26 +02:00
~cmState();
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
Delete some default constructors and assignment operators They are unused, but if someone used them they would lead to problems since they would copy the internal raw pointers and the destructor would cause double delete
2019-02-14 17:29:57 +01:00
cmState(const cmState&) = delete;
cmState& operator=(const cmState&) = delete;
Properties: Add CMAKE_ROLE global property This property allows scripts to determine whether they're in project mode, script mode, find-package mode, CTest, or CPack.
2019-01-14 12:27:14 -05:00
enum Mode
{
Unknown,
Project,
Script,
FindPackage,
CTest,
CPack,
};
cmState: Move TargetType enum to separate namespace
2016-10-18 21:28:46 +02:00
static const char* GetTargetTypeName(cmStateEnums::TargetType targetType);
cmState: Move GetTargetTypeName from cmTarget.
2015-10-08 00:26:50 +02:00
cmState: Move Snapshot type to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 21:28:47 +02:00
cmStateSnapshot CreateBaseSnapshot();
cmStateSnapshot CreateBuildsystemDirectorySnapshot(
Pass large types by const&, small types by value
2017-06-02 21:01:01 +02:00
cmStateSnapshot const& originSnapshot);
cmStateSnapshot CreateFunctionCallSnapshot(
cmStateSnapshot const& originSnapshot, std::string const& fileName);
cmStateSnapshot CreateMacroCallSnapshot(
cmStateSnapshot const& originSnapshot, std::string const& fileName);
cmStateSnapshot CreateIncludeFileSnapshot(
cmStateSnapshot const& originSnapshot, std::string const& fileName);
cmStateSnapshot CreateVariableScopeSnapshot(
cmStateSnapshot const& originSnapshot);
cmStateSnapshot CreateInlineListFileSnapshot(
cmStateSnapshot const& originSnapshot, std::string const& fileName);
cmStateSnapshot CreatePolicyScopeSnapshot(
cmStateSnapshot const& originSnapshot);
cmStateSnapshot Pop(cmStateSnapshot const& originSnapshot);
Introduce cmState::Snapshot. Create snapshots for buildsystem directories during configure time. This class will be extended in follow up commits to snapshot all values in the cmState.
2015-04-11 18:38:16 +02:00
cmState: more members will use std::string
2020-01-01 08:00:00 -05:00
static cmStateEnums::CacheEntryType StringToCacheEntryType(
const std::string&);
static bool StringToCacheEntryType(const std::string&,
set: warn if CACHE type is not recognized
2019-01-28 21:06:38 -05:00
cmStateEnums::CacheEntryType& type);
cmState: more members will use std::string
2020-01-01 08:00:00 -05:00
static const std::string& CacheEntryTypeToString(
cmStateEnums::CacheEntryType);
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
static bool IsCacheEntryType(std::string const& key);
cmState: Add cache file manipulation wrappers.
2015-10-10 15:21:41 +02:00
bool LoadCache(const std::string& path, bool internal,
std::set<std::string>& excludes,
std::set<std::string>& includes);
cmCacheManager: Truncate values containing newlines Fixes #16098.
2018-01-09 15:56:40 -05:00
bool SaveCache(const std::string& path, cmMessenger* messenger);
cmState: Add cache file manipulation wrappers.
2015-10-10 15:21:41 +02:00
bool DeleteCache(const std::string& path);
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
std::vector<std::string> GetCacheEntryKeys() const;
const char* GetCacheEntryValue(std::string const& key) const;
Ninja Multi-Config: Use build.ninja if cmake --build has no --config If cmake --build is called with no --config argument, and a build.ninja file is available, use that instead of defaulting to the Debug config.
2020-02-04 11:06:46 -05:00
std::string GetSafeCacheEntryValue(std::string const& key) const;
cmState::GetInitializedCacheValue: Return as const std::string*
2018-09-10 09:31:48 -04:00
const std::string* GetInitializedCacheValue(std::string const& key) const;
cmState: Move CacheEntryType enum to separate namespace Port dependent code to the change.
2016-10-18 21:28:47 +02:00
cmStateEnums::CacheEntryType GetCacheEntryType(std::string const& key) const;
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
void SetCacheEntryValue(std::string const& key, std::string const& value);
void SetCacheValue(std::string const& key, std::string const& value);
void RemoveCacheEntry(std::string const& key);
void SetCacheEntryProperty(std::string const& key,
std::string const& propertyName,
std::string const& value);
void SetCacheEntryBoolProperty(std::string const& key,
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
std::string const& propertyName, bool value);
cmState: Expose list of properties of values in the cache
2016-06-10 10:10:07 +02:00
std::vector<std::string> GetCacheEntryPropertyList(std::string const& key);
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
const char* GetCacheEntryProperty(std::string const& key,
std::string const& propertyName);
bool GetCacheEntryPropertyAsBool(std::string const& key,
std::string const& propertyName);
void AppendCacheEntryProperty(std::string const& key,
const std::string& property,
const std::string& value,
bool asString = false);
void RemoveCacheEntryProperty(std::string const& key,
std::string const& propertyName);
Fix invalid ///! doxygen comment line starts In various places `///!` was used to start a comment line. This is not valid Doygen syntax. This patch replaces `///!` comment starts with `//!`.
2019-03-31 11:27:12 +02:00
//! Break up a line like VAR:type="value" into var, type and value
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
static bool ParseCacheEntry(const std::string& entry, std::string& var,
cmState: Move CacheEntryType enum to separate namespace Port dependent code to the change.
2016-10-18 21:28:47 +02:00
std::string& value,
cmStateEnums::CacheEntryType& type);
cmState: Move ParseCacheEntry from cmCacheManager.
2015-10-10 15:08:15 +02:00
cmState: Move Snapshot type to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 21:28:47 +02:00
cmStateSnapshot Reset();
Move property definition to cmState.
2015-04-04 23:33:26 +02:00
// Define a property
void DefineProperty(const std::string& name, cmProperty::ScopeType scope,
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
const char* ShortDescription,
const char* FullDescription, bool chain = false);
Move property definition to cmState.
2015-04-04 23:33:26 +02:00
// get property definition
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
cmPropertyDefinition const* GetPropertyDefinition(
const std::string& name, cmProperty::ScopeType scope) const;
Move property definition to cmState.
2015-04-04 23:33:26 +02:00
// Is a property defined?
Constify property definition API.
2015-06-06 09:46:38 +02:00
bool IsPropertyDefined(const std::string& name,
cmProperty::ScopeType scope) const;
bool IsPropertyChained(const std::string& name,
cmProperty::ScopeType scope) const;
Move property definition to cmState.
2015-04-04 23:33:26 +02:00
cmGlobalGenerator: Delegate storage of enabled languages to cmState.
2015-04-11 14:16:39 +02:00
void SetLanguageEnabled(std::string const& l);
bool GetLanguageEnabled(std::string const& l) const;
std::vector<std::string> GetEnabledLanguages() const;
cmGlobalGenerator: Finish storing enabled languages in cmState In commit 74de9a73 (cmGlobalGenerator: Delegate storage of enabled languages to cmState, 2015-04-11) the original LanguageEnabled member of cmGlobalGenerator was left behind by mistake. One use of it in EnableLanguagesFromGenerator (for try_compile) was left, but the member is not populated anymore. Drop the member and teach EnableLanguagesFromGenerator to copy the list of enabled languages from one cmState to the other. Reported-by: Matt McCormick <matt.mccormick@kitware.com>
2015-04-30 08:56:48 -04:00
void SetEnabledLanguages(std::vector<std::string> const& langs);
cmGlobalGenerator: Delegate storage of enabled languages to cmState.
2015-04-11 14:16:39 +02:00
void ClearEnabledLanguages();
Move property definition to cmState.
2015-04-04 23:33:26 +02:00
cmState: Move try_compile state from cmake class.
2015-04-11 12:16:54 +02:00
bool GetIsInTryCompile() const;
void SetIsInTryCompile(bool b);
Add GENERATOR_IS_MULTI_CONFIG global property Fixes: #16768
2017-04-03 18:47:32 +02:00
bool GetIsGeneratorMultiConfig() const;
void SetIsGeneratorMultiConfig(bool b);
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
using Command = std::function<bool(std::vector<cmListFileArgument> const&,
cmExecutionStatus&)>;
cmState: Support BuiltinCommands as free functions
2019-04-08 09:55:52 +02:00
using BuiltinCommand = bool (*)(std::vector<std::string> const&,
cmExecutionStatus&);
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
Revise implementation of case-insensitive command names Store both the as-written and lower-case command names and use the latter to avoid case-insensitive string comparisons. With this I obtain 2-6% speed increase (on Windows) for the configure step with no significant changes in memory usage. A case-insensitive comparison is a lot slower than just calling `==` because the operator will use things like memcmp, so prefer the latter. The `cmSystemTools::LowerCase` function allocates a new string each time it is called, so before this change we were allocating in: * cmMakefile::Configure two times for each function (to look for `cmake_minimum_required` and `project`) * cmMakefile::ExecuteCommand twice by function by calling cmState::GetCommand and copying the name Now we are only allocating once by function instead of four.
2018-05-01 16:17:31 +02:00
// Returns a command from its name, case insensitive, or nullptr
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
Command GetCommand(std::string const& name) const;
Revise implementation of case-insensitive command names Store both the as-written and lower-case command names and use the latter to avoid case-insensitive string comparisons. With this I obtain 2-6% speed increase (on Windows) for the configure step with no significant changes in memory usage. A case-insensitive comparison is a lot slower than just calling `==` because the operator will use things like memcmp, so prefer the latter. The `cmSystemTools::LowerCase` function allocates a new string each time it is called, so before this change we were allocating in: * cmMakefile::Configure two times for each function (to look for `cmake_minimum_required` and `project`) * cmMakefile::ExecuteCommand twice by function by calling cmState::GetCommand and copying the name Now we are only allocating once by function instead of four.
2018-05-01 16:17:31 +02:00
// Returns a command from its name, or nullptr
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
Command GetCommandByExactName(std::string const& name) const;
Revise implementation of case-insensitive command names Store both the as-written and lower-case command names and use the latter to avoid case-insensitive string comparisons. With this I obtain 2-6% speed increase (on Windows) for the configure step with no significant changes in memory usage. A case-insensitive comparison is a lot slower than just calling `==` because the operator will use things like memcmp, so prefer the latter. The `cmSystemTools::LowerCase` function allocates a new string each time it is called, so before this change we were allocating in: * cmMakefile::Configure two times for each function (to look for `cmake_minimum_required` and `project`) * cmMakefile::ExecuteCommand twice by function by calling cmState::GetCommand and copying the name Now we are only allocating once by function instead of four.
2018-05-01 16:17:31 +02:00
modernize: manage cmCommand instances using unique_ptr.
2019-07-04 18:14:22 +02:00
void AddBuiltinCommand(std::string const& name,
std::unique_ptr<cmCommand> command);
cmUnexpectedCommand: Replace with lambda expression
2019-04-07 20:40:59 +02:00
void AddBuiltinCommand(std::string const& name, Command command);
cmState: Support BuiltinCommands as free functions
2019-04-08 09:55:52 +02:00
void AddBuiltinCommand(std::string const& name, BuiltinCommand command);
cmState: Support free function disallowed commands
2019-08-13 13:42:59 +02:00
void AddDisallowedCommand(std::string const& name, BuiltinCommand command,
cmPolicies::PolicyID policy, const char* message);
cmState: introduce methods for adding builtin commands
2017-05-10 21:05:29 +02:00
void AddUnexpectedCommand(std::string const& name, const char* error);
cmState: Add scripted commands by value
2019-04-07 21:27:41 +02:00
void AddScriptedCommand(std::string const& name, Command command);
set_directory_properties: Restore in script mode Since commit v3.10.0-rc1~391^2~3 (Add directory property 'LABELS' and CMAKE_DIRECTORY_LABELS variable, 2017-06-23) this command was accidentally not allowed in script mode. It was dropped because `ctest -S` mode needs to start with CMake's normal script mode and then replace the `set_directory_properties` implementation. Restore the normal `set_directory_properties` in script mode and then add special logic to replace it in ctest. Also add a test case. Fixes: #18523
2018-10-29 11:15:10 -04:00
void RemoveBuiltinCommand(std::string const& name);
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 12:30:26 +02:00
void RemoveUserDefinedCommands();
std::vector<std::string> GetCommandNames() const;
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
void SetGlobalProperty(const std::string& prop, const char* value);
AppendProperty: convert value param to std::string
2020-01-25 10:37:00 -05:00
void AppendGlobalProperty(const std::string& prop, const std::string& value,
Revise C++ coding style using clang-format Run the `Utilities/Scripts/clang-format.bash` script to update all our C++ code to a new style defined by `.clang-format`. Use `clang-format` version 3.8. * If you reached this commit for a line in `git blame`, re-run the blame operation starting at the parent of this commit to see older history for the content. * See the parent commit for instructions to rebase a change across this style transition commit.
2016-05-16 10:34:04 -04:00
bool asString = false);
const char* GetGlobalProperty(const std::string& prop);
Move global properties to cmState.
2015-04-11 14:17:46 +02:00
bool GetGlobalPropertyAsBool(const std::string& prop);
Reduce raw string pointers usage. * Change some functions to take `std::string` instead of `const char*` in the following classes: `cmMakeFile`, `cmake`, `cmCoreTryCompile`, `cmSystemTools`, `cmState`, `cmLocalGenerator` and a few others. * Greatly reduce using of `const char*` overloads for `cmSystemTools::MakeDirectory` and `cmSystemTools::RelativePath`. * Remove many redundant `c_str()` conversions throughout the code.
2018-01-31 18:20:02 +03:00
std::string const& GetSourceDirectory() const;
cmState: Store the Source and Binary directories.
2015-04-12 15:26:54 +02:00
void SetSourceDirectory(std::string const& sourceDirectory);
Reduce raw string pointers usage. * Change some functions to take `std::string` instead of `const char*` in the following classes: `cmMakeFile`, `cmake`, `cmCoreTryCompile`, `cmSystemTools`, `cmState`, `cmLocalGenerator` and a few others. * Greatly reduce using of `const char*` overloads for `cmSystemTools::MakeDirectory` and `cmSystemTools::RelativePath`. * Remove many redundant `c_str()` conversions throughout the code.
2018-01-31 18:20:02 +03:00
std::string const& GetBinaryDirectory() const;
cmState: Store the Source and Binary directories.
2015-04-12 15:26:54 +02:00
void SetBinaryDirectory(std::string const& binaryDirectory);
cmState: Host some state from the cmGlobalGenerator.
2015-05-24 11:46:30 +02:00
void SetWindowsShell(bool windowsShell);
bool UseWindowsShell() const;
void SetWindowsVSIDE(bool windowsVSIDE);
bool UseWindowsVSIDE() const;
GHS: try_compile() now uses GHS platform variables -- Forward GHS platform variables to try_compile() CMAKE_TRY_COMPILE_PLATFORM_VARIABLES only worked for source signature try_compile() -- Update tests to no longer add GHS platform variables to try_compile() -- Avoid linker error in GhsMulti/GhsMultiCompilerOptions/CMakeLists.txt by building library
2019-01-08 23:52:12 -05:00
void SetGhsMultiIDE(bool ghsMultiIDE);
bool UseGhsMultiIDE() const;
cmState: Host some state from the cmGlobalGenerator.
2015-05-24 11:46:30 +02:00
void SetWatcomWMake(bool watcomWMake);
bool UseWatcomWMake() const;
void SetMinGWMake(bool minGWMake);
bool UseMinGWMake() const;
void SetNMake(bool nMake);
bool UseNMake() const;
void SetMSYSShell(bool mSYSShell);
bool UseMSYSShell() const;
Ninja: Add multi-config variant Co-Authored-by: vector-of-bool <vectorofbool@gmail.com>
2019-11-15 13:01:36 -05:00
void SetNinjaMulti(bool ninjaMulti);
bool UseNinjaMulti() const;
cmState: Host some state from the cmGlobalGenerator.
2015-05-24 11:46:30 +02:00
cmState: Add API for cache version.
2015-10-10 14:34:26 +02:00
unsigned int GetCacheMajorVersion() const;
unsigned int GetCacheMinorVersion() const;
Properties: Add CMAKE_ROLE global property This property allows scripts to determine whether they're in project mode, script mode, find-package mode, CTest, or CPack.
2019-01-14 12:27:14 -05:00
Mode GetMode() const;
std::string GetModeString() const;
void SetMode(Mode mode);
static std::string ModeToString(Mode mode);
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
private:
cmState: Make AddCacheEntry method private.
2015-10-10 15:05:50 +02:00
friend class cmake;
void AddCacheEntry(const std::string& key, const char* value,
cmState: Move CacheEntryType enum to separate namespace Port dependent code to the change.
2016-10-18 21:28:47 +02:00
const char* helpString,
cmStateEnums::CacheEntryType type);
cmState: Make AddCacheEntry method private.
2015-10-10 15:05:50 +02:00
Add cmGlobVerificationManager class, integrate with cmake and cmState
2018-02-14 11:26:35 -05:00
bool DoWriteGlobVerifyTarget() const;
std::string const& GetGlobVerifyScript() const;
std::string const& GetGlobVerifyStamp() const;
bool SaveVerificationScript(const std::string& path);
void AddGlobCacheEntry(bool recurse, bool listDirectories,
bool followSymlinks, const std::string& relative,
const std::string& expression,
const std::vector<std::string>& files,
const std::string& variable,
cmListFileBacktrace const& bt);
Move property definition to cmState.
2015-04-04 23:33:26 +02:00
std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions;
cmGlobalGenerator: Delegate storage of enabled languages to cmState.
2015-04-11 14:16:39 +02:00
std::vector<std::string> EnabledLanguages;
cmState: Hold commands by value
2019-04-07 20:18:32 +02:00
std::map<std::string, Command> BuiltinCommands;
std::map<std::string, Command> ScriptedCommands;
Move global properties to cmState.
2015-04-11 14:17:46 +02:00
cmPropertyMap GlobalProperties;
modermize: replace some raw pointers w/ `unique_ptr`
2019-06-21 03:41:48 +03:00
std::unique_ptr<cmCacheManager> CacheManager;
std::unique_ptr<cmGlobVerificationManager> GlobVerificationManager;
cmState: Compute and store directory components. There is no need to duplicate these in all cmLocalGenerators. Rename the symbols according to current conventions. Add explicit calls to Set{Source,Binary}Directory with empty strings in order to trigger the population of the components containers with the current working directory in cmLocalGenerator. Having directories set to empty is a special case in CMake, which is relied on for the `if(CMAKE_BINARY_DIR)` condition at the end of CMakeDetermineSystem.cmake.
2015-05-04 23:01:29 +02:00
cmState: Move nested struct into separate top-level namespace Add a friend declaration to give the struct access to cmState::PositionType. This will be removed when that type is also extracted.
2016-10-18 21:28:45 +02:00
cmLinkedTree<cmStateDetail::BuildsystemDirectoryStateType>
BuildsystemDirectory;
cmState: Group BuildsystemDirectory state together in a struct. It needs to be snapshotted independently of other state.
2015-05-23 10:37:07 +02:00
cmState: Store execution context. Extend snapshot creation API to store the file being executed and the entry point to get to that context.
2015-05-31 19:37:08 +02:00
cmLinkedTree<std::string> ExecutionListFiles;
cmState: Move PolicyStackEntry to separate namespace
2016-10-18 21:28:45 +02:00
cmLinkedTree<cmStateDetail::PolicyStackEntry> PolicyStack;
cmState: Move SnapshotDataType to separate namespace
2016-10-18 21:28:45 +02:00
cmLinkedTree<cmStateDetail::SnapshotDataType> SnapshotData;
cmState: Host variable definitions.
2015-06-21 21:26:43 +02:00
cmLinkedTree<cmDefinitions> VarTree;
cmState::Snapshot: Store components for current directories. Remove this responsibility from cmLocalGenerator.
2015-05-04 23:08:19 +02:00
cmState: Store the Source and Binary directories.
2015-04-12 15:26:54 +02:00
std::string SourceDirectory;
std::string BinaryDirectory;
clang-tidy: Use default member initialization
2018-11-21 23:17:54 +01:00
bool IsInTryCompile = false;
bool IsGeneratorMultiConfig = false;
bool WindowsShell = false;
bool WindowsVSIDE = false;
GHS: try_compile() now uses GHS platform variables -- Forward GHS platform variables to try_compile() CMAKE_TRY_COMPILE_PLATFORM_VARIABLES only worked for source signature try_compile() -- Update tests to no longer add GHS platform variables to try_compile() -- Avoid linker error in GhsMulti/GhsMultiCompilerOptions/CMakeLists.txt by building library
2019-01-08 23:52:12 -05:00
bool GhsMultiIDE = false;
clang-tidy: Use default member initialization
2018-11-21 23:17:54 +01:00
bool WatcomWMake = false;
bool MinGWMake = false;
bool NMake = false;
bool MSYSShell = false;
Ninja: Add multi-config variant Co-Authored-by: vector-of-bool <vectorofbool@gmail.com>
2019-11-15 13:01:36 -05:00
bool NinjaMulti = false;
Properties: Add CMAKE_ROLE global property This property allows scripts to determine whether they're in project mode, script mode, find-package mode, CTest, or CPack.
2019-01-14 12:27:14 -05:00
Mode CurrentMode = Unknown;
Introduce cmState class. At this point, it is an interface to the cache. It will be extended to be a universal interface for access to and manipulation of configuration-time data (defintions, properties on targets, directories, source files etc). This will allow porting all command implementations away from the cmMakefile and cmTarget classes, and result in something more-purely related to configuration-time processing of cmake commands. That should serve at least the following goals: * Split the CMake implementation more definitively into three stages: Configuration, computation and generation, and be able to implement each optimally for memory access patterns etc. * Make better IDE integration possible by making more configuration data available. * Make it possiblte to use a smaller library than CMakeLib.a in cpack and ctest, resulting in smaller executables. * Make it possible to run the configure step multiple times in the same CMake run (#14539). Manage its lifetime in the cmake class, and add a convenience accessor to cmMakefile.
2015-04-04 21:20:12 +02:00
};
#endif
Reference in New Issue Copy Permalink