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 
19 SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
20   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
21 }
22 
23 SBTypeFilter::SBTypeFilter(uint32_t options)
24     : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
25   LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
26 }
27 
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 
35 bool SBTypeFilter::IsValid() const {
36   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
37   return this->operator bool();
38 }
39 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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
169 lldb::TypeFilterImplSP SBTypeFilter::GetSP() { return m_opaque_sp; }
170 
171 void SBTypeFilter::SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp) {
172   m_opaque_sp = typefilter_impl_sp;
173 }
174 
175 SBTypeFilter::SBTypeFilter(const lldb::TypeFilterImplSP &typefilter_impl_sp)
176     : m_opaque_sp(typefilter_impl_sp) {}
177 
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 <>
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