1 //===-- SBTypeFilter.cpp --------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "lldb/API/SBTypeFilter.h"
10 #include "SBReproducerPrivate.h"
11
12 #include "lldb/API/SBStream.h"
13
14 #include "lldb/DataFormatters/DataVisualization.h"
15
16 using namespace lldb;
17 using namespace lldb_private;
18
SBTypeFilter()19 SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
20 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
21 }
22
SBTypeFilter(uint32_t options)23 SBTypeFilter::SBTypeFilter(uint32_t options)
24 : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
25 LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
26 }
27
SBTypeFilter(const lldb::SBTypeFilter & rhs)28 SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
29 : m_opaque_sp(rhs.m_opaque_sp) {
30 LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
31 }
32
33 SBTypeFilter::~SBTypeFilter() = default;
34
IsValid() const35 bool SBTypeFilter::IsValid() const {
36 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
37 return this->operator bool();
38 }
operator bool() const39 SBTypeFilter::operator bool() const {
40 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
41
42 return m_opaque_sp.get() != nullptr;
43 }
44
GetOptions()45 uint32_t SBTypeFilter::GetOptions() {
46 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
47
48 if (IsValid())
49 return m_opaque_sp->GetOptions();
50 return 0;
51 }
52
SetOptions(uint32_t value)53 void SBTypeFilter::SetOptions(uint32_t value) {
54 LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
55
56 if (CopyOnWrite_Impl())
57 m_opaque_sp->SetOptions(value);
58 }
59
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)60 bool SBTypeFilter::GetDescription(lldb::SBStream &description,
61 lldb::DescriptionLevel description_level) {
62 LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
63 (lldb::SBStream &, lldb::DescriptionLevel), description,
64 description_level);
65
66 if (!IsValid())
67 return false;
68 else {
69 description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
70 return true;
71 }
72 }
73
Clear()74 void SBTypeFilter::Clear() {
75 LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
76
77 if (CopyOnWrite_Impl())
78 m_opaque_sp->Clear();
79 }
80
GetNumberOfExpressionPaths()81 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
82 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
83 GetNumberOfExpressionPaths);
84
85 if (IsValid())
86 return m_opaque_sp->GetCount();
87 return 0;
88 }
89
GetExpressionPathAtIndex(uint32_t i)90 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
91 LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
92 (uint32_t), i);
93
94 if (IsValid()) {
95 const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
96 if (item && *item == '.')
97 item++;
98 return item;
99 }
100 return nullptr;
101 }
102
ReplaceExpressionPathAtIndex(uint32_t i,const char * item)103 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
104 LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
105 (uint32_t, const char *), i, item);
106
107 if (CopyOnWrite_Impl())
108 return m_opaque_sp->SetExpressionPathAtIndex(i, item);
109 else
110 return false;
111 }
112
AppendExpressionPath(const char * item)113 void SBTypeFilter::AppendExpressionPath(const char *item) {
114 LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
115 item);
116
117 if (CopyOnWrite_Impl())
118 m_opaque_sp->AddExpressionPath(item);
119 }
120
operator =(const lldb::SBTypeFilter & rhs)121 lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
122 LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
123 SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
124
125 if (this != &rhs) {
126 m_opaque_sp = rhs.m_opaque_sp;
127 }
128 return LLDB_RECORD_RESULT(*this);
129 }
130
operator ==(lldb::SBTypeFilter & rhs)131 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
132 LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
133 rhs);
134
135 if (!IsValid())
136 return !rhs.IsValid();
137
138 return m_opaque_sp == rhs.m_opaque_sp;
139 }
140
IsEqualTo(lldb::SBTypeFilter & rhs)141 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
142 LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
143 rhs);
144
145 if (!IsValid())
146 return !rhs.IsValid();
147
148 if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths())
149 return false;
150
151 for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
152 if (strcmp(GetExpressionPathAtIndex(j), rhs.GetExpressionPathAtIndex(j)) !=
153 0)
154 return false;
155
156 return GetOptions() == rhs.GetOptions();
157 }
158
operator !=(lldb::SBTypeFilter & rhs)159 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
160 LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
161 rhs);
162
163 if (!IsValid())
164 return !rhs.IsValid();
165
166 return m_opaque_sp != rhs.m_opaque_sp;
167 }
168
GetSP()169 lldb::TypeFilterImplSP SBTypeFilter::GetSP() { return m_opaque_sp; }
170
SetSP(const lldb::TypeFilterImplSP & typefilter_impl_sp)171 void SBTypeFilter::SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp) {
172 m_opaque_sp = typefilter_impl_sp;
173 }
174
SBTypeFilter(const lldb::TypeFilterImplSP & typefilter_impl_sp)175 SBTypeFilter::SBTypeFilter(const lldb::TypeFilterImplSP &typefilter_impl_sp)
176 : m_opaque_sp(typefilter_impl_sp) {}
177
CopyOnWrite_Impl()178 bool SBTypeFilter::CopyOnWrite_Impl() {
179 if (!IsValid())
180 return false;
181 if (m_opaque_sp.unique())
182 return true;
183
184 TypeFilterImplSP new_sp(new TypeFilterImpl(GetOptions()));
185
186 for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
187 new_sp->AddExpressionPath(GetExpressionPathAtIndex(j));
188
189 SetSP(new_sp);
190
191 return true;
192 }
193
194 namespace lldb_private {
195 namespace repro {
196
197 template <>
RegisterMethods(Registry & R)198 void RegisterMethods<SBTypeFilter>(Registry &R) {
199 LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
200 LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
201 LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
202 LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
203 LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
204 LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
205 LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
206 LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
207 (lldb::SBStream &, lldb::DescriptionLevel));
208 LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
209 LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
210 ());
211 LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
212 (uint32_t));
213 LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
214 (uint32_t, const char *));
215 LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
216 (const char *));
217 LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
218 SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
219 LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
220 LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
221 LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
222 }
223
224 }
225 }
226