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