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 "lldb/Utility/ReproducerInstrumentation.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() { 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 LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMember, (const lldb::SBTypeEnumMember &), 36 rhs); 37 38 m_opaque_sp = clone(rhs.m_opaque_sp); 39 } 40 41 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) { 42 LLDB_RECORD_METHOD( 43 SBTypeEnumMember &, 44 SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &), rhs); 45 46 if (this != &rhs) 47 m_opaque_sp = clone(rhs.m_opaque_sp); 48 return *this; 49 } 50 51 bool SBTypeEnumMember::IsValid() const { 52 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid); 53 return this->operator bool(); 54 } 55 SBTypeEnumMember::operator bool() const { 56 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool); 57 58 return m_opaque_sp.get(); 59 } 60 61 const char *SBTypeEnumMember::GetName() { 62 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName); 63 64 if (m_opaque_sp.get()) 65 return m_opaque_sp->GetName().GetCString(); 66 return nullptr; 67 } 68 69 int64_t SBTypeEnumMember::GetValueAsSigned() { 70 LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned); 71 72 if (m_opaque_sp.get()) 73 return m_opaque_sp->GetValueAsSigned(); 74 return 0; 75 } 76 77 uint64_t SBTypeEnumMember::GetValueAsUnsigned() { 78 LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned); 79 80 if (m_opaque_sp.get()) 81 return m_opaque_sp->GetValueAsUnsigned(); 82 return 0; 83 } 84 85 SBType SBTypeEnumMember::GetType() { 86 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType); 87 88 SBType sb_type; 89 if (m_opaque_sp.get()) { 90 sb_type.SetSP(m_opaque_sp->GetIntegerType()); 91 } 92 return sb_type; 93 } 94 95 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) { 96 m_opaque_sp.reset(type_member_impl); 97 } 98 99 TypeEnumMemberImpl &SBTypeEnumMember::ref() { 100 if (m_opaque_sp.get() == nullptr) 101 m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(); 102 return *m_opaque_sp.get(); 103 } 104 105 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const { 106 return *m_opaque_sp.get(); 107 } 108 109 SBTypeEnumMemberList::SBTypeEnumMemberList() 110 : m_opaque_up(new TypeEnumMemberListImpl()) { 111 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList); 112 } 113 114 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs) 115 : m_opaque_up(new TypeEnumMemberListImpl()) { 116 LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList, 117 (const lldb::SBTypeEnumMemberList &), rhs); 118 119 for (uint32_t i = 0, 120 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); 121 i < rhs_size; i++) 122 Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); 123 } 124 125 bool SBTypeEnumMemberList::IsValid() { 126 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid); 127 return this->operator bool(); 128 } 129 SBTypeEnumMemberList::operator bool() const { 130 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool); 131 132 return (m_opaque_up != nullptr); 133 } 134 135 SBTypeEnumMemberList &SBTypeEnumMemberList:: 136 operator=(const SBTypeEnumMemberList &rhs) { 137 LLDB_RECORD_METHOD( 138 lldb::SBTypeEnumMemberList &, 139 SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &), 140 rhs); 141 142 if (this != &rhs) { 143 m_opaque_up = std::make_unique<TypeEnumMemberListImpl>(); 144 for (uint32_t i = 0, 145 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize(); 146 i < rhs_size; i++) 147 Append( 148 const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i)); 149 } 150 return *this; 151 } 152 153 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) { 154 LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append, 155 (lldb::SBTypeEnumMember), enum_member); 156 157 if (enum_member.IsValid()) 158 m_opaque_up->Append(enum_member.m_opaque_sp); 159 } 160 161 SBTypeEnumMember 162 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) { 163 LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList, 164 GetTypeEnumMemberAtIndex, (uint32_t), index); 165 166 if (m_opaque_up) 167 return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)); 168 return SBTypeEnumMember(); 169 } 170 171 uint32_t SBTypeEnumMemberList::GetSize() { 172 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize); 173 174 return m_opaque_up->GetSize(); 175 } 176 177 SBTypeEnumMemberList::~SBTypeEnumMemberList() = default; 178 179 bool SBTypeEnumMember::GetDescription( 180 lldb::SBStream &description, lldb::DescriptionLevel description_level) { 181 LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription, 182 (lldb::SBStream &, lldb::DescriptionLevel), description, 183 description_level); 184 185 Stream &strm = description.ref(); 186 187 if (m_opaque_sp.get()) { 188 if (m_opaque_sp->GetIntegerType()->GetDescription(strm, 189 description_level)) { 190 strm.Printf(" %s", m_opaque_sp->GetName().GetCString()); 191 } 192 } else { 193 strm.PutCString("No value"); 194 } 195 return true; 196 } 197