1 //===-- SBTypeEnumMember.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/SBTypeEnumMember.h" 10 #include "SBReproducerPrivate.h" 11 #include "Utils.h" 12 #include "lldb/API/SBDefines.h" 13 #include "lldb/API/SBStream.h" 14 #include "lldb/API/SBType.h" 15 #include "lldb/Symbol/CompilerType.h" 16 #include "lldb/Symbol/Type.h" 17 #include "lldb/Utility/Stream.h" 18 19 #include <memory> 20 21 using namespace lldb; 22 using namespace lldb_private; 23 24 SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() { 25 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember); 26 } 27 28 SBTypeEnumMember::~SBTypeEnumMember() = default; 29 30 SBTypeEnumMember::SBTypeEnumMember( 31 const lldb::TypeEnumMemberImplSP &enum_member_sp) 32 : m_opaque_sp(enum_member_sp) {} 33 34 SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) 35 : m_opaque_sp() { 36 LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &), 37 rhs); 38 39 m_opaque_sp = clone(rhs.m_opaque_sp); 40 } 41 42 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) { 43 LLDB_RECORD_METHOD( 44 SBTypeEnumMember &, 45 SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs); 46 47 if (this != &rhs) 48 m_opaque_sp = clone(rhs.m_opaque_sp); 49 return LLDB_RECORD_RESULT(*this); 50 } 51 52 bool SBTypeEnumMember::IsValid() const { 53 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); 54 return this->operator bool(); 55 } 56 SBTypeEnumMember::operator bool() const { 57 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool); 58 59 return m_opaque_sp.get(); 60 } 61 62 const char *SBTypeEnumMember::GetName() { 63 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName); 64 65 if (m_opaque_sp.get()) 66 return m_opaque_sp->GetName().GetCString(); 67 return nullptr; 68 } 69 70 int64_t SBTypeEnumMember::GetValueAsSigned() { 71 LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned); 72 73 if (m_opaque_sp.get()) 74 return m_opaque_sp->GetValueAsSigned(); 75 return 0; 76 } 77 78 uint64_t SBTypeEnumMember::GetValueAsUnsigned() { 79 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned); 80 81 if (m_opaque_sp.get()) 82 return m_opaque_sp->GetValueAsUnsigned(); 83 return 0; 84 } 85 86 SBType SBTypeEnumMember::GetType() { 87 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType); 88 89 SBType sb_type; 90 if (m_opaque_sp.get()) { 91 sb_type.SetSP(m_opaque_sp->GetIntegerType()); 92 } 93 return LLDB_RECORD_RESULT(sb_type); 94 } 95 96 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) { 97 m_opaque_sp.reset(type_member_impl); 98 } 99 100 TypeEnumMemberImpl &SBTypeEnumMember::ref() { 101 if (m_opaque_sp.get() == nullptr) 102 m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(); 103 return *m_opaque_sp.get(); 104 } 105 106 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const { 107 return *m_opaque_sp.get(); 108 } 109 110 SBTypeEnumMemberList::SBTypeEnumMemberList() 111 : m_opaque_up(new TypeEnumMemberListImpl()) { 112 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList); 113 } 114 115 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs) 116 : m_opaque_up(new TypeEnumMemberListImpl()) { 117 LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList, 118 (const lldb::SBTypeEnumMemberList &), rhs); 119 120 for (uint32_t i = 0, 121 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); 122 i < rhs_size; i++) 123 Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); 124 } 125 126 bool SBTypeEnumMemberList::IsValid() { 127 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); 128 return this->operator bool(); 129 } 130 SBTypeEnumMemberList::operator bool() const { 131 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool); 132 133 return (m_opaque_up != nullptr); 134 } 135 136 SBTypeEnumMemberList &SBTypeEnumMemberList:: 137 operator=(const SBTypeEnumMemberList &rhs) { 138 LLDB_RECORD_METHOD( 139 lldb::SBTypeEnumMemberList &, 140 SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &), 141 rhs); 142 143 if (this != &rhs) { 144 m_opaque_up = std::make_unique<TypeEnumMemberListImpl>(); 145 for (uint32_t i = 0, 146 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); 147 i < rhs_size; i++) 148 Append( 149 const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); 150 } 151 return LLDB_RECORD_RESULT(*this); 152 } 153 154 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { 155 LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append, 156 (lldb::SBTypeEnumMember), enum_member); 157 158 if (enum_member.IsValid()) 159 m_opaque_up->Append(enum_member.m_opaque_sp); 160 } 161 162 SBTypeEnumMember 163 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { 164 LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, 165 GetTypeEnumMemberAtIndex, (uint32_t), index); 166 167 if (m_opaque_up) 168 return LLDB_RECORD_RESULT( 169 SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index))); 170 return LLDB_RECORD_RESULT(SBTypeEnumMember()); 171 } 172 173 uint32_t SBTypeEnumMemberList::GetSize() { 174 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); 175 176 return m_opaque_up->GetSize(); 177 } 178 179 SBTypeEnumMemberList::~SBTypeEnumMemberList() = default; 180 181 bool SBTypeEnumMember::GetDescription( 182 lldb::SBStream &description, lldb::DescriptionLevel description_level) { 183 LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription, 184 (lldb::SBStream &, lldb::DescriptionLevel), description, 185 description_level); 186 187 Stream &strm = description.ref(); 188 189 if (m_opaque_sp.get()) { 190 if (m_opaque_sp->GetIntegerType()->GetDescription(strm, 191 description_level)) { 192 strm.Printf(" %s", m_opaque_sp->GetName().GetCString()); 193 } 194 } else { 195 strm.PutCString("No value"); 196 } 197 return true; 198 } 199 200 namespace lldb_private { 201 namespace repro { 202 203 template <> 204 void RegisterMethods<SBTypeEnumMember>(Registry &R) { 205 LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ()); 206 LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, 207 (const lldb::SBTypeEnumMember &)); 208 LLDB_REGISTER_METHOD( 209 lldb::SBTypeEnumMember &, 210 SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &)); 211 LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ()); 212 LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ()); 213 LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ()); 214 LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ()); 215 LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ()); 216 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ()); 217 LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ()); 218 LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, 219 (const lldb::SBTypeEnumMemberList &)); 220 LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ()); 221 LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ()); 222 LLDB_REGISTER_METHOD( 223 lldb::SBTypeEnumMemberList &, 224 SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &)); 225 LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append, 226 (lldb::SBTypeEnumMember)); 227 LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, 228 GetTypeEnumMemberAtIndex, (uint32_t)); 229 LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ()); 230 LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription, 231 (lldb::SBStream &, lldb::DescriptionLevel)); 232 } 233 234 } 235 } 236