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