Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/lldb/DataFormatters/CXXFunctionPointer.h b/linux-x64/clang/include/lldb/DataFormatters/CXXFunctionPointer.h
index b541789..e9742bc 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/CXXFunctionPointer.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/CXXFunctionPointer.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_CXXFunctionPointer_h_
-#define liblldb_CXXFunctionPointer_h_
+#ifndef LLDB_DATAFORMATTERS_CXXFUNCTIONPOINTER_H
+#define LLDB_DATAFORMATTERS_CXXFUNCTIONPOINTER_H
#include "lldb/lldb-forward.h"
@@ -18,4 +18,4 @@
} // namespace formatters
} // namespace lldb_private
-#endif // liblldb_CXXFunctionPointer_h_
+#endif // LLDB_DATAFORMATTERS_CXXFUNCTIONPOINTER_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/DataVisualization.h b/linux-x64/clang/include/lldb/DataFormatters/DataVisualization.h
index cdb2eab..7be07d6 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/DataVisualization.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/DataVisualization.h
@@ -6,9 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_DataVisualization_h_
-#define lldb_DataVisualization_h_
-
+#ifndef LLDB_DATAFORMATTERS_DATAVISUALIZATION_H
+#define LLDB_DATAFORMATTERS_DATAVISUALIZATION_H
#include "lldb/DataFormatters/FormatClasses.h"
#include "lldb/DataFormatters/FormatManager.h"
@@ -51,12 +50,6 @@
static lldb::SyntheticChildrenSP
GetSyntheticChildren(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
- static lldb::TypeValidatorImplSP
- GetValidator(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
-
- static lldb::TypeValidatorImplSP
- GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
-
static bool
AnyMatches(ConstString type_name,
TypeCategoryImpl::FormatCategoryItems items =
@@ -76,9 +69,9 @@
static void Clear();
- static void
- ForEach(std::function<bool(ConstString, const lldb::TypeSummaryImplSP &)>
- callback);
+ static void ForEach(std::function<bool(const TypeMatcher &,
+ const lldb::TypeSummaryImplSP &)>
+ callback);
static uint32_t GetCount();
};
@@ -128,4 +121,4 @@
} // namespace lldb_private
-#endif // lldb_DataVisualization_h_
+#endif // LLDB_DATAFORMATTERS_DATAVISUALIZATION_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/DumpValueObjectOptions.h b/linux-x64/clang/include/lldb/DataFormatters/DumpValueObjectOptions.h
index c374115..2f3bdf8 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/DumpValueObjectOptions.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/DumpValueObjectOptions.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_DumpValueObjectOptions_h_
-#define lldb_DumpValueObjectOptions_h_
+#ifndef LLDB_DATAFORMATTERS_DUMPVALUEOBJECTOPTIONS_H
+#define LLDB_DATAFORMATTERS_DUMPVALUEOBJECTOPTIONS_H
#include <string>
@@ -127,7 +127,6 @@
DumpValueObjectOptions &
SetPointerAsArray(const PointerAsArraySettings &ptr_array);
-public:
uint32_t m_max_depth = UINT32_MAX;
lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
uint32_t m_omit_summary_depth = 0;
@@ -157,4 +156,4 @@
} // namespace lldb_private
-#endif // lldb_DumpValueObjectOptions_h_
+#endif // LLDB_DATAFORMATTERS_DUMPVALUEOBJECTOPTIONS_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/FormatCache.h b/linux-x64/clang/include/lldb/DataFormatters/FormatCache.h
index 7a6774b..e75aaee 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/FormatCache.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/FormatCache.h
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_FormatCache_h_
-#define lldb_FormatCache_h_
+#ifndef LLDB_DATAFORMATTERS_FORMATCACHE_H
+#define LLDB_DATAFORMATTERS_FORMATCACHE_H
#include <map>
#include <mutex>
@@ -24,77 +24,43 @@
bool m_format_cached : 1;
bool m_summary_cached : 1;
bool m_synthetic_cached : 1;
- bool m_validator_cached : 1;
lldb::TypeFormatImplSP m_format_sp;
lldb::TypeSummaryImplSP m_summary_sp;
lldb::SyntheticChildrenSP m_synthetic_sp;
- lldb::TypeValidatorImplSP m_validator_sp;
public:
Entry();
- Entry(lldb::TypeFormatImplSP);
- Entry(lldb::TypeSummaryImplSP);
- Entry(lldb::SyntheticChildrenSP);
- Entry(lldb::TypeValidatorImplSP);
- Entry(lldb::TypeFormatImplSP, lldb::TypeSummaryImplSP,
- lldb::SyntheticChildrenSP, lldb::TypeValidatorImplSP);
+ template<typename ImplSP> bool IsCached();
bool IsFormatCached();
-
bool IsSummaryCached();
-
bool IsSyntheticCached();
- bool IsValidatorCached();
+ void Get(lldb::TypeFormatImplSP &);
+ void Get(lldb::TypeSummaryImplSP &);
+ void Get(lldb::SyntheticChildrenSP &);
- lldb::TypeFormatImplSP GetFormat();
-
- lldb::TypeSummaryImplSP GetSummary();
-
- lldb::SyntheticChildrenSP GetSynthetic();
-
- lldb::TypeValidatorImplSP GetValidator();
-
- void SetFormat(lldb::TypeFormatImplSP);
-
- void SetSummary(lldb::TypeSummaryImplSP);
-
- void SetSynthetic(lldb::SyntheticChildrenSP);
-
- void SetValidator(lldb::TypeValidatorImplSP);
+ void Set(lldb::TypeFormatImplSP);
+ void Set(lldb::TypeSummaryImplSP);
+ void Set(lldb::SyntheticChildrenSP);
};
typedef std::map<ConstString, Entry> CacheMap;
CacheMap m_map;
std::recursive_mutex m_mutex;
- uint64_t m_cache_hits;
- uint64_t m_cache_misses;
+ uint64_t m_cache_hits = 0;
+ uint64_t m_cache_misses = 0;
Entry &GetEntry(ConstString type);
public:
- FormatCache();
+ FormatCache() = default;
- bool GetFormat(ConstString type, lldb::TypeFormatImplSP &format_sp);
-
- bool GetSummary(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
-
- bool GetSynthetic(ConstString type,
- lldb::SyntheticChildrenSP &synthetic_sp);
-
- bool GetValidator(ConstString type,
- lldb::TypeValidatorImplSP &summary_sp);
-
- void SetFormat(ConstString type, lldb::TypeFormatImplSP &format_sp);
-
- void SetSummary(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
-
- void SetSynthetic(ConstString type,
- lldb::SyntheticChildrenSP &synthetic_sp);
-
- void SetValidator(ConstString type,
- lldb::TypeValidatorImplSP &synthetic_sp);
+ template <typename ImplSP> bool Get(ConstString type, ImplSP &format_impl_sp);
+ void Set(ConstString type, lldb::TypeFormatImplSP &format_sp);
+ void Set(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
+ void Set(ConstString type, lldb::SyntheticChildrenSP &synthetic_sp);
void Clear();
@@ -102,6 +68,7 @@
uint64_t GetCacheMisses() { return m_cache_misses; }
};
+
} // namespace lldb_private
-#endif // lldb_FormatCache_h_
+#endif // LLDB_DATAFORMATTERS_FORMATCACHE_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/FormatClasses.h b/linux-x64/clang/include/lldb/DataFormatters/FormatClasses.h
index 5144bc6..e398913 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/FormatClasses.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/FormatClasses.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_FormatClasses_h_
-#define lldb_FormatClasses_h_
+#ifndef LLDB_DATAFORMATTERS_FORMATCLASSES_H
+#define LLDB_DATAFORMATTERS_FORMATCLASSES_H
#include <functional>
#include <memory>
@@ -17,7 +17,6 @@
#include "lldb/DataFormatters/TypeFormat.h"
#include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/DataFormatters/TypeValidator.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h"
#include "lldb/lldb-enumerations.h"
@@ -40,22 +39,19 @@
typedef HardcodedFormatterFinders<TypeFormatImpl> HardcodedFormatFinder;
typedef HardcodedFormatterFinders<TypeSummaryImpl> HardcodedSummaryFinder;
typedef HardcodedFormatterFinders<SyntheticChildren> HardcodedSyntheticFinder;
- typedef HardcodedFormatterFinders<TypeValidatorImpl> HardcodedValidatorFinder;
};
class FormattersMatchCandidate {
public:
- FormattersMatchCandidate(ConstString name, uint32_t reason, bool strip_ptr,
+ FormattersMatchCandidate(ConstString name, bool strip_ptr,
bool strip_ref, bool strip_tydef)
- : m_type_name(name), m_reason(reason), m_stripped_pointer(strip_ptr),
+ : m_type_name(name), m_stripped_pointer(strip_ptr),
m_stripped_reference(strip_ref), m_stripped_typedef(strip_tydef) {}
~FormattersMatchCandidate() = default;
ConstString GetTypeName() const { return m_type_name; }
- uint32_t GetReason() const { return m_reason; }
-
bool DidStripPointer() const { return m_stripped_pointer; }
bool DidStripReference() const { return m_stripped_reference; }
@@ -77,7 +73,6 @@
private:
ConstString m_type_name;
- uint32_t m_reason;
bool m_stripped_pointer;
bool m_stripped_reference;
bool m_stripped_typedef;
@@ -114,21 +109,21 @@
TypeNameSpecifierImpl(llvm::StringRef name, bool is_regex)
: m_is_regex(is_regex), m_type() {
- m_type.m_type_name = name;
+ m_type.m_type_name = std::string(name);
}
// if constructing with a given type, is_regex cannot be true since we are
// giving an exact type to match
TypeNameSpecifierImpl(lldb::TypeSP type) : m_is_regex(false), m_type() {
if (type) {
- m_type.m_type_name = type->GetName().GetStringRef();
+ m_type.m_type_name = std::string(type->GetName().GetStringRef());
m_type.m_compiler_type = type->GetForwardCompilerType();
}
}
TypeNameSpecifierImpl(CompilerType type) : m_is_regex(false), m_type() {
if (type.IsValid()) {
- m_type.m_type_name.assign(type.GetConstTypeName().GetCString());
+ m_type.m_type_name.assign(type.GetTypeName().GetCString());
m_type.m_compiler_type = type;
}
}
@@ -156,10 +151,11 @@
};
TypeOrName m_type;
-private:
- DISALLOW_COPY_AND_ASSIGN(TypeNameSpecifierImpl);
+ TypeNameSpecifierImpl(const TypeNameSpecifierImpl &) = delete;
+ const TypeNameSpecifierImpl &
+ operator=(const TypeNameSpecifierImpl &) = delete;
};
} // namespace lldb_private
-#endif // lldb_FormatClasses_h_
+#endif // LLDB_DATAFORMATTERS_FORMATCLASSES_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/FormatManager.h b/linux-x64/clang/include/lldb/DataFormatters/FormatManager.h
index afaafda..978ad14 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/FormatManager.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/FormatManager.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_FormatManager_h_
-#define lldb_FormatManager_h_
+#ifndef LLDB_DATAFORMATTERS_FORMATMANAGER_H
+#define LLDB_DATAFORMATTERS_FORMATMANAGER_H
#include <atomic>
#include <initializer_list>
@@ -34,7 +34,7 @@
// this file's objects directly
class FormatManager : public IFormatChangeListener {
- typedef FormatMap<ConstString, TypeSummaryImpl> NamedSummariesMap;
+ typedef FormattersContainer<TypeSummaryImpl> NamedSummariesMap;
typedef TypeCategoryMap::MapType::iterator CategoryMapIterator;
public:
@@ -52,24 +52,15 @@
void
EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos = TypeCategoryMap::Default) {
- EnableCategory(category_name, pos,
- std::initializer_list<lldb::LanguageType>());
+ EnableCategory(category_name, pos, {});
}
void EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos, lldb::LanguageType lang) {
- std::initializer_list<lldb::LanguageType> langs = {lang};
- EnableCategory(category_name, pos, langs);
- }
-
- void EnableCategory(ConstString category_name,
- TypeCategoryMap::Position pos = TypeCategoryMap::Default,
- std::initializer_list<lldb::LanguageType> langs = {}) {
TypeCategoryMap::ValueSP category_sp;
if (m_categories_map.Get(category_name, category_sp) && category_sp) {
m_categories_map.Enable(category_sp, pos);
- for (const lldb::LanguageType lang : langs)
- category_sp->AddLanguage(lang);
+ category_sp->AddLanguage(lang);
}
}
@@ -127,9 +118,6 @@
lldb::ScriptedSyntheticChildrenSP
GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
- lldb::TypeValidatorImplSP
- GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
-
lldb::TypeFormatImplSP GetFormat(ValueObject &valobj,
lldb::DynamicValueType use_dynamic);
@@ -139,9 +127,6 @@
lldb::SyntheticChildrenSP
GetSyntheticChildren(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
- lldb::TypeValidatorImplSP GetValidator(ValueObject &valobj,
- lldb::DynamicValueType use_dynamic);
-
bool
AnyMatches(ConstString type_name,
TypeCategoryImpl::FormatCategoryItems items =
@@ -159,13 +144,6 @@
static const char *GetFormatAsCString(lldb::Format format);
- // if the user tries to add formatters for, say, "struct Foo" those will not
- // match any type because of the way we strip qualifiers from typenames this
- // method looks for the case where the user is adding a
- // "class","struct","enum" or "union" Foo and strips the unnecessary
- // qualifier
- static ConstString GetValidTypeName(ConstString type);
-
// when DataExtractor dumps a vectorOfT, it uses a predefined format for each
// item this method returns it, or eFormatInvalid if vector_format is not a
// vectorOf
@@ -185,7 +163,6 @@
GetPossibleMatches(ValueObject &valobj, lldb::DynamicValueType use_dynamic) {
FormattersMatchVector matches;
GetPossibleMatches(valobj, valobj.GetCompilerType(),
- lldb_private::eFormatterChoiceCriterionDirectChoice,
use_dynamic, matches, false, false, false, true);
return matches;
}
@@ -198,11 +175,8 @@
GetCandidateLanguages(lldb::LanguageType lang_type);
private:
- static std::vector<lldb::LanguageType>
- GetCandidateLanguages(ValueObject &valobj);
-
static void GetPossibleMatches(ValueObject &valobj,
- CompilerType compiler_type, uint32_t reason,
+ CompilerType compiler_type,
lldb::DynamicValueType use_dynamic,
FormattersMatchVector &entries,
bool did_strip_ptr, bool did_strip_ref,
@@ -220,14 +194,10 @@
ConstString m_system_category_name;
ConstString m_vectortypes_category_name;
- lldb::TypeFormatImplSP GetHardcodedFormat(FormattersMatchData &);
-
- lldb::TypeSummaryImplSP GetHardcodedSummaryFormat(FormattersMatchData &);
-
- lldb::SyntheticChildrenSP
- GetHardcodedSyntheticChildren(FormattersMatchData &);
-
- lldb::TypeValidatorImplSP GetHardcodedValidator(FormattersMatchData &);
+ template <typename ImplSP>
+ ImplSP Get(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
+ template <typename ImplSP> ImplSP GetCached(FormattersMatchData &match_data);
+ template <typename ImplSP> ImplSP GetHardcoded(FormattersMatchData &);
TypeCategoryMap &GetCategories() { return m_categories_map; }
@@ -246,4 +216,4 @@
} // namespace lldb_private
-#endif // lldb_FormatManager_h_
+#endif // LLDB_DATAFORMATTERS_FORMATMANAGER_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/FormattersContainer.h b/linux-x64/clang/include/lldb/DataFormatters/FormattersContainer.h
index 9d7d373..2f56218 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/FormattersContainer.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/FormattersContainer.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_FormattersContainer_h_
-#define lldb_FormattersContainer_h_
+#ifndef LLDB_DATAFORMATTERS_FORMATTERSCONTAINER_H
+#define LLDB_DATAFORMATTERS_FORMATTERSCONTAINER_H
#include <functional>
#include <map>
@@ -22,7 +22,6 @@
#include "lldb/DataFormatters/TypeFormat.h"
#include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/DataFormatters/TypeValidator.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/StringLexer.h"
@@ -38,61 +37,146 @@
virtual uint32_t GetCurrentRevision() = 0;
};
-// if the user tries to add formatters for, say, "struct Foo" those will not
-// match any type because of the way we strip qualifiers from typenames this
-// method looks for the case where the user is adding a "class","struct","enum"
-// or "union" Foo and strips the unnecessary qualifier
-static inline ConstString GetValidTypeName_Impl(ConstString type) {
- if (type.IsEmpty())
- return type;
+/// Class for matching type names.
+class TypeMatcher {
+ RegularExpression m_type_name_regex;
+ ConstString m_type_name;
+ /// False if m_type_name_regex should be used for matching. False if this is
+ /// just matching by comparing with m_type_name string.
+ bool m_is_regex;
- std::string type_cstr(type.AsCString());
- lldb_utility::StringLexer type_lexer(type_cstr);
+ // if the user tries to add formatters for, say, "struct Foo" those will not
+ // match any type because of the way we strip qualifiers from typenames this
+ // method looks for the case where the user is adding a
+ // "class","struct","enum" or "union" Foo and strips the unnecessary qualifier
+ static ConstString StripTypeName(ConstString type) {
+ if (type.IsEmpty())
+ return type;
- type_lexer.AdvanceIf("class ");
- type_lexer.AdvanceIf("enum ");
- type_lexer.AdvanceIf("struct ");
- type_lexer.AdvanceIf("union ");
+ std::string type_cstr(type.AsCString());
+ StringLexer type_lexer(type_cstr);
- while (type_lexer.NextIf({' ', '\t', '\v', '\f'}).first)
- ;
+ type_lexer.AdvanceIf("class ");
+ type_lexer.AdvanceIf("enum ");
+ type_lexer.AdvanceIf("struct ");
+ type_lexer.AdvanceIf("union ");
- return ConstString(type_lexer.GetUnlexed());
-}
+ while (type_lexer.NextIf({' ', '\t', '\v', '\f'}).first)
+ ;
-template <typename KeyType, typename ValueType> class FormattersContainer;
+ return ConstString(type_lexer.GetUnlexed());
+ }
-template <typename KeyType, typename ValueType> class FormatMap {
public:
- typedef typename ValueType::SharedPointer ValueSP;
- typedef std::map<KeyType, ValueSP> MapType;
- typedef typename MapType::iterator MapIterator;
- typedef std::function<bool(KeyType, const ValueSP &)> ForEachCallback;
+ TypeMatcher() = delete;
+ /// Creates a matcher that accepts any type with exactly the given type name.
+ TypeMatcher(ConstString type_name)
+ : m_type_name(type_name), m_is_regex(false) {}
+ /// Creates a matcher that accepts any type matching the given regex.
+ TypeMatcher(RegularExpression regex)
+ : m_type_name_regex(std::move(regex)), m_is_regex(true) {}
- FormatMap(IFormatChangeListener *lst)
- : m_map(), m_map_mutex(), listener(lst) {}
+ /// True iff this matches the given type name.
+ bool Matches(ConstString type_name) const {
+ if (m_is_regex)
+ return m_type_name_regex.Execute(type_name.GetStringRef());
+ return m_type_name == type_name ||
+ StripTypeName(m_type_name) == StripTypeName(type_name);
+ }
- void Add(KeyType name, const ValueSP &entry) {
+ /// Returns the underlying match string for this TypeMatcher.
+ ConstString GetMatchString() const {
+ if (m_is_regex)
+ return ConstString(m_type_name_regex.GetText());
+ return StripTypeName(m_type_name);
+ }
+
+ /// Returns true if this TypeMatcher and the given one were most created by
+ /// the same match string.
+ /// The main purpose of this function is to find existing TypeMatcher
+ /// instances by the user input that created them. This is necessary as LLDB
+ /// allows referencing existing TypeMatchers in commands by the user input
+ /// that originally created them:
+ /// (lldb) type summary add --summary-string \"A\" -x TypeName
+ /// (lldb) type summary delete TypeName
+ bool CreatedBySameMatchString(TypeMatcher other) const {
+ return GetMatchString() == other.GetMatchString();
+ }
+};
+
+template <typename ValueType> class FormattersContainer {
+public:
+ typedef typename std::shared_ptr<ValueType> ValueSP;
+ typedef std::vector<std::pair<TypeMatcher, ValueSP>> MapType;
+ typedef std::function<bool(const TypeMatcher &, const ValueSP &)>
+ ForEachCallback;
+ typedef typename std::shared_ptr<FormattersContainer<ValueType>>
+ SharedPointer;
+
+ friend class TypeCategoryImpl;
+
+ FormattersContainer(IFormatChangeListener *lst) : listener(lst) {}
+
+ void Add(TypeMatcher matcher, const ValueSP &entry) {
if (listener)
entry->GetRevision() = listener->GetCurrentRevision();
else
entry->GetRevision() = 0;
std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
- m_map[name] = entry;
+ Delete(matcher);
+ m_map.emplace_back(std::move(matcher), std::move(entry));
if (listener)
listener->Changed();
}
- bool Delete(KeyType name) {
+ bool Delete(TypeMatcher matcher) {
std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
- MapIterator iter = m_map.find(name);
- if (iter == m_map.end())
- return false;
- m_map.erase(name);
- if (listener)
- listener->Changed();
- return true;
+ for (auto iter = m_map.begin(); iter != m_map.end(); ++iter)
+ if (iter->first.CreatedBySameMatchString(matcher)) {
+ m_map.erase(iter);
+ if (listener)
+ listener->Changed();
+ return true;
+ }
+ return false;
+ }
+
+ bool Get(ConstString type, ValueSP &entry) {
+ std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+ for (auto &formatter : llvm::reverse(m_map)) {
+ if (formatter.first.Matches(type)) {
+ entry = formatter.second;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool GetExact(TypeMatcher matcher, ValueSP &entry) {
+ std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+ for (const auto &pos : m_map)
+ if (pos.first.CreatedBySameMatchString(matcher)) {
+ entry = pos.second;
+ return true;
+ }
+ return false;
+ }
+
+ ValueSP GetAtIndex(size_t index) {
+ std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+ if (index >= m_map.size())
+ return ValueSP();
+ return m_map[index].second;
+ }
+
+ lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierAtIndex(size_t index) {
+ std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+ if (index >= m_map.size())
+ return lldb::TypeNameSpecifierImplSP();
+ TypeMatcher type_matcher = m_map[index].first;
+ return std::make_shared<TypeNameSpecifierImpl>(
+ type_matcher.GetMatchString().GetStringRef(), true);
}
void Clear() {
@@ -102,242 +186,52 @@
listener->Changed();
}
- bool Get(KeyType name, ValueSP &entry) {
- std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
- MapIterator iter = m_map.find(name);
- if (iter == m_map.end())
- return false;
- entry = iter->second;
- return true;
- }
-
void ForEach(ForEachCallback callback) {
if (callback) {
std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
- MapIterator pos, end = m_map.end();
- for (pos = m_map.begin(); pos != end; pos++) {
- KeyType type = pos->first;
- if (!callback(type, pos->second))
+ for (const auto &pos : m_map) {
+ const TypeMatcher &type = pos.first;
+ if (!callback(type, pos.second))
break;
}
}
}
- uint32_t GetCount() { return m_map.size(); }
-
- ValueSP GetValueAtIndex(size_t index) {
+ uint32_t GetCount() {
std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
- MapIterator iter = m_map.begin();
- MapIterator end = m_map.end();
- while (index > 0) {
- iter++;
- index--;
- if (end == iter)
- return ValueSP();
- }
- return iter->second;
+ return m_map.size();
}
- KeyType GetKeyAtIndex(size_t index) {
- std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
- MapIterator iter = m_map.begin();
- MapIterator end = m_map.end();
- while (index > 0) {
- iter++;
- index--;
- if (end == iter)
- return KeyType();
- }
- return iter->first;
+ void AutoComplete(CompletionRequest &request) {
+ ForEach([&request](const TypeMatcher &matcher, const ValueSP &value) {
+ request.TryCompleteCurrentArg(matcher.GetMatchString().GetStringRef());
+ return true;
+ });
}
protected:
- MapType m_map;
- std::recursive_mutex m_map_mutex;
- IFormatChangeListener *listener;
+ FormattersContainer(const FormattersContainer &) = delete;
+ const FormattersContainer &operator=(const FormattersContainer &) = delete;
- MapType &map() { return m_map; }
-
- std::recursive_mutex &mutex() { return m_map_mutex; }
-
- friend class FormattersContainer<KeyType, ValueType>;
- friend class FormatManager;
-};
-
-template <typename KeyType, typename ValueType> class FormattersContainer {
-protected:
- typedef FormatMap<KeyType, ValueType> BackEndType;
-
-public:
- typedef typename BackEndType::MapType MapType;
- typedef typename MapType::iterator MapIterator;
- typedef typename MapType::key_type MapKeyType;
- typedef typename MapType::mapped_type MapValueType;
- typedef typename BackEndType::ForEachCallback ForEachCallback;
- typedef typename std::shared_ptr<FormattersContainer<KeyType, ValueType>>
- SharedPointer;
-
- friend class TypeCategoryImpl;
-
- FormattersContainer(std::string name, IFormatChangeListener *lst)
- : m_format_map(lst), m_name(name) {}
-
- void Add(const MapKeyType &type, const MapValueType &entry) {
- Add_Impl(type, entry, static_cast<KeyType *>(nullptr));
- }
-
- bool Delete(ConstString type) {
- return Delete_Impl(type, static_cast<KeyType *>(nullptr));
- }
-
- bool Get(ValueObject &valobj, MapValueType &entry,
- lldb::DynamicValueType use_dynamic, uint32_t *why = nullptr) {
- uint32_t value = lldb_private::eFormatterChoiceCriterionDirectChoice;
- CompilerType ast_type(valobj.GetCompilerType());
- bool ret = Get(valobj, ast_type, entry, use_dynamic, value);
- if (ret)
- entry = MapValueType(entry);
- else
- entry = MapValueType();
- if (why)
- *why = value;
- return ret;
- }
-
- bool Get(ConstString type, MapValueType &entry) {
- return Get_Impl(type, entry, static_cast<KeyType *>(nullptr));
- }
-
- bool GetExact(ConstString type, MapValueType &entry) {
- return GetExact_Impl(type, entry, static_cast<KeyType *>(nullptr));
- }
-
- MapValueType GetAtIndex(size_t index) {
- return m_format_map.GetValueAtIndex(index);
- }
-
- lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierAtIndex(size_t index) {
- return GetTypeNameSpecifierAtIndex_Impl(index,
- static_cast<KeyType *>(nullptr));
- }
-
- void Clear() { m_format_map.Clear(); }
-
- void ForEach(ForEachCallback callback) { m_format_map.ForEach(callback); }
-
- uint32_t GetCount() { return m_format_map.GetCount(); }
-
-protected:
- BackEndType m_format_map;
- std::string m_name;
-
- DISALLOW_COPY_AND_ASSIGN(FormattersContainer);
-
- void Add_Impl(const MapKeyType &type, const MapValueType &entry,
- lldb::RegularExpressionSP *dummy) {
- m_format_map.Add(type, entry);
- }
-
- void Add_Impl(ConstString type, const MapValueType &entry,
- ConstString *dummy) {
- m_format_map.Add(GetValidTypeName_Impl(type), entry);
- }
-
- bool Delete_Impl(ConstString type, ConstString *dummy) {
- return m_format_map.Delete(type);
- }
-
- bool Delete_Impl(ConstString type, lldb::RegularExpressionSP *dummy) {
- std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
- MapIterator pos, end = m_format_map.map().end();
- for (pos = m_format_map.map().begin(); pos != end; pos++) {
- lldb::RegularExpressionSP regex = pos->first;
- if (type.GetStringRef() == regex->GetText()) {
- m_format_map.map().erase(pos);
- if (m_format_map.listener)
- m_format_map.listener->Changed();
- return true;
- }
- }
- return false;
- }
-
- bool Get_Impl(ConstString type, MapValueType &entry, ConstString *dummy) {
- return m_format_map.Get(type, entry);
- }
-
- bool GetExact_Impl(ConstString type, MapValueType &entry,
- ConstString *dummy) {
- return Get_Impl(type, entry, static_cast<KeyType *>(nullptr));
- }
-
- lldb::TypeNameSpecifierImplSP
- GetTypeNameSpecifierAtIndex_Impl(size_t index, ConstString *dummy) {
- ConstString key = m_format_map.GetKeyAtIndex(index);
- if (key)
- return lldb::TypeNameSpecifierImplSP(
- new TypeNameSpecifierImpl(key.AsCString(), false));
- else
- return lldb::TypeNameSpecifierImplSP();
- }
-
- lldb::TypeNameSpecifierImplSP
- GetTypeNameSpecifierAtIndex_Impl(size_t index,
- lldb::RegularExpressionSP *dummy) {
- lldb::RegularExpressionSP regex = m_format_map.GetKeyAtIndex(index);
- if (regex.get() == nullptr)
- return lldb::TypeNameSpecifierImplSP();
- return lldb::TypeNameSpecifierImplSP(
- new TypeNameSpecifierImpl(regex->GetText().str().c_str(), true));
- }
-
- bool Get_Impl(ConstString key, MapValueType &value,
- lldb::RegularExpressionSP *dummy) {
- llvm::StringRef key_str = key.GetStringRef();
- std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
- MapIterator pos, end = m_format_map.map().end();
- for (pos = m_format_map.map().begin(); pos != end; pos++) {
- lldb::RegularExpressionSP regex = pos->first;
- if (regex->Execute(key_str)) {
- value = pos->second;
- return true;
- }
- }
- return false;
- }
-
- bool GetExact_Impl(ConstString key, MapValueType &value,
- lldb::RegularExpressionSP *dummy) {
- std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
- MapIterator pos, end = m_format_map.map().end();
- for (pos = m_format_map.map().begin(); pos != end; pos++) {
- lldb::RegularExpressionSP regex = pos->first;
- if (regex->GetText() == key.GetStringRef()) {
- value = pos->second;
- return true;
- }
- }
- return false;
- }
-
- bool Get(const FormattersMatchVector &candidates, MapValueType &entry,
- uint32_t *reason) {
+ bool Get(const FormattersMatchVector &candidates, ValueSP &entry) {
for (const FormattersMatchCandidate &candidate : candidates) {
if (Get(candidate.GetTypeName(), entry)) {
if (candidate.IsMatch(entry) == false) {
entry.reset();
continue;
} else {
- if (reason)
- *reason = candidate.GetReason();
return true;
}
}
}
return false;
}
+
+ MapType m_map;
+ std::recursive_mutex m_map_mutex;
+ IFormatChangeListener *listener;
};
} // namespace lldb_private
-#endif // lldb_FormattersContainer_h_
+#endif // LLDB_DATAFORMATTERS_FORMATTERSCONTAINER_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/FormattersHelpers.h b/linux-x64/clang/include/lldb/DataFormatters/FormattersHelpers.h
index 79bd376..a5b0da5 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/FormattersHelpers.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/FormattersHelpers.h
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_FormattersHelpers_h_
-#define lldb_FormattersHelpers_h_
+#ifndef LLDB_DATAFORMATTERS_FORMATTERSHELPERS_H
+#define LLDB_DATAFORMATTERS_FORMATTERSHELPERS_H
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
@@ -56,6 +56,8 @@
lldb::addr_t GetArrayAddressOrPointerValue(ValueObject &valobj);
+lldb::ValueObjectSP GetValueOfLibCXXCompressedPair(ValueObject &pair);
+
time_t GetOSXEpoch();
struct InferiorSizedWord {
@@ -184,4 +186,4 @@
} // namespace formatters
} // namespace lldb_private
-#endif // lldb_FormattersHelpers_h_
+#endif // LLDB_DATAFORMATTERS_FORMATTERSHELPERS_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/LanguageCategory.h b/linux-x64/clang/include/lldb/DataFormatters/LanguageCategory.h
index f109d46..d767673 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/LanguageCategory.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/LanguageCategory.h
@@ -7,9 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_LanguageCategory_h_
-#define lldb_LanguageCategory_h_
-
+#ifndef LLDB_DATAFORMATTERS_LANGUAGECATEGORY_H
+#define LLDB_DATAFORMATTERS_LANGUAGECATEGORY_H
#include "lldb/DataFormatters/FormatCache.h"
#include "lldb/DataFormatters/FormatClasses.h"
@@ -25,27 +24,11 @@
LanguageCategory(lldb::LanguageType lang_type);
- bool Get(FormattersMatchData &match_data, lldb::TypeFormatImplSP &format_sp);
-
- bool Get(FormattersMatchData &match_data, lldb::TypeSummaryImplSP &format_sp);
-
- bool Get(FormattersMatchData &match_data,
- lldb::SyntheticChildrenSP &format_sp);
-
- bool Get(FormattersMatchData &match_data,
- lldb::TypeValidatorImplSP &format_sp);
-
+ template <typename ImplSP>
+ bool Get(FormattersMatchData &match_data, ImplSP &format_sp);
+ template <typename ImplSP>
bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
- lldb::TypeFormatImplSP &format_sp);
-
- bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
- lldb::TypeSummaryImplSP &format_sp);
-
- bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
- lldb::SyntheticChildrenSP &format_sp);
-
- bool GetHardcoded(FormatManager &fmt_mgr, FormattersMatchData &match_data,
- lldb::TypeValidatorImplSP &format_sp);
+ ImplSP &format_sp);
lldb::TypeCategoryImplSP GetCategory() const;
@@ -63,7 +46,9 @@
HardcodedFormatters::HardcodedFormatFinder m_hardcoded_formats;
HardcodedFormatters::HardcodedSummaryFinder m_hardcoded_summaries;
HardcodedFormatters::HardcodedSyntheticFinder m_hardcoded_synthetics;
- HardcodedFormatters::HardcodedValidatorFinder m_hardcoded_validators;
+
+ template <typename ImplSP>
+ auto &GetHardcodedFinder();
lldb_private::FormatCache m_format_cache;
@@ -72,4 +57,4 @@
} // namespace lldb_private
-#endif // lldb_LanguageCategory_h_
+#endif // LLDB_DATAFORMATTERS_LANGUAGECATEGORY_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/StringPrinter.h b/linux-x64/clang/include/lldb/DataFormatters/StringPrinter.h
index 41d5edd..4a6e2e9 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/StringPrinter.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/StringPrinter.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_StringPrinter_h_
-#define liblldb_StringPrinter_h_
+#ifndef LLDB_DATAFORMATTERS_STRINGPRINTER_H
+#define LLDB_DATAFORMATTERS_STRINGPRINTER_H
#include <functional>
#include <string>
@@ -24,309 +24,127 @@
enum class GetPrintableElementType { ASCII, UTF8 };
- class ReadStringAndDumpToStreamOptions {
+ enum class EscapeStyle { CXX, Swift };
+
+ class DumpToStreamOptions {
public:
- ReadStringAndDumpToStreamOptions()
- : m_location(0), m_process_sp(), m_stream(nullptr), m_prefix_token(),
- m_suffix_token(), m_quote('"'), m_source_size(0),
- m_needs_zero_termination(true), m_escape_non_printables(true),
- m_ignore_max_length(false), m_zero_is_terminator(true),
- m_language_type(lldb::eLanguageTypeUnknown) {}
+ DumpToStreamOptions() = default;
- ReadStringAndDumpToStreamOptions(ValueObject &valobj);
-
- ReadStringAndDumpToStreamOptions &SetLocation(uint64_t l) {
- m_location = l;
- return *this;
- }
-
- uint64_t GetLocation() const { return m_location; }
-
- ReadStringAndDumpToStreamOptions &SetProcessSP(lldb::ProcessSP p) {
- m_process_sp = p;
- return *this;
- }
-
- lldb::ProcessSP GetProcessSP() const { return m_process_sp; }
-
- ReadStringAndDumpToStreamOptions &SetStream(Stream *s) {
- m_stream = s;
- return *this;
- }
+ void SetStream(Stream *s) { m_stream = s; }
Stream *GetStream() const { return m_stream; }
- ReadStringAndDumpToStreamOptions &SetPrefixToken(const std::string &p) {
- m_prefix_token = p;
- return *this;
- }
+ void SetPrefixToken(const std::string &p) { m_prefix_token = p; }
- ReadStringAndDumpToStreamOptions &SetPrefixToken(std::nullptr_t) {
- m_prefix_token.clear();
- return *this;
- }
+ void SetPrefixToken(std::nullptr_t) { m_prefix_token.clear(); }
const char *GetPrefixToken() const { return m_prefix_token.c_str(); }
- ReadStringAndDumpToStreamOptions &SetSuffixToken(const std::string &p) {
- m_suffix_token = p;
- return *this;
- }
+ void SetSuffixToken(const std::string &p) { m_suffix_token = p; }
- ReadStringAndDumpToStreamOptions &SetSuffixToken(std::nullptr_t) {
- m_suffix_token.clear();
- return *this;
- }
+ void SetSuffixToken(std::nullptr_t) { m_suffix_token.clear(); }
const char *GetSuffixToken() const { return m_suffix_token.c_str(); }
- ReadStringAndDumpToStreamOptions &SetQuote(char q) {
- m_quote = q;
- return *this;
- }
+ void SetQuote(char q) { m_quote = q; }
char GetQuote() const { return m_quote; }
- ReadStringAndDumpToStreamOptions &SetSourceSize(uint32_t s) {
- m_source_size = s;
- return *this;
- }
+ void SetSourceSize(uint32_t s) { m_source_size = s; }
uint32_t GetSourceSize() const { return m_source_size; }
- ReadStringAndDumpToStreamOptions &SetNeedsZeroTermination(bool z) {
- m_needs_zero_termination = z;
- return *this;
- }
+ void SetNeedsZeroTermination(bool z) { m_needs_zero_termination = z; }
bool GetNeedsZeroTermination() const { return m_needs_zero_termination; }
- ReadStringAndDumpToStreamOptions &SetBinaryZeroIsTerminator(bool e) {
- m_zero_is_terminator = e;
- return *this;
- }
+ void SetBinaryZeroIsTerminator(bool e) { m_zero_is_terminator = e; }
bool GetBinaryZeroIsTerminator() const { return m_zero_is_terminator; }
- ReadStringAndDumpToStreamOptions &SetEscapeNonPrintables(bool e) {
- m_escape_non_printables = e;
- return *this;
- }
+ void SetEscapeNonPrintables(bool e) { m_escape_non_printables = e; }
bool GetEscapeNonPrintables() const { return m_escape_non_printables; }
- ReadStringAndDumpToStreamOptions &SetIgnoreMaxLength(bool e) {
- m_ignore_max_length = e;
- return *this;
- }
+ void SetIgnoreMaxLength(bool e) { m_ignore_max_length = e; }
bool GetIgnoreMaxLength() const { return m_ignore_max_length; }
- ReadStringAndDumpToStreamOptions &SetLanguage(lldb::LanguageType l) {
- m_language_type = l;
- return *this;
- }
+ void SetEscapeStyle(EscapeStyle style) { m_escape_style = style; }
- lldb::LanguageType GetLanguage() const
-
- {
- return m_language_type;
- }
+ EscapeStyle GetEscapeStyle() const { return m_escape_style; }
private:
- uint64_t m_location;
- lldb::ProcessSP m_process_sp;
- Stream *m_stream;
+ /// The used output stream.
+ Stream *m_stream = nullptr;
+ /// String that should be printed before the heading quote character.
std::string m_prefix_token;
+ /// String that should be printed after the trailing quote character.
std::string m_suffix_token;
- char m_quote;
- uint32_t m_source_size;
- bool m_needs_zero_termination;
- bool m_escape_non_printables;
- bool m_ignore_max_length;
- bool m_zero_is_terminator;
- lldb::LanguageType m_language_type;
+ /// The quote character that should surround the string.
+ char m_quote = '"';
+ /// The length of the memory region that should be dumped in bytes.
+ uint32_t m_source_size = 0;
+ bool m_needs_zero_termination = true;
+ /// True iff non-printable characters should be escaped when dumping
+ /// them to the stream.
+ bool m_escape_non_printables = true;
+ /// True iff the max-string-summary-length setting of the target should
+ /// be ignored.
+ bool m_ignore_max_length = false;
+ /// True iff a zero bytes ('\0') should terminate the memory region that
+ /// is being dumped.
+ bool m_zero_is_terminator = true;
+ /// The language-specific style for escaping special characters.
+ EscapeStyle m_escape_style = EscapeStyle::CXX;
};
- class ReadBufferAndDumpToStreamOptions {
+ class ReadStringAndDumpToStreamOptions : public DumpToStreamOptions {
public:
- ReadBufferAndDumpToStreamOptions()
- : m_data(), m_stream(nullptr), m_prefix_token(), m_suffix_token(),
- m_quote('"'), m_source_size(0), m_escape_non_printables(true),
- m_zero_is_terminator(true), m_is_truncated(false),
- m_language_type(lldb::eLanguageTypeUnknown) {}
+ ReadStringAndDumpToStreamOptions() = default;
+
+ ReadStringAndDumpToStreamOptions(ValueObject &valobj);
+
+ void SetLocation(uint64_t l) { m_location = l; }
+
+ uint64_t GetLocation() const { return m_location; }
+
+ void SetProcessSP(lldb::ProcessSP p) { m_process_sp = std::move(p); }
+
+ lldb::ProcessSP GetProcessSP() const { return m_process_sp; }
+
+ void SetHasSourceSize(bool e) { m_has_source_size = e; }
+
+ bool HasSourceSize() const { return m_has_source_size; }
+
+ private:
+ uint64_t m_location = 0;
+ lldb::ProcessSP m_process_sp;
+ /// True iff we know the source size of the string.
+ bool m_has_source_size = false;
+ };
+
+ class ReadBufferAndDumpToStreamOptions : public DumpToStreamOptions {
+ public:
+ ReadBufferAndDumpToStreamOptions() = default;
ReadBufferAndDumpToStreamOptions(ValueObject &valobj);
ReadBufferAndDumpToStreamOptions(
const ReadStringAndDumpToStreamOptions &options);
- ReadBufferAndDumpToStreamOptions &SetData(DataExtractor d) {
- m_data = d;
- return *this;
- }
+ void SetData(DataExtractor d) { m_data = d; }
lldb_private::DataExtractor GetData() const { return m_data; }
- ReadBufferAndDumpToStreamOptions &SetStream(Stream *s) {
- m_stream = s;
- return *this;
- }
-
- Stream *GetStream() const { return m_stream; }
-
- ReadBufferAndDumpToStreamOptions &SetPrefixToken(const std::string &p) {
- m_prefix_token = p;
- return *this;
- }
-
- ReadBufferAndDumpToStreamOptions &SetPrefixToken(std::nullptr_t) {
- m_prefix_token.clear();
- return *this;
- }
-
- const char *GetPrefixToken() const { return m_prefix_token.c_str(); }
-
- ReadBufferAndDumpToStreamOptions &SetSuffixToken(const std::string &p) {
- m_suffix_token = p;
- return *this;
- }
-
- ReadBufferAndDumpToStreamOptions &SetSuffixToken(std::nullptr_t) {
- m_suffix_token.clear();
- return *this;
- }
-
- const char *GetSuffixToken() const { return m_suffix_token.c_str(); }
-
- ReadBufferAndDumpToStreamOptions &SetQuote(char q) {
- m_quote = q;
- return *this;
- }
-
- char GetQuote() const { return m_quote; }
-
- ReadBufferAndDumpToStreamOptions &SetSourceSize(uint32_t s) {
- m_source_size = s;
- return *this;
- }
-
- uint32_t GetSourceSize() const { return m_source_size; }
-
- ReadBufferAndDumpToStreamOptions &SetEscapeNonPrintables(bool e) {
- m_escape_non_printables = e;
- return *this;
- }
-
- bool GetEscapeNonPrintables() const { return m_escape_non_printables; }
-
- ReadBufferAndDumpToStreamOptions &SetBinaryZeroIsTerminator(bool e) {
- m_zero_is_terminator = e;
- return *this;
- }
-
- bool GetBinaryZeroIsTerminator() const { return m_zero_is_terminator; }
-
- ReadBufferAndDumpToStreamOptions &SetIsTruncated(bool t) {
- m_is_truncated = t;
- return *this;
- }
+ void SetIsTruncated(bool t) { m_is_truncated = t; }
bool GetIsTruncated() const { return m_is_truncated; }
-
- ReadBufferAndDumpToStreamOptions &SetLanguage(lldb::LanguageType l) {
- m_language_type = l;
- return *this;
- }
-
- lldb::LanguageType GetLanguage() const
-
- {
- return m_language_type;
- }
-
private:
DataExtractor m_data;
- Stream *m_stream;
- std::string m_prefix_token;
- std::string m_suffix_token;
- char m_quote;
- uint32_t m_source_size;
- bool m_escape_non_printables;
- bool m_zero_is_terminator;
- bool m_is_truncated;
- lldb::LanguageType m_language_type;
+ bool m_is_truncated = false;
};
- // I can't use a std::unique_ptr for this because the Deleter is a template
- // argument there
- // and I want the same type to represent both pointers I want to free and
- // pointers I don't need to free - which is what this class essentially is
- // It's very specialized to the needs of this file, and not suggested for
- // general use
- template <typename T = uint8_t, typename U = char, typename S = size_t>
- struct StringPrinterBufferPointer {
- public:
- typedef std::function<void(const T *)> Deleter;
-
- StringPrinterBufferPointer(std::nullptr_t ptr)
- : m_data(nullptr), m_size(0), m_deleter() {}
-
- StringPrinterBufferPointer(const T *bytes, S size,
- Deleter deleter = nullptr)
- : m_data(bytes), m_size(size), m_deleter(deleter) {}
-
- StringPrinterBufferPointer(const U *bytes, S size,
- Deleter deleter = nullptr)
- : m_data(reinterpret_cast<const T *>(bytes)), m_size(size),
- m_deleter(deleter) {}
-
- StringPrinterBufferPointer(StringPrinterBufferPointer &&rhs)
- : m_data(rhs.m_data), m_size(rhs.m_size), m_deleter(rhs.m_deleter) {
- rhs.m_data = nullptr;
- }
-
- StringPrinterBufferPointer(const StringPrinterBufferPointer &rhs)
- : m_data(rhs.m_data), m_size(rhs.m_size), m_deleter(rhs.m_deleter) {
- rhs.m_data = nullptr; // this is why m_data has to be mutable
- }
-
- ~StringPrinterBufferPointer() {
- if (m_data && m_deleter)
- m_deleter(m_data);
- m_data = nullptr;
- }
-
- const T *GetBytes() const { return m_data; }
-
- const S GetSize() const { return m_size; }
-
- StringPrinterBufferPointer &
- operator=(const StringPrinterBufferPointer &rhs) {
- if (m_data && m_deleter)
- m_deleter(m_data);
- m_data = rhs.m_data;
- m_size = rhs.m_size;
- m_deleter = rhs.m_deleter;
- rhs.m_data = nullptr;
- return *this;
- }
-
- private:
- mutable const T *m_data;
- size_t m_size;
- Deleter m_deleter;
- };
-
- typedef std::function<StringPrinter::StringPrinterBufferPointer<
- uint8_t, char, size_t>(uint8_t *, uint8_t *, uint8_t *&)>
- EscapingHelper;
- typedef std::function<EscapingHelper(GetPrintableElementType)>
- EscapingHelperGenerator;
-
- static EscapingHelper
- GetDefaultEscapingHelper(GetPrintableElementType elem_type);
-
template <StringElementType element_type>
static bool
ReadStringAndDumpToStream(const ReadStringAndDumpToStreamOptions &options);
@@ -339,4 +157,4 @@
} // namespace formatters
} // namespace lldb_private
-#endif // liblldb_StringPrinter_h_
+#endif // LLDB_DATAFORMATTERS_STRINGPRINTER_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/TypeCategory.h b/linux-x64/clang/include/lldb/DataFormatters/TypeCategory.h
index bdb393a..2c93059 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/TypeCategory.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/TypeCategory.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_TypeCategory_h_
-#define lldb_TypeCategory_h_
+#ifndef LLDB_DATAFORMATTERS_TYPECATEGORY_H
+#define LLDB_DATAFORMATTERS_TYPECATEGORY_H
#include <initializer_list>
#include <memory>
@@ -25,14 +25,13 @@
template <typename FormatterImpl> class FormatterContainerPair {
public:
- typedef FormattersContainer<ConstString, FormatterImpl> ExactMatchContainer;
- typedef FormattersContainer<lldb::RegularExpressionSP, FormatterImpl>
- RegexMatchContainer;
+ typedef FormattersContainer<FormatterImpl> ExactMatchContainer;
+ typedef FormattersContainer<FormatterImpl> RegexMatchContainer;
- typedef typename ExactMatchContainer::MapType ExactMatchMap;
- typedef typename RegexMatchContainer::MapType RegexMatchMap;
+ typedef TypeMatcher ExactMatchMap;
+ typedef TypeMatcher RegexMatchMap;
- typedef typename ExactMatchContainer::MapValueType MapValueType;
+ typedef typename ExactMatchContainer::ValueSP MapValueType;
typedef typename ExactMatchContainer::SharedPointer ExactMatchContainerSP;
typedef typename RegexMatchContainer::SharedPointer RegexMatchContainerSP;
@@ -42,10 +41,9 @@
typedef
typename RegexMatchContainer::ForEachCallback RegexMatchForEachCallback;
- FormatterContainerPair(const char *exact_name, const char *regex_name,
- IFormatChangeListener *clist)
- : m_exact_sp(new ExactMatchContainer(std::string(exact_name), clist)),
- m_regex_sp(new RegexMatchContainer(std::string(regex_name), clist)) {}
+ FormatterContainerPair(IFormatChangeListener *clist)
+ : m_exact_sp(new ExactMatchContainer(clist)),
+ m_regex_sp(new RegexMatchContainer(clist)) {}
~FormatterContainerPair() = default;
@@ -67,7 +65,6 @@
typedef FormatterContainerPair<TypeFormatImpl> FormatContainer;
typedef FormatterContainerPair<TypeSummaryImpl> SummaryContainer;
typedef FormatterContainerPair<TypeFilterImpl> FilterContainer;
- typedef FormatterContainerPair<TypeValidatorImpl> ValidatorContainer;
typedef FormatterContainerPair<SyntheticChildren> SynthContainer;
public:
@@ -86,9 +83,6 @@
typedef SynthContainer::ExactMatchContainerSP SynthContainerSP;
typedef SynthContainer::RegexMatchContainerSP RegexSynthContainerSP;
- typedef ValidatorContainer::ExactMatchContainerSP ValidatorContainerSP;
- typedef ValidatorContainer::RegexMatchContainerSP RegexValidatorContainerSP;
-
template <typename T> class ForEachCallbacks {
public:
ForEachCallbacks() = default;
@@ -97,64 +91,52 @@
template <typename U = TypeFormatImpl>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetExact(FormatContainer::ExactMatchForEachCallback callback) {
- m_format_exact = callback;
+ m_format_exact = std::move(callback);
return *this;
}
template <typename U = TypeFormatImpl>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetWithRegex(FormatContainer::RegexMatchForEachCallback callback) {
- m_format_regex = callback;
+ m_format_regex = std::move(callback);
return *this;
}
template <typename U = TypeSummaryImpl>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetExact(SummaryContainer::ExactMatchForEachCallback callback) {
- m_summary_exact = callback;
+ m_summary_exact = std::move(callback);
return *this;
}
template <typename U = TypeSummaryImpl>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetWithRegex(SummaryContainer::RegexMatchForEachCallback callback) {
- m_summary_regex = callback;
+ m_summary_regex = std::move(callback);
return *this;
}
template <typename U = TypeFilterImpl>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetExact(FilterContainer::ExactMatchForEachCallback callback) {
- m_filter_exact = callback;
+ m_filter_exact = std::move(callback);
return *this;
}
template <typename U = TypeFilterImpl>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetWithRegex(FilterContainer::RegexMatchForEachCallback callback) {
- m_filter_regex = callback;
+ m_filter_regex = std::move(callback);
return *this;
}
template <typename U = SyntheticChildren>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetExact(SynthContainer::ExactMatchForEachCallback callback) {
- m_synth_exact = callback;
+ m_synth_exact = std::move(callback);
return *this;
}
template <typename U = SyntheticChildren>
typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
SetWithRegex(SynthContainer::RegexMatchForEachCallback callback) {
- m_synth_regex = callback;
- return *this;
- }
- template <typename U = TypeValidatorImpl>
- typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
- SetExact(ValidatorContainer::ExactMatchForEachCallback callback) {
- m_validator_exact = callback;
- return *this;
- }
- template <typename U = TypeValidatorImpl>
- typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
- SetWithRegex(ValidatorContainer::RegexMatchForEachCallback callback) {
- m_validator_regex = callback;
+ m_synth_regex = std::move(callback);
return *this;
}
@@ -188,15 +170,6 @@
return m_synth_regex;
}
- ValidatorContainer::ExactMatchForEachCallback
- GetValidatorExactCallback() const {
- return m_validator_exact;
- }
- ValidatorContainer::RegexMatchForEachCallback
- GetValidatorRegexCallback() const {
- return m_validator_regex;
- }
-
private:
FormatContainer::ExactMatchForEachCallback m_format_exact;
FormatContainer::RegexMatchForEachCallback m_format_regex;
@@ -209,13 +182,9 @@
SynthContainer::ExactMatchForEachCallback m_synth_exact;
SynthContainer::RegexMatchForEachCallback m_synth_regex;
-
- ValidatorContainer::ExactMatchForEachCallback m_validator_exact;
- ValidatorContainer::RegexMatchForEachCallback m_validator_regex;
};
- TypeCategoryImpl(IFormatChangeListener *clist, ConstString name,
- std::initializer_list<lldb::LanguageType> langs = {});
+ TypeCategoryImpl(IFormatChangeListener *clist, ConstString name);
template <typename T> void ForEach(const ForEachCallbacks<T> &foreach) {
GetTypeFormatsContainer()->ForEach(foreach.GetFormatExactCallback());
@@ -230,10 +199,6 @@
GetTypeSyntheticsContainer()->ForEach(foreach.GetSynthExactCallback());
GetRegexTypeSyntheticsContainer()->ForEach(foreach.GetSynthRegexCallback());
-
- GetTypeValidatorsContainer()->ForEach(foreach.GetValidatorExactCallback());
- GetRegexTypeValidatorsContainer()->ForEach(
- foreach.GetValidatorRegexCallback());
}
FormatContainerSP GetTypeFormatsContainer() {
@@ -278,9 +243,6 @@
SynthContainer::MapValueType
GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
- ValidatorContainer::MapValueType
- GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
-
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierForFormatAtIndex(size_t index);
@@ -311,19 +273,6 @@
lldb::TypeNameSpecifierImplSP
GetTypeNameSpecifierForSyntheticAtIndex(size_t index);
- ValidatorContainerSP GetTypeValidatorsContainer() {
- return m_validator_cont.GetExactMatch();
- }
-
- RegexValidatorContainerSP GetRegexTypeValidatorsContainer() {
- return m_validator_cont.GetRegexMatch();
- }
-
- ValidatorContainer::MapValueType GetValidatorAtIndex(size_t index);
-
- lldb::TypeNameSpecifierImplSP
- GetTypeNameSpecifierForValidatorAtIndex(size_t index);
-
bool IsEnabled() const { return m_enabled; }
uint32_t GetEnabledPosition() {
@@ -333,17 +282,14 @@
return m_enabled_position;
}
- bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
- lldb::TypeFormatImplSP &entry, uint32_t *reason = nullptr);
+ bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
+ lldb::TypeFormatImplSP &entry);
- bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
- lldb::TypeSummaryImplSP &entry, uint32_t *reason = nullptr);
+ bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
+ lldb::TypeSummaryImplSP &entry);
- bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
- lldb::SyntheticChildrenSP &entry, uint32_t *reason = nullptr);
-
- bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
- lldb::TypeValidatorImplSP &entry, uint32_t *reason = nullptr);
+ bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
+ lldb::SyntheticChildrenSP &entry);
void Clear(FormatCategoryItems items = ALL_ITEM_TYPES);
@@ -359,8 +305,6 @@
void AddLanguage(lldb::LanguageType lang);
- bool HasLanguage(lldb::LanguageType lang);
-
std::string GetDescription();
bool AnyMatches(ConstString type_name,
@@ -376,7 +320,6 @@
SummaryContainer m_summary_cont;
FilterContainer m_filter_cont;
SynthContainer m_synth_cont;
- ValidatorContainer m_validator_cont;
bool m_enabled;
@@ -394,7 +337,7 @@
void Disable() { Enable(false, UINT32_MAX); }
- bool IsApplicable(ValueObject &valobj);
+ bool IsApplicable(lldb::LanguageType lang);
uint32_t GetLastEnabledPosition() { return m_enabled_position; }
@@ -404,24 +347,15 @@
friend class LanguageCategory;
friend class TypeCategoryMap;
- friend class FormattersContainer<ConstString, TypeFormatImpl>;
- friend class FormattersContainer<lldb::RegularExpressionSP, TypeFormatImpl>;
+ friend class FormattersContainer<TypeFormatImpl>;
- friend class FormattersContainer<ConstString, TypeSummaryImpl>;
- friend class FormattersContainer<lldb::RegularExpressionSP, TypeSummaryImpl>;
+ friend class FormattersContainer<TypeSummaryImpl>;
- friend class FormattersContainer<ConstString, TypeFilterImpl>;
- friend class FormattersContainer<lldb::RegularExpressionSP, TypeFilterImpl>;
+ friend class FormattersContainer<TypeFilterImpl>;
- friend class FormattersContainer<ConstString, ScriptedSyntheticChildren>;
- friend class FormattersContainer<lldb::RegularExpressionSP,
- ScriptedSyntheticChildren>;
-
- friend class FormattersContainer<ConstString, TypeValidatorImpl>;
- friend class FormattersContainer<lldb::RegularExpressionSP,
- TypeValidatorImpl>;
+ friend class FormattersContainer<ScriptedSyntheticChildren>;
};
} // namespace lldb_private
-#endif // lldb_TypeCategory_h_
+#endif // LLDB_DATAFORMATTERS_TYPECATEGORY_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/TypeCategoryMap.h b/linux-x64/clang/include/lldb/DataFormatters/TypeCategoryMap.h
index 753b58c..4dbca29 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/TypeCategoryMap.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/TypeCategoryMap.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_TypeCategoryMap_h_
-#define lldb_TypeCategoryMap_h_
+#ifndef LLDB_DATAFORMATTERS_TYPECATEGORYMAP_H
+#define LLDB_DATAFORMATTERS_TYPECATEGORYMAP_H
#include <functional>
#include <list>
@@ -77,21 +77,15 @@
uint32_t GetCount() { return m_map.size(); }
- lldb::TypeFormatImplSP GetFormat(FormattersMatchData &match_data);
-
- lldb::TypeSummaryImplSP GetSummaryFormat(FormattersMatchData &match_data);
-
- lldb::SyntheticChildrenSP
- GetSyntheticChildren(FormattersMatchData &match_data);
-
- lldb::TypeValidatorImplSP GetValidator(FormattersMatchData &match_data);
+ template <typename ImplSP> void Get(FormattersMatchData &, ImplSP &);
private:
class delete_matching_categories {
lldb::TypeCategoryImplSP ptr;
public:
- delete_matching_categories(lldb::TypeCategoryImplSP p) : ptr(p) {}
+ delete_matching_categories(lldb::TypeCategoryImplSP p)
+ : ptr(std::move(p)) {}
bool operator()(const lldb::TypeCategoryImplSP &other) {
return ptr.get() == other.get();
@@ -110,9 +104,9 @@
std::recursive_mutex &mutex() { return m_map_mutex; }
- friend class FormattersContainer<KeyType, ValueType>;
+ friend class FormattersContainer<ValueType>;
friend class FormatManager;
};
} // namespace lldb_private
-#endif // lldb_TypeCategoryMap_h_
+#endif // LLDB_DATAFORMATTERS_TYPECATEGORYMAP_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/TypeFormat.h b/linux-x64/clang/include/lldb/DataFormatters/TypeFormat.h
index 77e8c0e..b8ed6a3 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/TypeFormat.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/TypeFormat.h
@@ -7,9 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_TypeFormat_h_
-#define lldb_TypeFormat_h_
-
+#ifndef LLDB_DATAFORMATTERS_TYPEFORMAT_H
+#define LLDB_DATAFORMATTERS_TYPEFORMAT_H
#include <functional>
#include <string>
@@ -153,7 +152,8 @@
uint32_t m_my_revision;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl);
+ TypeFormatImpl(const TypeFormatImpl &) = delete;
+ const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
};
class TypeFormatImpl_Format : public TypeFormatImpl {
@@ -181,7 +181,9 @@
lldb::Format m_format;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_Format);
+ TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete;
+ const TypeFormatImpl_Format &
+ operator=(const TypeFormatImpl_Format &) = delete;
};
class TypeFormatImpl_EnumType : public TypeFormatImpl {
@@ -210,8 +212,10 @@
mutable std::unordered_map<void *, CompilerType> m_types;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_EnumType);
+ TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &) = delete;
+ const TypeFormatImpl_EnumType &
+ operator=(const TypeFormatImpl_EnumType &) = delete;
};
} // namespace lldb_private
-#endif // lldb_TypeFormat_h_
+#endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/TypeSummary.h b/linux-x64/clang/include/lldb/DataFormatters/TypeSummary.h
index 9c97b36..ce3195d 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/TypeSummary.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/TypeSummary.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_TypeSummary_h_
-#define lldb_TypeSummary_h_
+#ifndef LLDB_DATAFORMATTERS_TYPESUMMARY_H
+#define LLDB_DATAFORMATTERS_TYPESUMMARY_H
#include <stdint.h>
@@ -270,7 +270,8 @@
private:
Kind m_kind;
- DISALLOW_COPY_AND_ASSIGN(TypeSummaryImpl);
+ TypeSummaryImpl(const TypeSummaryImpl &) = delete;
+ const TypeSummaryImpl &operator=(const TypeSummaryImpl &) = delete;
};
// simple string-based summaries, using ${var to show data
@@ -297,7 +298,8 @@
}
private:
- DISALLOW_COPY_AND_ASSIGN(StringSummaryFormat);
+ StringSummaryFormat(const StringSummaryFormat &) = delete;
+ const StringSummaryFormat &operator=(const StringSummaryFormat &) = delete;
};
// summaries implemented via a C++ function
@@ -320,7 +322,7 @@
const char *GetTextualInfo() const { return m_description.c_str(); }
- void SetBackendFunction(Callback cb_func) { m_impl = cb_func; }
+ void SetBackendFunction(Callback cb_func) { m_impl = std::move(cb_func); }
void SetTextualInfo(const char *descr) {
if (descr)
@@ -341,7 +343,9 @@
typedef std::shared_ptr<CXXFunctionSummaryFormat> SharedPointer;
private:
- DISALLOW_COPY_AND_ASSIGN(CXXFunctionSummaryFormat);
+ CXXFunctionSummaryFormat(const CXXFunctionSummaryFormat &) = delete;
+ const CXXFunctionSummaryFormat &
+ operator=(const CXXFunctionSummaryFormat &) = delete;
};
// Python-based summaries, running script code to show data
@@ -387,8 +391,9 @@
typedef std::shared_ptr<ScriptSummaryFormat> SharedPointer;
private:
- DISALLOW_COPY_AND_ASSIGN(ScriptSummaryFormat);
+ ScriptSummaryFormat(const ScriptSummaryFormat &) = delete;
+ const ScriptSummaryFormat &operator=(const ScriptSummaryFormat &) = delete;
};
} // namespace lldb_private
-#endif // lldb_TypeSummary_h_
+#endif // LLDB_DATAFORMATTERS_TYPESUMMARY_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/TypeSynthetic.h b/linux-x64/clang/include/lldb/DataFormatters/TypeSynthetic.h
index 93443cf..fa14582 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/TypeSynthetic.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/TypeSynthetic.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_TypeSynthetic_h_
-#define lldb_TypeSynthetic_h_
+#ifndef LLDB_DATAFORMATTERS_TYPESYNTHETIC_H
+#define LLDB_DATAFORMATTERS_TYPESYNTHETIC_H
#include <stdint.h>
@@ -96,7 +96,9 @@
private:
bool m_valid;
- DISALLOW_COPY_AND_ASSIGN(SyntheticChildrenFrontEnd);
+ SyntheticChildrenFrontEnd(const SyntheticChildrenFrontEnd &) = delete;
+ const SyntheticChildrenFrontEnd &
+ operator=(const SyntheticChildrenFrontEnd &) = delete;
};
class SyntheticValueProviderFrontEnd : public SyntheticChildrenFrontEnd {
@@ -121,7 +123,10 @@
lldb::ValueObjectSP GetSyntheticValue() override = 0;
private:
- DISALLOW_COPY_AND_ASSIGN(SyntheticValueProviderFrontEnd);
+ SyntheticValueProviderFrontEnd(const SyntheticValueProviderFrontEnd &) =
+ delete;
+ const SyntheticValueProviderFrontEnd &
+ operator=(const SyntheticValueProviderFrontEnd &) = delete;
};
class SyntheticChildren {
@@ -265,7 +270,8 @@
Flags m_flags;
private:
- DISALLOW_COPY_AND_ASSIGN(SyntheticChildren);
+ SyntheticChildren(const SyntheticChildren &) = delete;
+ const SyntheticChildren &operator=(const SyntheticChildren &) = delete;
};
class TypeFilterImpl : public SyntheticChildren {
@@ -333,7 +339,8 @@
private:
TypeFilterImpl *filter;
- DISALLOW_COPY_AND_ASSIGN(FrontEnd);
+ FrontEnd(const FrontEnd &) = delete;
+ const FrontEnd &operator=(const FrontEnd &) = delete;
};
SyntheticChildrenFrontEnd::AutoPointer
@@ -344,7 +351,8 @@
typedef std::shared_ptr<TypeFilterImpl> SharedPointer;
private:
- DISALLOW_COPY_AND_ASSIGN(TypeFilterImpl);
+ TypeFilterImpl(const TypeFilterImpl &) = delete;
+ const TypeFilterImpl &operator=(const TypeFilterImpl &) = delete;
};
class CXXSyntheticChildren : public SyntheticChildren {
@@ -354,7 +362,7 @@
CreateFrontEndCallback;
CXXSyntheticChildren(const SyntheticChildren::Flags &flags,
const char *description, CreateFrontEndCallback callback)
- : SyntheticChildren(flags), m_create_callback(callback),
+ : SyntheticChildren(flags), m_create_callback(std::move(callback)),
m_description(description ? description : "") {}
bool IsScripted() override { return false; }
@@ -372,7 +380,8 @@
std::string m_description;
private:
- DISALLOW_COPY_AND_ASSIGN(CXXSyntheticChildren);
+ CXXSyntheticChildren(const CXXSyntheticChildren &) = delete;
+ const CXXSyntheticChildren &operator=(const CXXSyntheticChildren &) = delete;
};
class ScriptedSyntheticChildren : public SyntheticChildren {
@@ -435,7 +444,8 @@
StructuredData::ObjectSP m_wrapper_sp;
ScriptInterpreter *m_interpreter;
- DISALLOW_COPY_AND_ASSIGN(FrontEnd);
+ FrontEnd(const FrontEnd &) = delete;
+ const FrontEnd &operator=(const FrontEnd &) = delete;
};
SyntheticChildrenFrontEnd::AutoPointer
@@ -448,8 +458,10 @@
}
private:
- DISALLOW_COPY_AND_ASSIGN(ScriptedSyntheticChildren);
+ ScriptedSyntheticChildren(const ScriptedSyntheticChildren &) = delete;
+ const ScriptedSyntheticChildren &
+ operator=(const ScriptedSyntheticChildren &) = delete;
};
} // namespace lldb_private
-#endif // lldb_TypeSynthetic_h_
+#endif // LLDB_DATAFORMATTERS_TYPESYNTHETIC_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/TypeValidator.h b/linux-x64/clang/include/lldb/DataFormatters/TypeValidator.h
deleted file mode 100644
index 531812e..0000000
--- a/linux-x64/clang/include/lldb/DataFormatters/TypeValidator.h
+++ /dev/null
@@ -1,201 +0,0 @@
-//===-- TypeValidator.h ------------------------------------------*- C++
-//-*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef lldb_TypeValidator_h_
-#define lldb_TypeValidator_h_
-
-
-#include <functional>
-#include <string>
-
-
-#include "lldb/lldb-enumerations.h"
-#include "lldb/lldb-private-enumerations.h"
-#include "lldb/lldb-public.h"
-
-namespace lldb_private {
-
-class TypeValidatorImpl {
-public:
- class Flags {
- public:
- Flags() : m_flags(lldb::eTypeOptionCascade) {}
-
- Flags(const Flags &other) : m_flags(other.m_flags) {}
-
- Flags(uint32_t value) : m_flags(value) {}
-
- Flags &operator=(const Flags &rhs) {
- if (&rhs != this)
- m_flags = rhs.m_flags;
-
- return *this;
- }
-
- Flags &operator=(const uint32_t &rhs) {
- m_flags = rhs;
- return *this;
- }
-
- Flags &Clear() {
- m_flags = 0;
- return *this;
- }
-
- bool GetCascades() const {
- return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade;
- }
-
- Flags &SetCascades(bool value = true) {
- if (value)
- m_flags |= lldb::eTypeOptionCascade;
- else
- m_flags &= ~lldb::eTypeOptionCascade;
- return *this;
- }
-
- bool GetSkipPointers() const {
- return (m_flags & lldb::eTypeOptionSkipPointers) ==
- lldb::eTypeOptionSkipPointers;
- }
-
- Flags &SetSkipPointers(bool value = true) {
- if (value)
- m_flags |= lldb::eTypeOptionSkipPointers;
- else
- m_flags &= ~lldb::eTypeOptionSkipPointers;
- return *this;
- }
-
- bool GetSkipReferences() const {
- return (m_flags & lldb::eTypeOptionSkipReferences) ==
- lldb::eTypeOptionSkipReferences;
- }
-
- Flags &SetSkipReferences(bool value = true) {
- if (value)
- m_flags |= lldb::eTypeOptionSkipReferences;
- else
- m_flags &= ~lldb::eTypeOptionSkipReferences;
- return *this;
- }
-
- bool GetNonCacheable() const {
- return (m_flags & lldb::eTypeOptionNonCacheable) ==
- lldb::eTypeOptionNonCacheable;
- }
-
- Flags &SetNonCacheable(bool value = true) {
- if (value)
- m_flags |= lldb::eTypeOptionNonCacheable;
- else
- m_flags &= ~lldb::eTypeOptionNonCacheable;
- return *this;
- }
-
- uint32_t GetValue() { return m_flags; }
-
- void SetValue(uint32_t value) { m_flags = value; }
-
- private:
- uint32_t m_flags;
- };
-
- TypeValidatorImpl(const Flags &flags = Flags());
-
- typedef std::shared_ptr<TypeValidatorImpl> SharedPointer;
-
- virtual ~TypeValidatorImpl();
-
- bool Cascades() const { return m_flags.GetCascades(); }
- bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
- bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
- bool NonCacheable() const { return m_flags.GetNonCacheable(); }
-
- void SetCascades(bool value) { m_flags.SetCascades(value); }
-
- void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }
-
- void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }
-
- void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }
-
- uint32_t GetOptions() { return m_flags.GetValue(); }
-
- void SetOptions(uint32_t value) { m_flags.SetValue(value); }
-
- uint32_t &GetRevision() { return m_my_revision; }
-
- enum class Type { eTypeUnknown, eTypeCXX };
-
- struct ValidationResult {
- TypeValidatorResult m_result;
- std::string m_message;
- };
-
- virtual Type GetType() { return Type::eTypeUnknown; }
-
- // we are using a ValueObject* instead of a ValueObjectSP because we do not
- // need to hold on to this for extended periods of time and we trust the
- // ValueObject to stay around for as long as it is required for us to
- // generate its value
- virtual ValidationResult FormatObject(ValueObject *valobj) const = 0;
-
- virtual std::string GetDescription() = 0;
-
- static ValidationResult Success();
-
- static ValidationResult Failure(std::string message);
-
-protected:
- Flags m_flags;
- uint32_t m_my_revision;
-
-private:
- DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl);
-};
-
-class TypeValidatorImpl_CXX : public TypeValidatorImpl {
-public:
- typedef std::function<TypeValidatorImpl::ValidationResult(
- ValueObject *valobj)>
- ValidatorFunction;
-
- TypeValidatorImpl_CXX(ValidatorFunction f, std::string d,
- const TypeValidatorImpl::Flags &flags = Flags());
-
- typedef std::shared_ptr<TypeValidatorImpl_CXX> SharedPointer;
-
- ~TypeValidatorImpl_CXX() override;
-
- ValidatorFunction GetValidatorFunction() const {
- return m_validator_function;
- }
-
- void SetValidatorFunction(ValidatorFunction f) { m_validator_function = f; }
-
- TypeValidatorImpl::Type GetType() override {
- return TypeValidatorImpl::Type::eTypeCXX;
- }
-
- ValidationResult FormatObject(ValueObject *valobj) const override;
-
- std::string GetDescription() override;
-
-protected:
- std::string m_description;
- ValidatorFunction m_validator_function;
-
-private:
- DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl_CXX);
-};
-
-} // namespace lldb_private
-
-#endif // lldb_TypeValidator_h_
diff --git a/linux-x64/clang/include/lldb/DataFormatters/ValueObjectPrinter.h b/linux-x64/clang/include/lldb/DataFormatters/ValueObjectPrinter.h
index 41adc2d..f1301d8 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/ValueObjectPrinter.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/ValueObjectPrinter.h
@@ -7,9 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef lldb_ValueObjectPrinter_h_
-#define lldb_ValueObjectPrinter_h_
-
+#ifndef LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H
+#define LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H
#include "lldb/lldb-private.h"
#include "lldb/lldb-public.h"
@@ -58,12 +57,10 @@
const char *GetDescriptionForDisplay();
- const char *GetRootNameForDisplay(const char *if_fail = nullptr);
+ const char *GetRootNameForDisplay();
bool ShouldPrintValueObject();
- bool ShouldPrintValidation();
-
bool IsNil();
bool IsUninitialized();
@@ -76,10 +73,6 @@
bool IsAggregate();
- bool PrintValidationMarkerIfNeeded();
-
- bool PrintValidationErrorIfNeeded();
-
bool PrintLocationIfNeeded();
void PrintDecl();
@@ -145,13 +138,13 @@
std::string m_summary;
std::string m_error;
bool m_val_summary_ok;
- std::pair<TypeValidatorResult, std::string> m_validation;
friend struct StringSummaryFormat;
- DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
+ ValueObjectPrinter(const ValueObjectPrinter &) = delete;
+ const ValueObjectPrinter &operator=(const ValueObjectPrinter &) = delete;
};
} // namespace lldb_private
-#endif // lldb_ValueObjectPrinter_h_
+#endif // LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/VectorIterator.h b/linux-x64/clang/include/lldb/DataFormatters/VectorIterator.h
index cde4be4..33650a3 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/VectorIterator.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/VectorIterator.h
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_VectorIterator_h_
-#define liblldb_VectorIterator_h_
+#ifndef LLDB_DATAFORMATTERS_VECTORITERATOR_H
+#define LLDB_DATAFORMATTERS_VECTORITERATOR_H
#include "lldb/lldb-forward.h"
@@ -42,4 +42,4 @@
} // namespace formatters
} // namespace lldb_private
-#endif // liblldb_CF_h_
+#endif // LLDB_DATAFORMATTERS_VECTORITERATOR_H
diff --git a/linux-x64/clang/include/lldb/DataFormatters/VectorType.h b/linux-x64/clang/include/lldb/DataFormatters/VectorType.h
index b757f75..6a66b18 100644
--- a/linux-x64/clang/include/lldb/DataFormatters/VectorType.h
+++ b/linux-x64/clang/include/lldb/DataFormatters/VectorType.h
@@ -6,8 +6,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef liblldb_VectorType_h_
-#define liblldb_VectorType_h_
+#ifndef LLDB_DATAFORMATTERS_VECTORTYPE_H
+#define LLDB_DATAFORMATTERS_VECTORTYPE_H
#include "lldb/lldb-forward.h"
@@ -21,4 +21,4 @@
} // namespace formatters
} // namespace lldb_private
-#endif // liblldb_VectorType_h_
+#endif // LLDB_DATAFORMATTERS_VECTORTYPE_H