contrib/llvm-project/lldb/source/API/SBTypeFilter.cpp

   1 //===-- SBTypeFilter.cpp ------------------------------------------*- C++
   2 //-*-===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBTypeFilter.h"
  11 #include "SBReproducerPrivate.h"
  12
  13 #include "lldb/API/SBStream.h"
  14
  15 #include "lldb/DataFormatters/DataVisualization.h"
  16
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
  21   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
  22 }
  23
  24 SBTypeFilter::SBTypeFilter(uint32_t options)
  25     : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
  26   LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
  27 }
  28
  29 SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
  30     : m_opaque_sp(rhs.m_opaque_sp) {
  31   LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
  32 }
  33
  34 SBTypeFilter::~SBTypeFilter() {}
  35
  36 bool SBTypeFilter::IsValid() const {
  37   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
  38   return this->operator bool();
  39 }
  40 SBTypeFilter::operator bool() const {
  41   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
  42
  43   return m_opaque_sp.get() != nullptr;
  44 }
  45
  46 uint32_t SBTypeFilter::GetOptions() {
  47   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
  48
  49   if (IsValid())
  50     return m_opaque_sp->GetOptions();
  51   return 0;
  52 }
  53
  54 void SBTypeFilter::SetOptions(uint32_t value) {
  55   LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
  56
  57   if (CopyOnWrite_Impl())
  58     m_opaque_sp->SetOptions(value);
  59 }
  60
  61 bool SBTypeFilter::GetDescription(lldb::SBStream &description,
  62                                   lldb::DescriptionLevel description_level) {
  63   LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
  64                      (lldb::SBStream &, lldb::DescriptionLevel), description,
  65                      description_level);
  66
  67   if (!IsValid())
  68     return false;
  69   else {
  70     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
  71     return true;
  72   }
  73 }
  74
  75 void SBTypeFilter::Clear() {
  76   LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
  77
  78   if (CopyOnWrite_Impl())
  79     m_opaque_sp->Clear();
  80 }
  81
  82 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
  83   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
  84                              GetNumberOfExpressionPaths);
  85
  86   if (IsValid())
  87     return m_opaque_sp->GetCount();
  88   return 0;
  89 }
  90
  91 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
  92   LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
  93                      (uint32_t), i);
  94
  95   if (IsValid()) {
  96     const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
  97     if (item && *item == '.')
  98       item++;
  99     return item;
 100   }
 101   return nullptr;
 102 }
 103
 104 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
 105   LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
 106                      (uint32_t, const char *), i, item);
 107
 108   if (CopyOnWrite_Impl())
 109     return m_opaque_sp->SetExpressionPathAtIndex(i, item);
 110   else
 111     return false;
 112 }
 113
 114 void SBTypeFilter::AppendExpressionPath(const char *item) {
 115   LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
 116                      item);
 117
 118   if (CopyOnWrite_Impl())
 119     m_opaque_sp->AddExpressionPath(item);
 120 }
 121
 122 lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
 123   LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
 124                      SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
 125
 126   if (this != &rhs) {
 127     m_opaque_sp = rhs.m_opaque_sp;
 128   }
 129   return LLDB_RECORD_RESULT(*this);
 130 }
 131
 132 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
 133   LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
 134                      rhs);
 135
 136   if (!IsValid())
 137     return !rhs.IsValid();
 138
 139   return m_opaque_sp == rhs.m_opaque_sp;
 140 }
 141
 142 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
 143   LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
 144                      rhs);
 145
 146   if (!IsValid())
 147     return !rhs.IsValid();
 148
 149   if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths())
 150     return false;
 151
 152   for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
 153     if (strcmp(GetExpressionPathAtIndex(j), rhs.GetExpressionPathAtIndex(j)) !=
 154         0)
 155       return false;
 156
 157   return GetOptions() == rhs.GetOptions();
 158 }
 159
 160 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
 161   LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
 162                      rhs);
 163
 164   if (!IsValid())
 165     return !rhs.IsValid();
 166
 167   return m_opaque_sp != rhs.m_opaque_sp;
 168 }
 169
 170 lldb::TypeFilterImplSP SBTypeFilter::GetSP() { return m_opaque_sp; }
 171
 172 void SBTypeFilter::SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp) {
 173   m_opaque_sp = typefilter_impl_sp;
 174 }
 175
 176 SBTypeFilter::SBTypeFilter(const lldb::TypeFilterImplSP &typefilter_impl_sp)
 177     : m_opaque_sp(typefilter_impl_sp) {}
 178
 179 bool SBTypeFilter::CopyOnWrite_Impl() {
 180   if (!IsValid())
 181     return false;
 182   if (m_opaque_sp.unique())
 183     return true;
 184
 185   TypeFilterImplSP new_sp(new TypeFilterImpl(GetOptions()));
 186
 187   for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
 188     new_sp->AddExpressionPath(GetExpressionPathAtIndex(j));
 189
 190   SetSP(new_sp);
 191
 192   return true;
 193 }
 194
 195 namespace lldb_private {
 196 namespace repro {
 197
 198 template <>
 199 void RegisterMethods<SBTypeFilter>(Registry &R) {
 200   LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
 201   LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
 202   LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
 203   LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
 204   LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
 205   LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
 206   LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
 207   LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
 208                        (lldb::SBStream &, lldb::DescriptionLevel));
 209   LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
 210   LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
 211                        ());
 212   LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
 213                        (uint32_t));
 214   LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
 215                        (uint32_t, const char *));
 216   LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
 217                        (const char *));
 218   LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
 219                        SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
 220   LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
 221   LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
 222   LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
 223 }
 224
 225 }
 226 }