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
SBTypeEnumMember()24 SBTypeEnumMember::SBTypeEnumMember() { LLDB_INSTRUMENT_VA(this); }
25
26 SBTypeEnumMember::~SBTypeEnumMember() = default;
27
SBTypeEnumMember(const lldb::TypeEnumMemberImplSP & enum_member_sp)28 SBTypeEnumMember::SBTypeEnumMember(
29 const lldb::TypeEnumMemberImplSP &enum_member_sp)
30 : m_opaque_sp(enum_member_sp) {}
31
SBTypeEnumMember(const SBTypeEnumMember & rhs)32 SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) {
33 LLDB_INSTRUMENT_VA(this, rhs);
34
35 m_opaque_sp = clone(rhs.m_opaque_sp);
36 }
37
operator =(const SBTypeEnumMember & rhs)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
IsValid() const46 bool SBTypeEnumMember::IsValid() const {
47 LLDB_INSTRUMENT_VA(this);
48 return this->operator bool();
49 }
operator bool() const50 SBTypeEnumMember::operator bool() const {
51 LLDB_INSTRUMENT_VA(this);
52
53 return m_opaque_sp.get();
54 }
55
GetName()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
GetValueAsSigned()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
GetValueAsUnsigned()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
GetType()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
reset(TypeEnumMemberImpl * type_member_impl)90 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
91 m_opaque_sp.reset(type_member_impl);
92 }
93
ref()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
ref() const100 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
101 return *m_opaque_sp.get();
102 }
103
SBTypeEnumMemberList()104 SBTypeEnumMemberList::SBTypeEnumMemberList()
105 : m_opaque_up(new TypeEnumMemberListImpl()) {
106 LLDB_INSTRUMENT_VA(this);
107 }
108
SBTypeEnumMemberList(const SBTypeEnumMemberList & rhs)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
IsValid()119 bool SBTypeEnumMemberList::IsValid() {
120 LLDB_INSTRUMENT_VA(this);
121 return this->operator bool();
122 }
operator bool() const123 SBTypeEnumMemberList::operator bool() const {
124 LLDB_INSTRUMENT_VA(this);
125
126 return (m_opaque_up != nullptr);
127 }
128
129 SBTypeEnumMemberList &SBTypeEnumMemberList::
operator =(const SBTypeEnumMemberList & rhs)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
Append(SBTypeEnumMember enum_member)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
GetTypeEnumMemberAtIndex(uint32_t index)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
GetSize()160 uint32_t SBTypeEnumMemberList::GetSize() {
161 LLDB_INSTRUMENT_VA(this);
162
163 return m_opaque_up->GetSize();
164 }
165
166 SBTypeEnumMemberList::~SBTypeEnumMemberList() = default;
167
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)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