LLDB  mainline
TypeFormat.h
Go to the documentation of this file.
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 {
25 public:
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:
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 
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:
153 
154 private:
156 };
157 
159 public:
161  const TypeFormatImpl::Flags &flags = Flags());
162 
163  typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;
164 
165  ~TypeFormatImpl_Format() override;
166 
167  lldb::Format GetFormat() const { return m_format; }
168 
169  void SetFormat(lldb::Format fmt) { m_format = fmt; }
170 
173  }
174 
175  bool FormatObject(ValueObject *valobj, std::string &dest) const override;
176 
177  std::string GetDescription() override;
178 
179 protected:
181 
182 private:
184 };
185 
187 public:
189  const TypeFormatImpl::Flags &flags = Flags());
190 
191  typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;
192 
193  ~TypeFormatImpl_EnumType() override;
194 
195  ConstString GetTypeName() { return m_enum_type; }
196 
197  void SetTypeName(ConstString enum_type) { m_enum_type = enum_type; }
198 
201  }
202 
203  bool FormatObject(ValueObject *valobj, std::string &dest) const override;
204 
205  std::string GetDescription() override;
206 
207 protected:
209  mutable std::unordered_map<void *, CompilerType> m_types;
210 
211 private:
213 };
214 } // namespace lldb_private
215 
216 #endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H
A class that represents a running process on the host machine.
virtual bool FormatObject(ValueObject *valobj, std::string &dest) const =0
std::shared_ptr< TypeFormatImpl_Format > SharedPointer
Definition: TypeFormat.h:163
Flags & SetSkipReferences(bool value=true)
Definition: TypeFormat.h:81
Flags & operator=(const uint32_t &rhs)
Definition: TypeFormat.h:41
std::shared_ptr< TypeFormatImpl > SharedPointer
Definition: TypeFormat.h:112
TypeFormatImpl::Type GetType() override
Definition: TypeFormat.h:199
std::unordered_map< void *, CompilerType > m_types
Definition: TypeFormat.h:209
Format
Display format definitions.
void SetTypeName(ConstString enum_type)
Definition: TypeFormat.h:197
Flags & operator=(const Flags &rhs)
Definition: TypeFormat.h:34
void SetOptions(uint32_t value)
Definition: TypeFormat.h:134
void SetNonCacheable(bool value)
Definition: TypeFormat.h:130
void SetSkipsPointers(bool value)
Definition: TypeFormat.h:126
void SetValue(uint32_t value)
Definition: TypeFormat.h:104
void SetFormat(lldb::Format fmt)
Definition: TypeFormat.h:169
TypeFormatImpl(const Flags &flags=Flags())
Definition: TypeFormat.cpp:30
void SetSkipsReferences(bool value)
Definition: TypeFormat.h:128
TypeFormatImpl::Type GetType() override
Definition: TypeFormat.h:171
A uniqued constant string class.
Definition: ConstString.h:40
Flags & SetNonCacheable(bool value=true)
Definition: TypeFormat.h:94
Definition: SBAddress.h:15
DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl)
Flags & SetCascades(bool value=true)
Definition: TypeFormat.h:55
virtual std::string GetDescription()=0
std::shared_ptr< TypeFormatImpl_EnumType > SharedPointer
Definition: TypeFormat.h:191
lldb::Format GetFormat() const
Definition: TypeFormat.h:167
void SetCascades(bool value)
Definition: TypeFormat.h:124
Flags & SetSkipPointers(bool value=true)
Definition: TypeFormat.h:68