reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-24 12:09:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
26ee9e4291
CMake/Source/cmState.h

190 lines
7.1 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 19:01:08 +00: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 19:20:12 +00:00
#ifndef cmState_h
#define cmState_h
fix a batch of include-what-you-use violations
2016-08-16 23:08:13 +00: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 13:40:20 +00:00
Fix several include-what-you-use findings
2016-11-05 20:40:14 +00:00
#include <map>
#include <set>
#include <string>
#include <vector>
fix a batch of include-what-you-use violations
2016-08-16 23:08:13 +00: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 14:53:13 +00:00
#include "cmLinkedTree.h"
fix a batch of include-what-you-use violations
2016-08-16 23:08:13 +00: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 14:53:13 +00:00
#include "cmPropertyDefinitionMap.h"
#include "cmPropertyMap.h"
Fix several include-what-you-use findings
2016-11-05 20:40:14 +00:00
#include "cmStatePrivate.h"
cmState: Move extracted declarations to a separate file
2016-10-18 19:28:48 +00: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 19:20:12 +00:00
fix a batch of include-what-you-use violations
2016-08-16 23:08:13 +00:00
class cmCacheManager;
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 10:30:26 +00:00
class cmCommand;
fix a batch of include-what-you-use violations
2016-08-16 23:08:13 +00: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 19:28:47 +00:00
class cmStateSnapshot;
cmState: Move Directory class to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 19:28:47 +00: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 19:20:12 +00: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 19:28:47 +00: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 14:34:04 +00: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 19:20:12 +00:00
public:
cmState: Port away from cmake instance.
2015-10-10 13:42:02 +00:00
cmState();
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 10:30:26 +00: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 19:20:12 +00:00
cmState: Move TargetType enum to separate namespace
2016-10-18 19:28:46 +00:00
static const char* GetTargetTypeName(cmStateEnums::TargetType targetType);
cmState: Move GetTargetTypeName from cmTarget.
2015-10-07 22:26:50 +00:00
cmState: Move Snapshot type to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 19:28:47 +00:00
cmStateSnapshot CreateBaseSnapshot();
cmStateSnapshot CreateBuildsystemDirectorySnapshot(
cmStateSnapshot originSnapshot);
cmStateSnapshot CreateFunctionCallSnapshot(cmStateSnapshot originSnapshot,
std::string const& fileName);
cmStateSnapshot CreateMacroCallSnapshot(cmStateSnapshot originSnapshot,
std::string const& fileName);
cmStateSnapshot CreateIncludeFileSnapshot(cmStateSnapshot originSnapshot,
std::string const& fileName);
cmStateSnapshot CreateVariableScopeSnapshot(cmStateSnapshot originSnapshot);
cmStateSnapshot CreateInlineListFileSnapshot(cmStateSnapshot originSnapshot,
std::string const& fileName);
cmStateSnapshot CreatePolicyScopeSnapshot(cmStateSnapshot originSnapshot);
cmStateSnapshot Pop(cmStateSnapshot 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 16:38:16 +00:00
cmState: Move CacheEntryType enum to separate namespace Port dependent code to the change.
2016-10-18 19:28:47 +00:00
static cmStateEnums::CacheEntryType StringToCacheEntryType(const char*);
static const char* 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 19:20:12 +00:00
static bool IsCacheEntryType(std::string const& key);
cmState: Add cache file manipulation wrappers.
2015-10-10 13:21:41 +00:00
bool LoadCache(const std::string& path, bool internal,
std::set<std::string>& excludes,
std::set<std::string>& includes);
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 14:34:04 +00:00
bool SaveCache(const std::string& path);
cmState: Add cache file manipulation wrappers.
2015-10-10 13:21:41 +00: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 19:20:12 +00:00
std::vector<std::string> GetCacheEntryKeys() const;
const char* GetCacheEntryValue(std::string const& key) const;
const char* GetInitializedCacheValue(std::string const& key) const;
cmState: Move CacheEntryType enum to separate namespace Port dependent code to the change.
2016-10-18 19:28:47 +00: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 19:20:12 +00: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 14:34:04 +00:00
std::string const& propertyName, bool value);
cmState: Expose list of properties of values in the cache
2016-06-10 08:10:07 +00: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 19:20:12 +00: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);
cmState: Move ParseCacheEntry from cmCacheManager.
2015-10-10 13:08:15 +00: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 14:34:04 +00: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 19:28:47 +00:00
std::string& value,
cmStateEnums::CacheEntryType& type);
cmState: Move ParseCacheEntry from cmCacheManager.
2015-10-10 13:08:15 +00:00
cmState: Move Snapshot type to separate namespace Leave behind a typedef to avoid porting dependent code in this commit.
2016-10-18 19:28:47 +00:00
cmStateSnapshot Reset();
Move property definition to cmState.
2015-04-04 21:33:26 +00: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 14:34:04 +00:00
const char* ShortDescription,
const char* FullDescription, bool chain = false);
Move property definition to cmState.
2015-04-04 21:33:26 +00: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 14:34:04 +00:00
cmPropertyDefinition const* GetPropertyDefinition(
const std::string& name, cmProperty::ScopeType scope) const;
Move property definition to cmState.
2015-04-04 21:33:26 +00:00
// Is a property defined?
Constify property definition API.
2015-06-06 07:46:38 +00: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 21:33:26 +00:00
cmGlobalGenerator: Delegate storage of enabled languages to cmState.
2015-04-11 12:16:39 +00: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 12:56:48 +00:00
void SetEnabledLanguages(std::vector<std::string> const& langs);
cmGlobalGenerator: Delegate storage of enabled languages to cmState.
2015-04-11 12:16:39 +00:00
void ClearEnabledLanguages();
Move property definition to cmState.
2015-04-04 21:33:26 +00:00
cmState: Move try_compile state from cmake class.
2015-04-11 10:16:54 +00:00
bool GetIsInTryCompile() const;
void SetIsInTryCompile(bool b);
Add GENERATOR_IS_MULTI_CONFIG global property Fixes: #16768
2017-04-03 16:47:32 +00:00
bool GetIsGeneratorMultiConfig() const;
void SetIsGeneratorMultiConfig(bool b);
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 10:30:26 +00:00
cmCommand* GetCommand(std::string const& name) const;
void AddCommand(cmCommand* command);
void RemoveUnscriptableCommands();
void RenameCommand(std::string const& oldName, std::string const& newName);
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 14:34:04 +00:00
void SetGlobalProperty(const std::string& prop, const char* value);
void AppendGlobalProperty(const std::string& prop, const char* value,
bool asString = false);
const char* GetGlobalProperty(const std::string& prop);
Move global properties to cmState.
2015-04-11 12:17:46 +00:00
bool GetGlobalPropertyAsBool(const std::string& prop);
cmState: Store the Source and Binary directories.
2015-04-12 13:26:54 +00:00
const char* GetSourceDirectory() const;
void SetSourceDirectory(std::string const& sourceDirectory);
const char* GetBinaryDirectory() const;
void SetBinaryDirectory(std::string const& binaryDirectory);
cmState: Host some state from the cmGlobalGenerator.
2015-05-24 09:46:30 +00:00
void SetWindowsShell(bool windowsShell);
bool UseWindowsShell() const;
void SetWindowsVSIDE(bool windowsVSIDE);
bool UseWindowsVSIDE() const;
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;
cmState: Add API for cache version.
2015-10-10 12:34:26 +00:00
unsigned int GetCacheMajorVersion() const;
unsigned int GetCacheMinorVersion() 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 19:20:12 +00:00
private:
cmState: Make AddCacheEntry method private.
2015-10-10 13:05:50 +00: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 19:28:47 +00:00
const char* helpString,
cmStateEnums::CacheEntryType type);
cmState: Make AddCacheEntry method private.
2015-10-10 13:05:50 +00:00
Move property definition to cmState.
2015-04-04 21:33:26 +00:00
std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions;
cmGlobalGenerator: Delegate storage of enabled languages to cmState.
2015-04-11 12:16:39 +00:00
std::vector<std::string> EnabledLanguages;
cmState: Move cmCommand-related methods from cmake class.
2015-04-11 10:30:26 +00:00
std::map<std::string, cmCommand*> Commands;
Move global properties to cmState.
2015-04-11 12:17:46 +00:00
cmPropertyMap GlobalProperties;
cmState: Port away from cmake instance.
2015-10-10 13:42:02 +00:00
cmCacheManager* CacheManager;
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 21:01:29 +00: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 19:28:45 +00: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 08:37:07 +00: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 17:37:08 +00:00
cmLinkedTree<std::string> ExecutionListFiles;
cmState: Move PolicyStackEntry to separate namespace
2016-10-18 19:28:45 +00:00
cmLinkedTree<cmStateDetail::PolicyStackEntry> PolicyStack;
cmState: Move SnapshotDataType to separate namespace
2016-10-18 19:28:45 +00:00
cmLinkedTree<cmStateDetail::SnapshotDataType> SnapshotData;
cmState: Host variable definitions.
2015-06-21 19:26:43 +00:00
cmLinkedTree<cmDefinitions> VarTree;
cmState::Snapshot: Store components for current directories. Remove this responsibility from cmLocalGenerator.
2015-05-04 21:08:19 +00:00
cmState: Store the Source and Binary directories.
2015-04-12 13:26:54 +00:00
std::string SourceDirectory;
std::string BinaryDirectory;
cmState: Move try_compile state from cmake class.
2015-04-11 10:16:54 +00:00
bool IsInTryCompile;
Add GENERATOR_IS_MULTI_CONFIG global property Fixes: #16768
2017-04-03 16:47:32 +00:00
bool IsGeneratorMultiConfig;
cmState: Host some state from the cmGlobalGenerator.
2015-05-24 09:46:30 +00:00
bool WindowsShell;
bool WindowsVSIDE;
bool WatcomWMake;
bool MinGWMake;
bool NMake;
bool MSYSShell;
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 19:20:12 +00:00
};
#endif
Reference in New Issue Copy Permalink