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 } 227