1 //===-- SBValueList.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/SBValueList.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBStream.h"
12 #include "lldb/API/SBValue.h"
13 #include "lldb/Core/ValueObjectList.h"
14
15 #include <vector>
16
17 using namespace lldb;
18 using namespace lldb_private;
19
20 class ValueListImpl {
21 public:
ValueListImpl()22 ValueListImpl() : m_values() {}
23
ValueListImpl(const ValueListImpl & rhs)24 ValueListImpl(const ValueListImpl &rhs) : m_values(rhs.m_values) {}
25
operator =(const ValueListImpl & rhs)26 ValueListImpl &operator=(const ValueListImpl &rhs) {
27 if (this == &rhs)
28 return *this;
29 m_values = rhs.m_values;
30 return *this;
31 }
32
GetSize()33 uint32_t GetSize() { return m_values.size(); }
34
Append(const lldb::SBValue & sb_value)35 void Append(const lldb::SBValue &sb_value) { m_values.push_back(sb_value); }
36
Append(const ValueListImpl & list)37 void Append(const ValueListImpl &list) {
38 for (auto val : list.m_values)
39 Append(val);
40 }
41
GetValueAtIndex(uint32_t index)42 lldb::SBValue GetValueAtIndex(uint32_t index) {
43 if (index >= GetSize())
44 return lldb::SBValue();
45 return m_values[index];
46 }
47
FindValueByUID(lldb::user_id_t uid)48 lldb::SBValue FindValueByUID(lldb::user_id_t uid) {
49 for (auto val : m_values) {
50 if (val.IsValid() && val.GetID() == uid)
51 return val;
52 }
53 return lldb::SBValue();
54 }
55
GetFirstValueByName(const char * name) const56 lldb::SBValue GetFirstValueByName(const char *name) const {
57 if (name) {
58 for (auto val : m_values) {
59 if (val.IsValid() && val.GetName() && strcmp(name, val.GetName()) == 0)
60 return val;
61 }
62 }
63 return lldb::SBValue();
64 }
65
66 private:
67 std::vector<lldb::SBValue> m_values;
68 };
69
SBValueList()70 SBValueList::SBValueList() : m_opaque_up() {
71 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
72 }
73
SBValueList(const SBValueList & rhs)74 SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
75 LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
76
77 if (rhs.IsValid())
78 m_opaque_up = std::make_unique<ValueListImpl>(*rhs);
79 }
80
SBValueList(const ValueListImpl * lldb_object_ptr)81 SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
82 if (lldb_object_ptr)
83 m_opaque_up = std::make_unique<ValueListImpl>(*lldb_object_ptr);
84 }
85
86 SBValueList::~SBValueList() = default;
87
IsValid() const88 bool SBValueList::IsValid() const {
89 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
90 return this->operator bool();
91 }
operator bool() const92 SBValueList::operator bool() const {
93 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
94
95 return (m_opaque_up != nullptr);
96 }
97
Clear()98 void SBValueList::Clear() {
99 LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
100
101 m_opaque_up.reset();
102 }
103
operator =(const SBValueList & rhs)104 const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
105 LLDB_RECORD_METHOD(const lldb::SBValueList &,
106 SBValueList, operator=,(const lldb::SBValueList &), rhs);
107
108 if (this != &rhs) {
109 if (rhs.IsValid())
110 m_opaque_up = std::make_unique<ValueListImpl>(*rhs);
111 else
112 m_opaque_up.reset();
113 }
114 return LLDB_RECORD_RESULT(*this);
115 }
116
operator ->()117 ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
118
operator *()119 ValueListImpl &SBValueList::operator*() { return *m_opaque_up; }
120
operator ->() const121 const ValueListImpl *SBValueList::operator->() const {
122 return m_opaque_up.get();
123 }
124
operator *() const125 const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
126
Append(const SBValue & val_obj)127 void SBValueList::Append(const SBValue &val_obj) {
128 LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
129 val_obj);
130
131 CreateIfNeeded();
132 m_opaque_up->Append(val_obj);
133 }
134
Append(lldb::ValueObjectSP & val_obj_sp)135 void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
136 if (val_obj_sp) {
137 CreateIfNeeded();
138 m_opaque_up->Append(SBValue(val_obj_sp));
139 }
140 }
141
Append(const lldb::SBValueList & value_list)142 void SBValueList::Append(const lldb::SBValueList &value_list) {
143 LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
144 value_list);
145
146 if (value_list.IsValid()) {
147 CreateIfNeeded();
148 m_opaque_up->Append(*value_list);
149 }
150 }
151
GetValueAtIndex(uint32_t idx) const152 SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
153 LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
154 (uint32_t), idx);
155
156
157 SBValue sb_value;
158 if (m_opaque_up)
159 sb_value = m_opaque_up->GetValueAtIndex(idx);
160
161 return LLDB_RECORD_RESULT(sb_value);
162 }
163
GetSize() const164 uint32_t SBValueList::GetSize() const {
165 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
166
167 uint32_t size = 0;
168 if (m_opaque_up)
169 size = m_opaque_up->GetSize();
170
171 return size;
172 }
173
CreateIfNeeded()174 void SBValueList::CreateIfNeeded() {
175 if (m_opaque_up == nullptr)
176 m_opaque_up = std::make_unique<ValueListImpl>();
177 }
178
FindValueObjectByUID(lldb::user_id_t uid)179 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
180 LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
181 (lldb::user_id_t), uid);
182
183 SBValue sb_value;
184 if (m_opaque_up)
185 sb_value = m_opaque_up->FindValueByUID(uid);
186 return LLDB_RECORD_RESULT(sb_value);
187 }
188
GetFirstValueByName(const char * name) const189 SBValue SBValueList::GetFirstValueByName(const char *name) const {
190 LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
191 (const char *), name);
192
193 SBValue sb_value;
194 if (m_opaque_up)
195 sb_value = m_opaque_up->GetFirstValueByName(name);
196 return LLDB_RECORD_RESULT(sb_value);
197 }
198
opaque_ptr()199 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
200
ref()201 ValueListImpl &SBValueList::ref() {
202 CreateIfNeeded();
203 return *m_opaque_up;
204 }
205
206 namespace lldb_private {
207 namespace repro {
208
209 template <>
RegisterMethods(Registry & R)210 void RegisterMethods<SBValueList>(Registry &R) {
211 LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
212 LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
213 LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
214 LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
215 LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
216 LLDB_REGISTER_METHOD(const lldb::SBValueList &,
217 SBValueList, operator=,(const lldb::SBValueList &));
218 LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
219 LLDB_REGISTER_METHOD(void, SBValueList, Append,
220 (const lldb::SBValueList &));
221 LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
222 (uint32_t));
223 LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
224 LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
225 (lldb::user_id_t));
226 LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
227 (const char *));
228 }
229
230 }
231 }
232