1 | //===-- TypeFormat.h ----------------------------------------------*- C++ |
---|---|
2 | //-*-===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef LLDB_DATAFORMATTERS_TYPEFORMAT_H |
11 | #define LLDB_DATAFORMATTERS_TYPEFORMAT_H |
12 | |
13 | #include <functional> |
14 | #include <string> |
15 | #include <unordered_map> |
16 | |
17 | |
18 | #include "lldb/lldb-enumerations.h" |
19 | #include "lldb/lldb-public.h" |
20 | |
21 | #include "lldb/Core/ValueObject.h" |
22 | |
23 | namespace lldb_private { |
24 | class TypeFormatImpl { |
25 | public: |
26 | class Flags { |
27 | public: |
28 | Flags() {} |
29 | |
30 | Flags(const Flags &other) : m_flags(other.m_flags) {} |
31 | |
32 | Flags(uint32_t value) : m_flags(value) {} |
33 | |
34 | Flags &operator=(const Flags &rhs) { |
35 | if (&rhs != this) |
36 | m_flags = rhs.m_flags; |
37 | |
38 | return *this; |
39 | } |
40 | |
41 | Flags &operator=(const uint32_t &rhs) { |
42 | m_flags = rhs; |
43 | return *this; |
44 | } |
45 | |
46 | Flags &Clear() { |
47 | m_flags = 0; |
48 | return *this; |
49 | } |
50 | |
51 | bool GetCascades() const { |
52 | return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade; |
53 | } |
54 | |
55 | Flags &SetCascades(bool value = true) { |
56 | if (value) |
57 | m_flags |= lldb::eTypeOptionCascade; |
58 | else |
59 | m_flags &= ~lldb::eTypeOptionCascade; |
60 | return *this; |
61 | } |
62 | |
63 | bool GetSkipPointers() const { |
64 | return (m_flags & lldb::eTypeOptionSkipPointers) == |
65 | lldb::eTypeOptionSkipPointers; |
66 | } |
67 | |
68 | Flags &SetSkipPointers(bool value = true) { |
69 | if (value) |
70 | m_flags |= lldb::eTypeOptionSkipPointers; |
71 | else |
72 | m_flags &= ~lldb::eTypeOptionSkipPointers; |
73 | return *this; |
74 | } |
75 | |
76 | bool GetSkipReferences() const { |
77 | return (m_flags & lldb::eTypeOptionSkipReferences) == |
78 | lldb::eTypeOptionSkipReferences; |
79 | } |
80 | |
81 | Flags &SetSkipReferences(bool value = true) { |
82 | if (value) |
83 | m_flags |= lldb::eTypeOptionSkipReferences; |
84 | else |
85 | m_flags &= ~lldb::eTypeOptionSkipReferences; |
86 | return *this; |
87 | } |
88 | |
89 | bool GetNonCacheable() const { |
90 | return (m_flags & lldb::eTypeOptionNonCacheable) == |
91 | lldb::eTypeOptionNonCacheable; |
92 | } |
93 | |
94 | Flags &SetNonCacheable(bool value = true) { |
95 | if (value) |
96 | m_flags |= lldb::eTypeOptionNonCacheable; |
97 | else |
98 | m_flags &= ~lldb::eTypeOptionNonCacheable; |
99 | return *this; |
100 | } |
101 | |
102 | uint32_t GetValue() { return m_flags; } |
103 | |
104 | void SetValue(uint32_t value) { m_flags = value; } |
105 | |
106 | private: |
107 | uint32_t m_flags = lldb::eTypeOptionCascade; |
108 | }; |
109 | |
110 | TypeFormatImpl(const Flags &flags = Flags()); |
111 | |
112 | typedef std::shared_ptr<TypeFormatImpl> SharedPointer; |
113 | |
114 | virtual ~TypeFormatImpl(); |
115 | |
116 | bool Cascades() const { return m_flags.GetCascades(); } |
117 | |
118 | bool SkipsPointers() const { return m_flags.GetSkipPointers(); } |
119 | |
120 | bool SkipsReferences() const { return m_flags.GetSkipReferences(); } |
121 | |
122 | bool NonCacheable() const { return m_flags.GetNonCacheable(); } |
123 | |
124 | void SetCascades(bool value) { m_flags.SetCascades(value); } |
125 | |
126 | void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); } |
127 | |
128 | void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); } |
129 | |
130 | void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); } |
131 | |
132 | uint32_t GetOptions() { return m_flags.GetValue(); } |
133 | |
134 | void SetOptions(uint32_t value) { m_flags.SetValue(value); } |
135 | |
136 | uint32_t &GetRevision() { return m_my_revision; } |
137 | |
138 | enum class Type { eTypeUnknown, eTypeFormat, eTypeEnum }; |
139 | |
140 | virtual Type GetType() { return Type::eTypeUnknown; } |
141 | |
142 | // we are using a ValueObject* instead of a ValueObjectSP because we do not |
143 | // need to hold on to this for extended periods of time and we trust the |
144 | // ValueObject to stay around for as long as it is required for us to |
145 | // generate its value |
146 | virtual bool FormatObject(ValueObject *valobj, std::string &dest) const = 0; |
147 | |
148 | virtual std::string GetDescription() = 0; |
149 | |
150 | protected: |
151 | Flags m_flags; |
152 | uint32_t m_my_revision = 0; |
153 | |
154 | private: |
155 | TypeFormatImpl(const TypeFormatImpl &) = delete; |
156 | const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete; |
157 | }; |
158 | |
159 | class TypeFormatImpl_Format : public TypeFormatImpl { |
160 | public: |
161 | TypeFormatImpl_Format(lldb::Format f = lldb::eFormatInvalid, |
162 | const TypeFormatImpl::Flags &flags = Flags()); |
163 | |
164 | typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer; |
165 | |
166 | ~TypeFormatImpl_Format() override; |
167 | |
168 | lldb::Format GetFormat() const { return m_format; } |
169 | |
170 | void SetFormat(lldb::Format fmt) { m_format = fmt; } |
171 | |
172 | TypeFormatImpl::Type GetType() override { |
173 | return TypeFormatImpl::Type::eTypeFormat; |
174 | } |
175 | |
176 | bool FormatObject(ValueObject *valobj, std::string &dest) const override; |
177 | |
178 | std::string GetDescription() override; |
179 | |
180 | protected: |
181 | lldb::Format m_format; |
182 | |
183 | private: |
184 | TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete; |
185 | const TypeFormatImpl_Format & |
186 | operator=(const TypeFormatImpl_Format &) = delete; |
187 | }; |
188 | |
189 | class TypeFormatImpl_EnumType : public TypeFormatImpl { |
190 | public: |
191 | TypeFormatImpl_EnumType(ConstString type_name = ConstString(""), |
192 | const TypeFormatImpl::Flags &flags = Flags()); |
193 | |
194 | typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer; |
195 | |
196 | ~TypeFormatImpl_EnumType() override; |
197 | |
198 | ConstString GetTypeName() { return m_enum_type; } |
199 | |
200 | void SetTypeName(ConstString enum_type) { m_enum_type = enum_type; } |
201 | |
202 | TypeFormatImpl::Type GetType() override { |
203 | return TypeFormatImpl::Type::eTypeEnum; |
204 | } |
205 | |
206 | bool FormatObject(ValueObject *valobj, std::string &dest) const override; |
207 | |
208 | std::string GetDescription() override; |
209 | |
210 | protected: |
211 | ConstString m_enum_type; |
212 | mutable std::unordered_map<void *, CompilerType> m_types; |
213 | |
214 | private: |
215 | TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &) = delete; |
216 | const TypeFormatImpl_EnumType & |
217 | operator=(const TypeFormatImpl_EnumType &) = delete; |
218 | }; |
219 | } // namespace lldb_private |
220 | |
221 | #endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H |
222 |