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
SBTypeEnumMember()24 SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {
25 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMember);
26 }
27
28 SBTypeEnumMember::~SBTypeEnumMember() = default;
29
SBTypeEnumMember(const lldb::TypeEnumMemberImplSP & enum_member_sp)30 SBTypeEnumMember::SBTypeEnumMember(
31 const lldb::TypeEnumMemberImplSP &enum_member_sp)
32 : m_opaque_sp(enum_member_sp) {}
33
SBTypeEnumMember(const SBTypeEnumMember & rhs)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
operator =(const SBTypeEnumMember & rhs)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
IsValid() const52 bool SBTypeEnumMember::IsValid() const {
53 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
54 return this->operator bool();
55 }
operator bool() const56 SBTypeEnumMember::operator bool() const {
57 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
58
59 return m_opaque_sp.get();
60 }
61
GetName()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
GetValueAsSigned()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
GetValueAsUnsigned()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
GetType()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
reset(TypeEnumMemberImpl * type_member_impl)96 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
97 m_opaque_sp.reset(type_member_impl);
98 }
99
ref()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
ref() const106 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
107 return *m_opaque_sp.get();
108 }
109
SBTypeEnumMemberList()110 SBTypeEnumMemberList::SBTypeEnumMemberList()
111 : m_opaque_up(new TypeEnumMemberListImpl()) {
112 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
113 }
114
SBTypeEnumMemberList(const SBTypeEnumMemberList & rhs)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
IsValid()126 bool SBTypeEnumMemberList::IsValid() {
127 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
128 return this->operator bool();
129 }
operator bool() const130 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::
operator =(const SBTypeEnumMemberList & rhs)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
Append(SBTypeEnumMember enum_member)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
GetTypeEnumMemberAtIndex(uint32_t index)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
GetSize()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
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)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 <>
RegisterMethods(Registry & R)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