lldb/source/API/SBValueList.cpp

   1 //===-- SBValueList.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/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.reset(new ValueListImpl(*rhs));
  79 }
  80
  81 SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
  82   if (lldb_object_ptr)
  83     m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr));
  84 }
  85
  86 SBValueList::~SBValueList() {}
  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.reset(new 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.reset(new 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 }