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
23namespace lldb_private {
24class TypeFormatImpl {
25public:
26 class Flags {
27 public:
28 Flags() : m_flags(lldb::eTypeOptionCascade) {}
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;
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
150protected:
151 Flags m_flags;
152 uint32_t m_my_revision;
153
154private:
155 TypeFormatImpl(const TypeFormatImpl &) = delete;
156 const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
157};
158
159class TypeFormatImpl_Format : public TypeFormatImpl {
160public:
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
180protected:
181 lldb::Format m_format;
182
183private:
184 TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete;
185 const TypeFormatImpl_Format &
186 operator=(const TypeFormatImpl_Format &) = delete;
187};
188
189class TypeFormatImpl_EnumType : public TypeFormatImpl {
190public:
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
210protected:
211 ConstString m_enum_type;
212 mutable std::unordered_map<void *, CompilerType> m_types;
213
214private:
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