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 
24 SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {
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     : 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_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 
52 bool SBTypeEnumMember::IsValid() const {
53   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
54   return this->operator bool();
55 }
56 SBTypeEnumMember::operator bool() const {
57   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
58 
59   return m_opaque_sp.get();
60 }
61 
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 
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 
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 
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 
96 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
97   m_opaque_sp.reset(type_member_impl);
98 }
99 
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 
106 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
107   return *m_opaque_sp.get();
108 }
109 
110 SBTypeEnumMemberList::SBTypeEnumMemberList()
111     : m_opaque_up(new TypeEnumMemberListImpl()) {
112   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
113 }
114 
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 
126 bool SBTypeEnumMemberList::IsValid() {
127   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
128   return this->operator bool();
129 }
130 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::
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 
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
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 
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 
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 <>
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