1 //===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===// 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 27 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) { 28 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStructuredData); 29 } 30 31 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs) 32 : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up.get())) { 33 LLDB_RECORD_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &), 34 rhs); 35 } 36 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 42 SBStructuredData::SBStructuredData(lldb_private::StructuredDataImpl *impl) 43 : m_impl_up(impl) { 44 LLDB_RECORD_CONSTRUCTOR(SBStructuredData, 45 (lldb_private::StructuredDataImpl *), impl); 46 } 47 48 SBStructuredData::~SBStructuredData() {} 49 50 SBStructuredData &SBStructuredData:: 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 *this; 58 } 59 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 75 bool SBStructuredData::IsValid() const { 76 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid); 77 78 return m_impl_up->IsValid(); 79 } 80 81 void SBStructuredData::Clear() { 82 LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear); 83 84 m_impl_up->Clear(); 85 } 86 87 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const { 88 LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON, 89 (lldb::SBStream &), stream); 90 91 SBError error; 92 error.SetError(m_impl_up->GetAsJSON(stream.ref())); 93 return LLDB_RECORD_RESULT(error); 94 } 95 96 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const { 97 LLDB_RECORD_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription, 98 (lldb::SBStream &), stream); 99 100 Status error = m_impl_up->GetDescription(stream.ref()); 101 SBError sb_error; 102 sb_error.SetError(error); 103 return LLDB_RECORD_RESULT(sb_error); 104 } 105 106 StructuredDataType SBStructuredData::GetType() const { 107 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::StructuredDataType, SBStructuredData, 108 GetType); 109 110 return (m_impl_up ? m_impl_up->GetType() : eStructuredDataTypeInvalid); 111 } 112 113 size_t SBStructuredData::GetSize() const { 114 LLDB_RECORD_METHOD_CONST_NO_ARGS(size_t, SBStructuredData, GetSize); 115 116 return (m_impl_up ? m_impl_up->GetSize() : 0); 117 } 118 119 bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const { 120 LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetKeys, 121 (lldb::SBStringList &), keys); 122 123 if (!m_impl_up) 124 return false; 125 126 if (GetType() != eStructuredDataTypeDictionary) 127 return false; 128 129 StructuredData::ObjectSP obj_sp = m_impl_up->GetObjectSP(); 130 if (!obj_sp) 131 return false; 132 133 StructuredData::Dictionary *dict = obj_sp->GetAsDictionary(); 134 // We claimed we were a dictionary, so this can't be null. 135 assert(dict); 136 // The return kind of GetKeys is an Array: 137 StructuredData::ObjectSP array_sp = dict->GetKeys(); 138 StructuredData::Array *key_arr = array_sp->GetAsArray(); 139 assert(key_arr); 140 141 key_arr->ForEach([&keys] (StructuredData::Object *object) -> bool { 142 llvm::StringRef key = object->GetStringValue(""); 143 keys.AppendString(key.str().c_str()); 144 return true; 145 }); 146 return true; 147 } 148 149 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const { 150 LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, 151 GetValueForKey, (const char *), key); 152 153 if (!m_impl_up) 154 return LLDB_RECORD_RESULT(SBStructuredData()); 155 156 SBStructuredData result; 157 result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key)); 158 return LLDB_RECORD_RESULT(result); 159 } 160 161 lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const { 162 LLDB_RECORD_METHOD_CONST(lldb::SBStructuredData, SBStructuredData, 163 GetItemAtIndex, (size_t), idx); 164 165 if (!m_impl_up) 166 return LLDB_RECORD_RESULT(SBStructuredData()); 167 168 SBStructuredData result; 169 result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx)); 170 return LLDB_RECORD_RESULT(result); 171 } 172 173 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const { 174 LLDB_RECORD_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue, 175 (uint64_t), fail_value); 176 177 return (m_impl_up ? m_impl_up->GetIntegerValue(fail_value) : fail_value); 178 } 179 180 double SBStructuredData::GetFloatValue(double fail_value) const { 181 LLDB_RECORD_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double), 182 fail_value); 183 184 return (m_impl_up ? m_impl_up->GetFloatValue(fail_value) : fail_value); 185 } 186 187 bool SBStructuredData::GetBooleanValue(bool fail_value) const { 188 LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool), 189 fail_value); 190 191 return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : fail_value); 192 } 193 194 size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const { 195 LLDB_RECORD_METHOD_CONST(size_t, SBStructuredData, GetStringValue, 196 (char *, size_t), dst, dst_len); 197 198 return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0); 199 } 200