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