lldb/source/API/SBStructuredData.cpp

   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
  11 #include "lldb/API/SBDebugger.h"
  12 #include "lldb/API/SBScriptObject.h"
  13 #include "lldb/API/SBStream.h"
  14 #include "lldb/API/SBStringList.h"
  15 #include "lldb/Core/Debugger.h"
  16 #include "lldb/Core/StructuredDataImpl.h"
  17 #include "lldb/Interpreter/ScriptInterpreter.h"
  18 #include "lldb/Target/StructuredDataPlugin.h"
  19 #include "lldb/Utility/Event.h"
  20 #include "lldb/Utility/Instrumentation.h"
  21 #include "lldb/Utility/Status.h"
  22 #include "lldb/Utility/Stream.h"
  23 #include "lldb/Utility/StringList.h"
  24 #include "lldb/Utility/StructuredData.h"
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 #pragma mark--
  30 #pragma mark SBStructuredData
  31
  32 SBStructuredData::SBStructuredData() : m_impl_up(new StructuredDataImpl()) {
  33   LLDB_INSTRUMENT_VA(this);
  34 }
  35
  36 SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs)
  37     : m_impl_up(new StructuredDataImpl(*rhs.m_impl_up)) {
  38   LLDB_INSTRUMENT_VA(this, rhs);
  39 }
  40
  41 SBStructuredData::SBStructuredData(const lldb::SBScriptObject obj,
  42                                    const lldb::SBDebugger &debugger) {
  43   LLDB_INSTRUMENT_VA(this, obj, debugger);
  44
  45   if (!obj.IsValid())
  46     return;
  47
  48   ScriptInterpreter *interpreter =
  49       debugger.m_opaque_sp->GetScriptInterpreter(true, obj.GetLanguage());
  50
  51   if (!interpreter)
  52     return;
  53
  54   StructuredDataImplUP impl_up = std::make_unique<StructuredDataImpl>(
  55       interpreter->CreateStructuredDataFromScriptObject(obj.ref()));
  56   if (impl_up && impl_up->IsValid())
  57     m_impl_up.reset(impl_up.release());
  58 }
  59
  60 SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp)
  61     : m_impl_up(new StructuredDataImpl(event_sp)) {
  62   LLDB_INSTRUMENT_VA(this, event_sp);
  63 }
  64
  65 SBStructuredData::SBStructuredData(const lldb_private::StructuredDataImpl &impl)
  66     : m_impl_up(new StructuredDataImpl(impl)) {
  67   LLDB_INSTRUMENT_VA(this, impl);
  68 }
  69
  70 SBStructuredData::~SBStructuredData() = default;
  71
  72 SBStructuredData &SBStructuredData::
  73 operator=(const lldb::SBStructuredData &rhs) {
  74   LLDB_INSTRUMENT_VA(this, rhs);
  75
  76   *m_impl_up = *rhs.m_impl_up;
  77   return *this;
  78 }
  79
  80 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
  81   LLDB_INSTRUMENT_VA(this, stream);
  82
  83   lldb::SBError error;
  84
  85   StructuredData::ObjectSP json_obj =
  86       StructuredData::ParseJSON(stream.GetData());
  87   m_impl_up->SetObjectSP(json_obj);
  88
  89   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
  90     error.SetErrorString("Invalid Syntax");
  91   return error;
  92 }
  93
  94 lldb::SBError SBStructuredData::SetFromJSON(const char *json) {
  95   LLDB_INSTRUMENT_VA(this, json);
  96   lldb::SBStream s;
  97   s.Print(json);
  98   return SetFromJSON(s);
  99 }
 100
 101 bool SBStructuredData::IsValid() const {
 102   LLDB_INSTRUMENT_VA(this);
 103   return this->operator bool();
 104 }
 105
 106 SBStructuredData::operator bool() const {
 107   LLDB_INSTRUMENT_VA(this);
 108
 109   return m_impl_up->IsValid();
 110 }
 111
 112 void SBStructuredData::Clear() {
 113   LLDB_INSTRUMENT_VA(this);
 114
 115   m_impl_up->Clear();
 116 }
 117
 118 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
 119   LLDB_INSTRUMENT_VA(this, stream);
 120
 121   SBError error;
 122   error.SetError(m_impl_up->GetAsJSON(stream.ref()));
 123   return error;
 124 }
 125
 126 lldb::SBError SBStructuredData::GetDescription(lldb::SBStream &stream) const {
 127   LLDB_INSTRUMENT_VA(this, stream);
 128
 129   Status error = m_impl_up->GetDescription(stream.ref());
 130   SBError sb_error;
 131   sb_error.SetError(error);
 132   return sb_error;
 133 }
 134
 135 StructuredDataType SBStructuredData::GetType() const {
 136   LLDB_INSTRUMENT_VA(this);
 137
 138   return m_impl_up->GetType();
 139 }
 140
 141 size_t SBStructuredData::GetSize() const {
 142   LLDB_INSTRUMENT_VA(this);
 143
 144   return m_impl_up->GetSize();
 145 }
 146
 147 bool SBStructuredData::GetKeys(lldb::SBStringList &keys) const {
 148   LLDB_INSTRUMENT_VA(this, keys);
 149
 150   if (GetType() != eStructuredDataTypeDictionary)
 151     return false;
 152
 153   StructuredData::ObjectSP obj_sp = m_impl_up->GetObjectSP();
 154   if (!obj_sp)
 155     return false;
 156
 157   StructuredData::Dictionary *dict = obj_sp->GetAsDictionary();
 158   // We claimed we were a dictionary, so this can't be null.
 159   assert(dict);
 160   // The return kind of GetKeys is an Array:
 161   StructuredData::ObjectSP array_sp = dict->GetKeys();
 162   StructuredData::Array *key_arr = array_sp->GetAsArray();
 163   assert(key_arr);
 164
 165   key_arr->ForEach([&keys](StructuredData::Object *object) -> bool {
 166     llvm::StringRef key = object->GetStringValue("");
 167     keys->AppendString(key);
 168     return true;
 169   });
 170   return true;
 171 }
 172
 173 lldb::SBStructuredData SBStructuredData::GetValueForKey(const char *key) const {
 174   LLDB_INSTRUMENT_VA(this, key);
 175
 176   SBStructuredData result;
 177   result.m_impl_up->SetObjectSP(m_impl_up->GetValueForKey(key));
 178   return result;
 179 }
 180
 181 lldb::SBStructuredData SBStructuredData::GetItemAtIndex(size_t idx) const {
 182   LLDB_INSTRUMENT_VA(this, idx);
 183
 184   SBStructuredData result;
 185   result.m_impl_up->SetObjectSP(m_impl_up->GetItemAtIndex(idx));
 186   return result;
 187 }
 188
 189 uint64_t SBStructuredData::GetIntegerValue(uint64_t fail_value) const {
 190   LLDB_INSTRUMENT_VA(this, fail_value);
 191
 192   return GetUnsignedIntegerValue(fail_value);
 193 }
 194
 195 uint64_t SBStructuredData::GetUnsignedIntegerValue(uint64_t fail_value) const {
 196   LLDB_INSTRUMENT_VA(this, fail_value);
 197
 198   return m_impl_up->GetIntegerValue(fail_value);
 199 }
 200
 201 int64_t SBStructuredData::GetSignedIntegerValue(int64_t fail_value) const {
 202   LLDB_INSTRUMENT_VA(this, fail_value);
 203
 204   return m_impl_up->GetIntegerValue(fail_value);
 205 }
 206
 207 double SBStructuredData::GetFloatValue(double fail_value) const {
 208   LLDB_INSTRUMENT_VA(this, fail_value);
 209
 210   return m_impl_up->GetFloatValue(fail_value);
 211 }
 212
 213 bool SBStructuredData::GetBooleanValue(bool fail_value) const {
 214   LLDB_INSTRUMENT_VA(this, fail_value);
 215
 216   return m_impl_up->GetBooleanValue(fail_value);
 217 }
 218
 219 size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
 220   LLDB_INSTRUMENT_VA(this, dst, dst_len);
 221
 222   return m_impl_up->GetStringValue(dst, dst_len);
 223 }
 224
 225 lldb::SBScriptObject SBStructuredData::GetGenericValue() const {
 226   LLDB_INSTRUMENT_VA(this);
 227
 228   return {m_impl_up->GetGenericValue(), eScriptLanguageDefault};
 229 }