reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-12-14 15:19:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
594dd9b36a
CMake/Source/cmDefinitions.h

87 lines
2.7 KiB
C
Raw Normal View History

Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 15:43:28 +00:00
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 15:43:28 +00:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 15:43:28 +00:00
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.
============================================================================*/
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
#ifndef cmDefinitions_h
#define cmDefinitions_h
#include "cmStandardIncludes.h"
cmDefinitions: Use a hashmap for faster checks The hash map is much faster at checking that the map won't have what we're looking for so that we can just go to the parent scope instead.
2014-03-12 05:48:06 +00:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
Use std::unordered_map instead of hash_map where available.
2015-05-16 04:57:53 +00:00
#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
#include <unordered_map>
#else
cmDefinitions: Use a hashmap for faster checks The hash map is much faster at checking that the map won't have what we're looking for so that we can just go to the parent scope instead.
2014-03-12 05:48:06 +00:00
#include "cmsys/hash_map.hxx"
#endif
Use std::unordered_map instead of hash_map where available.
2015-05-16 04:57:53 +00:00
#endif
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
cmDefinitions: Implement MakeClosure in terms of a list of ancestors.
2015-04-26 14:00:18 +00:00
#include <list>
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
/** \class cmDefinitions
* \brief Store a scope of variable definitions for CMake language.
*
* This stores the state of variable definitions (set or unset) for
* one scope. Sets are always local. Gets search parent scopes
* transitively and save results locally.
*/
class cmDefinitions
{
cmDefinitions: Centralize knowledge of iterator type. Currently we process a list of definitions, but that will change.
2015-05-16 03:33:25 +00:00
typedef std::list<cmDefinitions>::reverse_iterator StackIter;
typedef std::list<cmDefinitions>::const_reverse_iterator StackConstIter;
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
public:
Revert "cmDefinitions: Don't store parent lookups" This reverts commit 5abfde6cb8a1ae0b2825797eab6c2e9842eb7c49. The behaviors associated with implicit pulldown on variable lookup seriously conflict with the optimizations made in these commits. Basically, since values were copied upon variable lookup, not just on PARENT_SCOPE, coupled with PARENT_SCOPE's behavior based on whether the variable is in the current scope or not causes serious problems with not storing a value for every variable at every scope. The commit changed behavior of the following example, among other cases: function(test_set) set(blah "value2") message("before PARENT_SCOPE blah=${blah}") set(blah ${blah} PARENT_SCOPE) message("after PARENT_SCOPE blah=${blah}") endfunction() set(blah value1) test_set() message("in parent scope, blah=${blah}") Reported-by: Alex Merry <alex.merry@kde.org> Reported-by: Ben Cooksley <bcooksley@kde.org>
2014-10-24 16:58:12 +00:00
/** Get the value associated with a key; null if none.
Store the result locally if it came from a parent. */
cmDefinitions: Make Get method static.
2015-04-30 23:50:45 +00:00
static const char* Get(const std::string& key,
cmDefinitions: Centralize knowledge of iterator type. Currently we process a list of definitions, but that will change.
2015-05-16 03:33:25 +00:00
StackIter begin, StackIter end);
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
/** Set (or unset if null) a value associated with a key. */
cmDefinitions: Remove unused Set return value.
2015-04-25 14:29:54 +00:00
void Set(const std::string& key, const char* value);
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
cmDefinitions: Add an Erase method.
2015-04-25 14:33:26 +00:00
void Erase(const std::string& key);
Add method to get the local scope variables
2010-08-24 18:40:51 +00:00
/** Get the set of all local keys. */
cmDefinitions: Change LocalKeys to return a vector. This is more efficient and we lose nothing.
2015-04-26 14:34:13 +00:00
std::vector<std::string> LocalKeys() const;
Add method to get the local scope variables
2010-08-24 18:40:51 +00:00
cmDefinitions: Make the ClosureKeys method static. For consistency with all other closure-related methods.
2015-05-16 03:33:30 +00:00
static std::vector<std::string> ClosureKeys(StackConstIter begin,
StackConstIter end);
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
cmDefinitions: Centralize knowledge of iterator type. Currently we process a list of definitions, but that will change.
2015-05-16 03:33:25 +00:00
static cmDefinitions MakeClosure(StackConstIter begin, StackConstIter end);
cmDefinitions: Replace private constructor with MakeClosure.
2015-04-26 13:44:26 +00:00
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
private:
// String with existence boolean.
strings: Remove cmStdString references Casts from std::string -> cmStdString were high on the list of things taking up time. Avoid such implicit casts across function calls by just using std::string everywhere. The comment that the symbol name is too long is no longer relevant since modern debuggers alias the templates anyways and the size is a non-issue since the underlying methods are generated since it's inherited.
2014-02-10 05:21:34 +00:00
struct Def: public std::string
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
{
strings: Remove cmStdString references Casts from std::string -> cmStdString were high on the list of things taking up time. Avoid such implicit casts across function calls by just using std::string everywhere. The comment that the symbol name is too long is no longer relevant since modern debuggers alias the templates anyways and the size is a non-issue since the underlying methods are generated since it's inherited.
2014-02-10 05:21:34 +00:00
private:
typedef std::string std_string;
public:
Def(): std_string(), Exists(false) {}
Def(const char* v): std_string(v?v:""), Exists(v?true:false) {}
stringapi: Add string overload for the Def struct
2014-02-22 00:06:54 +00:00
Def(const std_string& v): std_string(v), Exists(true) {}
strings: Remove cmStdString references Casts from std::string -> cmStdString were high on the list of things taking up time. Avoid such implicit casts across function calls by just using std::string everywhere. The comment that the symbol name is too long is no longer relevant since modern debuggers alias the templates anyways and the size is a non-issue since the underlying methods are generated since it's inherited.
2014-02-10 05:21:34 +00:00
Def(Def const& d): std_string(d), Exists(d.Exists) {}
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
bool Exists;
};
static Def NoDef;
cmDefinitions: Use a hashmap for faster checks The hash map is much faster at checking that the map won't have what we're looking for so that we can just go to the parent scope instead.
2014-03-12 05:48:06 +00:00
#if defined(CMAKE_BUILD_WITH_CMAKE)
Use std::unordered_map instead of hash_map where available.
2015-05-16 04:57:53 +00:00
#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
typedef std::unordered_map<std::string, Def> MapType;
#else
cmDefinitions: Use a hashmap for faster checks The hash map is much faster at checking that the map won't have what we're looking for so that we can just go to the parent scope instead.
2014-03-12 05:48:06 +00:00
typedef cmsys::hash_map<std::string, Def> MapType;
Use std::unordered_map instead of hash_map where available.
2015-05-16 04:57:53 +00:00
#endif
cmDefinitions: Use a hashmap for faster checks The hash map is much faster at checking that the map won't have what we're looking for so that we can just go to the parent scope instead.
2014-03-12 05:48:06 +00:00
#else
strings: Remove cmStdString references Casts from std::string -> cmStdString were high on the list of things taking up time. Avoid such implicit casts across function calls by just using std::string everywhere. The comment that the symbol name is too long is no longer relevant since modern debuggers alias the templates anyways and the size is a non-issue since the underlying methods are generated since it's inherited.
2014-02-10 05:21:34 +00:00
typedef std::map<std::string, Def> MapType;
cmDefinitions: Use a hashmap for faster checks The hash map is much faster at checking that the map won't have what we're looking for so that we can just go to the parent scope instead.
2014-03-12 05:48:06 +00:00
#endif
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
MapType Map;
cmDefinitions: Make GetInternal method static. For some reason, using recursion here is faster to configure ParaView than using a loop. Probably some compiler optimization is inhibited by using a loop. Co-Author: Brad King <brad.king@kitware.com>
2015-04-30 23:13:38 +00:00
static Def const& GetInternal(const std::string& key,
cmDefinitions: Centralize knowledge of iterator type. Currently we process a list of definitions, but that will change.
2015-05-16 03:33:25 +00:00
StackIter begin, StackIter end);
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 18:22:45 +00:00
};
#endif
Reference in New Issue Copy Permalink