mirror of
https://github.com/reactos/CMake.git
synced 2025-05-13 18:15:53 +00:00
e268840c0a
- The `cmDefinitions::Def` struct is simplified by removing an unused constructor and the `std_string` type definition. The std::string value becomes a member variable instead of being derived from. - The `cmDefinitions::Unset` method is added that unsets a definition. It has the same functionality as calling `cmDefinitions::Set` with a `nullptr` value argument, - The `cmDefinitions::Set` method gets an overloaded version that takes a `cm::string_view` as value argument. - The originl `cmDefinitions::Set` method with `const char*` argument is refactored to either call the `cm::string_view` based `cmDefinitions::Set` overload or `cmDefinitions::Unset`, depending on whether the value `const char*` is a nullptr (`Unset`) or not (`Set`).
121 lines
3.1 KiB
C++
121 lines
3.1 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmDefinitions.h"
|
|
|
|
#include <assert.h>
|
|
#include <set>
|
|
#include <utility>
|
|
|
|
cmDefinitions::Def cmDefinitions::NoDef;
|
|
|
|
cmDefinitions::Def const& cmDefinitions::GetInternal(const std::string& key,
|
|
StackIter begin,
|
|
StackIter end, bool raise)
|
|
{
|
|
assert(begin != end);
|
|
{
|
|
MapType::iterator it = begin->Map.find(key);
|
|
if (it != begin->Map.end()) {
|
|
it->second.Used = true;
|
|
return it->second;
|
|
}
|
|
}
|
|
StackIter it = begin;
|
|
++it;
|
|
if (it == end) {
|
|
return cmDefinitions::NoDef;
|
|
}
|
|
Def const& def = cmDefinitions::GetInternal(key, it, end, raise);
|
|
if (!raise) {
|
|
return def;
|
|
}
|
|
return begin->Map.emplace(key, def).first->second;
|
|
}
|
|
|
|
const std::string* cmDefinitions::Get(const std::string& key, StackIter begin,
|
|
StackIter end)
|
|
{
|
|
Def const& def = cmDefinitions::GetInternal(key, begin, end, false);
|
|
return def.Exists ? &def.Value : nullptr;
|
|
}
|
|
|
|
void cmDefinitions::Raise(const std::string& key, StackIter begin,
|
|
StackIter end)
|
|
{
|
|
cmDefinitions::GetInternal(key, begin, end, true);
|
|
}
|
|
|
|
bool cmDefinitions::HasKey(const std::string& key, StackIter begin,
|
|
StackIter end)
|
|
{
|
|
for (StackIter it = begin; it != end; ++it) {
|
|
if (it->Map.find(key) != it->Map.end()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void cmDefinitions::Set(const std::string& key, cm::string_view value)
|
|
{
|
|
this->Map[key] = Def(value);
|
|
}
|
|
|
|
void cmDefinitions::Unset(const std::string& key)
|
|
{
|
|
this->Map[key] = Def();
|
|
}
|
|
|
|
std::vector<std::string> cmDefinitions::UnusedKeys() const
|
|
{
|
|
std::vector<std::string> keys;
|
|
keys.reserve(this->Map.size());
|
|
// Consider local definitions.
|
|
for (auto const& mi : this->Map) {
|
|
if (!mi.second.Used) {
|
|
keys.push_back(mi.first);
|
|
}
|
|
}
|
|
return keys;
|
|
}
|
|
|
|
cmDefinitions cmDefinitions::MakeClosure(StackIter begin, StackIter end)
|
|
{
|
|
cmDefinitions closure;
|
|
std::set<std::string> undefined;
|
|
for (StackIter it = begin; it != end; ++it) {
|
|
// Consider local definitions.
|
|
for (auto const& mi : it->Map) {
|
|
// Use this key if it is not already set or unset.
|
|
if (closure.Map.find(mi.first) == closure.Map.end() &&
|
|
undefined.find(mi.first) == undefined.end()) {
|
|
if (mi.second.Exists) {
|
|
closure.Map.insert(mi);
|
|
} else {
|
|
undefined.insert(mi.first);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return closure;
|
|
}
|
|
|
|
std::vector<std::string> cmDefinitions::ClosureKeys(StackIter begin,
|
|
StackIter end)
|
|
{
|
|
std::vector<std::string> defined;
|
|
std::set<std::string> bound;
|
|
|
|
for (StackIter it = begin; it != end; ++it) {
|
|
defined.reserve(defined.size() + it->Map.size());
|
|
for (auto const& mi : it->Map) {
|
|
// Use this key if it is not already set or unset.
|
|
if (bound.insert(mi.first).second && mi.second.Exists) {
|
|
defined.push_back(mi.first);
|
|
}
|
|
}
|
|
}
|
|
|
|
return defined;
|
|
}
|