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