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: 22 ValueListImpl() : m_values() {} 23 24 ValueListImpl(const ValueListImpl &rhs) : m_values(rhs.m_values) {} 25 26 ValueListImpl &operator=(const ValueListImpl &rhs) { 27 if (this == &rhs) 28 return *this; 29 m_values = rhs.m_values; 30 return *this; 31 } 32 33 uint32_t GetSize() { return m_values.size(); } 34 35 void Append(const lldb::SBValue &sb_value) { m_values.push_back(sb_value); } 36 37 void Append(const ValueListImpl &list) { 38 for (auto val : list.m_values) 39 Append(val); 40 } 41 42 lldb::SBValue GetValueAtIndex(uint32_t index) { 43 if (index >= GetSize()) 44 return lldb::SBValue(); 45 return m_values[index]; 46 } 47 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 56 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 70 SBValueList::SBValueList() : m_opaque_up() { 71 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList); 72 } 73 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 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 88 bool SBValueList::IsValid() const { 89 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid); 90 return this->operator bool(); 91 } 92 SBValueList::operator bool() const { 93 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool); 94 95 return (m_opaque_up != nullptr); 96 } 97 98 void SBValueList::Clear() { 99 LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear); 100 101 m_opaque_up.reset(); 102 } 103 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 117 ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); } 118 119 ValueListImpl &SBValueList::operator*() { return *m_opaque_up; } 120 121 const ValueListImpl *SBValueList::operator->() const { 122 return m_opaque_up.get(); 123 } 124 125 const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; } 126 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 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 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 152 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 164 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 174 void SBValueList::CreateIfNeeded() { 175 if (m_opaque_up == nullptr) 176 m_opaque_up = std::make_unique<ValueListImpl>(); 177 } 178 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 189 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 199 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); } 200 201 ValueListImpl &SBValueList::ref() { 202 CreateIfNeeded(); 203 return *m_opaque_up; 204 } 205 206 namespace lldb_private { 207 namespace repro { 208 209 template <> 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