1 //===-- SBStructuredData.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/SBStructuredData.h"
10 #include "SBReproducerPrivate.h"
11
12 #include "lldb/API/SBStream.h"
13 #include "lldb/API/SBStringList.h"
14 #include "lldb/Core/StructuredDataImpl.h"
15 #include "lldb/Target/StructuredDataPlugin.h"
16 #include "lldb/Utility/Event.h"
17 #include "lldb/Utility/Status.h"
18 #include "lldb/Utility/Stream.h"
19 #include "lldb/Utility/StructuredData.h"
20
21 using namespace lldb;
22 using namespace lldb_private;
23
24 #pragma mark--
25 #pragma mark SBStructuredData
26
SBStructuredData()27 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
28 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData);
29 }
30
SBStructuredData(const lldb::SBStructuredData & rhs)31 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
32 : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
33 LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &),
34 rhs);
35 }
36
SBStructuredData(const lldb::EventSP & event_sp)37 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
38 : m_impl_up(new StructuredDataImpl(event_sp)) {
39 LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &), event_sp);
40 }
41
SBStructuredData(lldb_private::StructuredDataImpl * impl)42 SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl)
43 : m_impl_up(impl ? impl : new StructuredDataImpl()) {
44 LLDB_RECORD_CONSTRUCTOR(SBStructuredData,
45 (lldb_private::StructuredDataImpl *), impl);
46 }
47
48 SBStructuredData::~SBStructuredData() = default;
49
50 SBStructuredData &SBStructuredData::
operator =(const lldb::SBStructuredData & rhs)51 operator=(const lldb::SBStructuredData &rhs) {
52 LLDB_RECORD_METHOD(
53 lldb::SBStructuredData &,
54 SBStructuredData, operator=,(const lldb::SBStructuredData &), rhs);
55
56 *m_impl_up = *rhs.m_impl_up;
57 return LLDB_RECORD_RESULT(*this);
58 }
59
SetFromJSON(lldb::SBStream & stream)60 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
61 LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
62 (lldb::SBStream &), stream);
63
64 lldb::SBError error;
65 std::string json_str(stream.GetData());
66
67 StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str);
68 m_impl_up->SetObjectSP(json_obj);
69
70 if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
71 error.SetErrorString("Invalid Syntax");
72 return LLDB_RECORD_RESULT(error);
73 }
74
SetFromJSON(const char * json)75 lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
76 LLDB_RECORD_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
77 (const char *), json);
78 lldb::SBStream s;
79 s.Print(json);
80 return LLDB_RECORD_RESULT(SetFromJSON(s));
81 }
82
IsValid() const83 bool SBStructuredData::IsValid() const {
84 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
85 return this->operator bool();
86 }
87
operator bool() const88 SBStructuredData::operator bool() const {
89 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool);
90
91 return m_impl_up->IsValid();
92 }
93
Clear()94 void SBStructuredData::Clear() {
95 LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
96
97 m_impl_up->Clear();
98 }
99
GetAsJSON(lldb::SBStream & stream) const100 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
101 LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
102 (lldb::SBStream &), stream);
103
104 SBError error;
105 error.SetError(m_impl_up->GetAsJSON(stream.ref()));
106 return LLDB_RECORD_RESULT(error);
107 }
108
GetDescription(lldb::SBStream & stream) const109 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
110 LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
111 (lldb::SBStream &), stream);
112
113 Status error = m_impl_up->GetDescription(stream.ref());
114 SBError sb_error;
115 sb_error.SetError(error);
116 return LLDB_RECORD_RESULT(sb_error);
117 }
118
GetType() const119 StructuredDataType SBStructuredData::GetType() const {
120 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData,
121 GetType);
122
123 return m_impl_up->GetType();
124 }
125
GetSize() const126 size_t SBStructuredData::GetSize() const {
127 LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize);
128
129 return m_impl_up->GetSize();
130 }
131
GetKeys(lldb::SBStringList & keys) const132 bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
133 LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys,
134 (lldb::SBStringList &), keys);
135
136 if (GetType() != eStructuredDataTypeDictionary)
137 return false;
138
139 StructuredData::ObjectSP obj_sp = m_impl_up->GetObjectSP();
140 if (!obj_sp)
141 return false;
142
143 StructuredData::Dictionary *dict = obj_sp->GetAsDictionary();
144 // We claimed we were a dictionary, so this can't be null.
145 assert(dict);
146 // The return kind of GetKeys is an Array:
147 StructuredData::ObjectSP array_sp = dict->GetKeys();
148 StructuredData::Array *key_arr = array_sp->GetAsArray();
149 assert(key_arr);
150
151 key_arr->ForEach([&keys] (StructuredData::Object *object) -> bool {
152 llvm::StringRef key = object->GetStringValue("");
153 keys.AppendString(key.str().c_str());
154 return true;
155 });
156 return true;
157 }
158
GetValueForKey(const char * key) const159 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
160 LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
161 GetValueForKey, (const char *), key);
162
163 SBStructuredData result;
164 result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
165 return LLDB_RECORD_RESULT(result);
166 }
167
GetItemAtIndex(size_t idx) const168 lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
169 LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
170 GetItemAtIndex, (size_t), idx);
171
172 SBStructuredData result;
173 result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
174 return LLDB_RECORD_RESULT(result);
175 }
176
GetIntegerValue(uint64_t fail_value) const177 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
178 LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
179 (uint64_t), fail_value);
180
181 return m_impl_up->GetIntegerValue(fail_value);
182 }
183
GetFloatValue(double fail_value) const184 double SBStructuredData::GetFloatValue(double fail_value) const {
185 LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double),
186 fail_value);
187
188 return m_impl_up->GetFloatValue(fail_value);
189 }
190
GetBooleanValue(bool fail_value) const191 bool SBStructuredData::GetBooleanValue(bool fail_value) const {
192 LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
193 fail_value);
194
195 return m_impl_up->GetBooleanValue(fail_value);
196 }
197
GetStringValue(char * dst,size_t dst_len) const198 size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
199 LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
200 (char *, size_t), dst, "", dst_len);
201
202 return m_impl_up->GetStringValue(dst, dst_len);
203 }
204
205 namespace lldb_private {
206 namespace repro {
207
RegisterMethods(Registry & R)208 template <> void RegisterMethods<SBStructuredData>(Registry &R) {
209 LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
210 LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &));
211 LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
212 LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
213 (lldb_private::StructuredDataImpl *));
214 LLDB_REGISTER_METHOD(
215 lldb::SBStructuredData &,
216 SBStructuredData, operator=,(const lldb::SBStructuredData &));
217 LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
218 (lldb::SBStream &));
219 LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
220 (const char *));
221 LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
222 LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
223 LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
224 LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
225 (lldb::SBStream &));
226 LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
227 (lldb::SBStream &));
228 LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
229 GetType, ());
230 LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
231 LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetKeys,
232 (lldb::SBStringList &));
233 LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
234 GetValueForKey, (const char *));
235 LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
236 GetItemAtIndex, (size_t));
237 LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
238 (uint64_t));
239 LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double));
240 LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
241 LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue);
242 }
243
244 } // namespace repro
245 } // namespace lldb_private
246