lldb/source/API/SBTypeSynthetic.cpp

   1 //===-- SBTypeSynthetic.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/SBTypeSynthetic.h"
  10 #include "lldb/Utility/Instrumentation.h"
  11
  12 #include "lldb/API/SBStream.h"
  13
  14 #include "lldb/DataFormatters/DataVisualization.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 SBTypeSynthetic::SBTypeSynthetic() { LLDB_INSTRUMENT_VA(this); }
  20
  21 SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
  22                                                      uint32_t options) {
  23   LLDB_INSTRUMENT_VA(data, options);
  24
  25   if (!data || data[0] == 0)
  26     return SBTypeSynthetic();
  27   return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
  28       new ScriptedSyntheticChildren(options, data, "")));
  29 }
  30
  31 SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
  32                                                       uint32_t options) {
  33   LLDB_INSTRUMENT_VA(data, options);
  34
  35   if (!data || data[0] == 0)
  36     return SBTypeSynthetic();
  37   return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
  38       new ScriptedSyntheticChildren(options, "", data)));
  39 }
  40
  41 SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
  42     : m_opaque_sp(rhs.m_opaque_sp) {
  43   LLDB_INSTRUMENT_VA(this, rhs);
  44 }
  45
  46 SBTypeSynthetic::~SBTypeSynthetic() = default;
  47
  48 bool SBTypeSynthetic::IsValid() const {
  49   LLDB_INSTRUMENT_VA(this);
  50   return this->operator bool();
  51 }
  52 SBTypeSynthetic::operator bool() const {
  53   LLDB_INSTRUMENT_VA(this);
  54
  55   return m_opaque_sp.get() != nullptr;
  56 }
  57
  58 bool SBTypeSynthetic::IsClassCode() {
  59   LLDB_INSTRUMENT_VA(this);
  60
  61   if (!IsValid())
  62     return false;
  63   const char *code = m_opaque_sp->GetPythonCode();
  64   return (code && *code);
  65 }
  66
  67 bool SBTypeSynthetic::IsClassName() {
  68   LLDB_INSTRUMENT_VA(this);
  69
  70   if (!IsValid())
  71     return false;
  72   return !IsClassCode();
  73 }
  74
  75 const char *SBTypeSynthetic::GetData() {
  76   LLDB_INSTRUMENT_VA(this);
  77
  78   if (!IsValid())
  79     return nullptr;
  80   if (IsClassCode())
  81     return ConstString(m_opaque_sp->GetPythonCode()).GetCString();
  82
  83   return ConstString(m_opaque_sp->GetPythonClassName()).GetCString();
  84 }
  85
  86 void SBTypeSynthetic::SetClassName(const char *data) {
  87   LLDB_INSTRUMENT_VA(this, data);
  88
  89   if (IsValid() && data && *data)
  90     m_opaque_sp->SetPythonClassName(data);
  91 }
  92
  93 void SBTypeSynthetic::SetClassCode(const char *data) {
  94   LLDB_INSTRUMENT_VA(this, data);
  95
  96   if (IsValid() && data && *data)
  97     m_opaque_sp->SetPythonCode(data);
  98 }
  99
 100 uint32_t SBTypeSynthetic::GetOptions() {
 101   LLDB_INSTRUMENT_VA(this);
 102
 103   if (!IsValid())
 104     return lldb::eTypeOptionNone;
 105   return m_opaque_sp->GetOptions();
 106 }
 107
 108 void SBTypeSynthetic::SetOptions(uint32_t value) {
 109   LLDB_INSTRUMENT_VA(this, value);
 110
 111   if (!CopyOnWrite_Impl())
 112     return;
 113   m_opaque_sp->SetOptions(value);
 114 }
 115
 116 bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
 117                                      lldb::DescriptionLevel description_level) {
 118   LLDB_INSTRUMENT_VA(this, description, description_level);
 119
 120   if (m_opaque_sp) {
 121     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
 122     return true;
 123   }
 124   return false;
 125 }
 126
 127 lldb::SBTypeSynthetic &SBTypeSynthetic::
 128 operator=(const lldb::SBTypeSynthetic &rhs) {
 129   LLDB_INSTRUMENT_VA(this, rhs);
 130
 131   if (this != &rhs) {
 132     m_opaque_sp = rhs.m_opaque_sp;
 133   }
 134   return *this;
 135 }
 136
 137 bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
 138   LLDB_INSTRUMENT_VA(this, rhs);
 139
 140   if (!IsValid())
 141     return !rhs.IsValid();
 142   return m_opaque_sp == rhs.m_opaque_sp;
 143 }
 144
 145 bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
 146   LLDB_INSTRUMENT_VA(this, rhs);
 147
 148   if (!IsValid())
 149     return !rhs.IsValid();
 150
 151   if (m_opaque_sp->IsScripted() != rhs.m_opaque_sp->IsScripted())
 152     return false;
 153
 154   if (IsClassCode() != rhs.IsClassCode())
 155     return false;
 156
 157   if (strcmp(GetData(), rhs.GetData()))
 158     return false;
 159
 160   return GetOptions() == rhs.GetOptions();
 161 }
 162
 163 bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
 164   LLDB_INSTRUMENT_VA(this, rhs);
 165
 166   if (!IsValid())
 167     return !rhs.IsValid();
 168   return m_opaque_sp != rhs.m_opaque_sp;
 169 }
 170
 171 lldb::ScriptedSyntheticChildrenSP SBTypeSynthetic::GetSP() {
 172   return m_opaque_sp;
 173 }
 174
 175 void SBTypeSynthetic::SetSP(
 176     const lldb::ScriptedSyntheticChildrenSP &TypeSynthetic_impl_sp) {
 177   m_opaque_sp = TypeSynthetic_impl_sp;
 178 }
 179
 180 SBTypeSynthetic::SBTypeSynthetic(
 181     const lldb::ScriptedSyntheticChildrenSP &TypeSynthetic_impl_sp)
 182     : m_opaque_sp(TypeSynthetic_impl_sp) {}
 183
 184 bool SBTypeSynthetic::CopyOnWrite_Impl() {
 185   if (!IsValid())
 186     return false;
 187   if (m_opaque_sp.use_count() == 1)
 188     return true;
 189
 190   ScriptedSyntheticChildrenSP new_sp(new ScriptedSyntheticChildren(
 191       m_opaque_sp->GetOptions(), m_opaque_sp->GetPythonClassName(),
 192       m_opaque_sp->GetPythonCode()));
 193
 194   SetSP(new_sp);
 195
 196   return true;
 197 }