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   return this->operator bool();
54 }
55 SBTypeEnumMember::operator bool() const {
56   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
57 
58   return m_opaque_sp.get();
59 }
60 
61 const char *SBTypeEnumMember::GetName() {
62   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
63 
64   if (m_opaque_sp.get())
65     return m_opaque_sp->GetName().GetCString();
66   return NULL;
67 }
68 
69 int64_t SBTypeEnumMember::GetValueAsSigned() {
70   LLDB_RECORD_METHOD_NO_ARGS(int64_t, SBTypeEnumMember, GetValueAsSigned);
71 
72   if (m_opaque_sp.get())
73     return m_opaque_sp->GetValueAsSigned();
74   return 0;
75 }
76 
77 uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
78   LLDB_RECORD_METHOD_NO_ARGS(uint64_t, SBTypeEnumMember, GetValueAsUnsigned);
79 
80   if (m_opaque_sp.get())
81     return m_opaque_sp->GetValueAsUnsigned();
82   return 0;
83 }
84 
85 SBType SBTypeEnumMember::GetType() {
86   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeEnumMember, GetType);
87 
88   SBType sb_type;
89   if (m_opaque_sp.get()) {
90     sb_type.SetSP(m_opaque_sp->GetIntegerType());
91   }
92   return LLDB_RECORD_RESULT(sb_type);
93 }
94 
95 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
96   m_opaque_sp.reset(type_member_impl);
97 }
98 
99 TypeEnumMemberImpl &SBTypeEnumMember::ref() {
100   if (m_opaque_sp.get() == NULL)
101     m_opaque_sp = std::make_shared<TypeEnumMemberImpl>();
102   return *m_opaque_sp.get();
103 }
104 
105 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
106   return *m_opaque_sp.get();
107 }
108 
109 SBTypeEnumMemberList::SBTypeEnumMemberList()
110     : m_opaque_up(new TypeEnumMemberListImpl()) {
111   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeEnumMemberList);
112 }
113 
114 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
115     : m_opaque_up(new TypeEnumMemberListImpl()) {
116   LLDB_RECORD_CONSTRUCTOR(SBTypeEnumMemberList,
117                           (const lldb::SBTypeEnumMemberList &), rhs);
118 
119   for (uint32_t i = 0,
120                 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
121        i < rhs_size; i++)
122     Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
123 }
124 
125 bool SBTypeEnumMemberList::IsValid() {
126   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
127   return this->operator bool();
128 }
129 SBTypeEnumMemberList::operator bool() const {
130   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool);
131 
132   return (m_opaque_up != NULL);
133 }
134 
135 SBTypeEnumMemberList &SBTypeEnumMemberList::
136 operator=(const SBTypeEnumMemberList &rhs) {
137   LLDB_RECORD_METHOD(
138       lldb::SBTypeEnumMemberList &,
139       SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &),
140       rhs);
141 
142   if (this != &rhs) {
143     m_opaque_up.reset(new TypeEnumMemberListImpl());
144     for (uint32_t i = 0,
145                   rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
146          i < rhs_size; i++)
147       Append(
148           const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
149   }
150   return *this;
151 }
152 
153 void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
154   LLDB_RECORD_METHOD(void, SBTypeEnumMemberList, Append,
155                      (lldb::SBTypeEnumMember), enum_member);
156 
157   if (enum_member.IsValid())
158     m_opaque_up->Append(enum_member.m_opaque_sp);
159 }
160 
161 SBTypeEnumMember
162 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
163   LLDB_RECORD_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
164                      GetTypeEnumMemberAtIndex, (uint32_t), index);
165 
166   if (m_opaque_up)
167     return LLDB_RECORD_RESULT(
168         SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(index)));
169   return LLDB_RECORD_RESULT(SBTypeEnumMember());
170 }
171 
172 uint32_t SBTypeEnumMemberList::GetSize() {
173   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeEnumMemberList, GetSize);
174 
175   return m_opaque_up->GetSize();
176 }
177 
178 SBTypeEnumMemberList::~SBTypeEnumMemberList() {}
179 
180 bool SBTypeEnumMember::GetDescription(
181     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
182   LLDB_RECORD_METHOD(bool, SBTypeEnumMember, GetDescription,
183                      (lldb::SBStream &, lldb::DescriptionLevel), description,
184                      description_level);
185 
186   Stream &strm = description.ref();
187 
188   if (m_opaque_sp.get()) {
189     if (m_opaque_sp->GetIntegerType()->GetDescription(strm,
190                                                       description_level)) {
191       strm.Printf(" %s", m_opaque_sp->GetName().GetCString());
192     }
193   } else {
194     strm.PutCString("No value");
195   }
196   return true;
197 }
198 
199 namespace lldb_private {
200 namespace repro {
201 
202 template <>
203 void RegisterMethods<SBTypeEnumMember>(Registry &R) {
204   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
205   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
206                             (const lldb::SBTypeEnumMember &));
207   LLDB_REGISTER_METHOD(
208       lldb::SBTypeEnumMember &,
209       SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
210   LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
211   LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
212   LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
213   LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
214   LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
215   LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
216   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
217   LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
218                             (const lldb::SBTypeEnumMemberList &));
219   LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
220   LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
221   LLDB_REGISTER_METHOD(
222       lldb::SBTypeEnumMemberList &,
223       SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
224   LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
225                        (lldb::SBTypeEnumMember));
226   LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
227                        GetTypeEnumMemberAtIndex, (uint32_t));
228   LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
229   LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
230                        (lldb::SBStream &, lldb::DescriptionLevel));
231 }
232 
233 }
234 }
235