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