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
21using namespace lldb;
22using namespace lldb_private;
23
24SBTypeEnumMember::SBTypeEnumMember() { LLDB_INSTRUMENT_VA(this); }
25
26SBTypeEnumMember::~SBTypeEnumMember() = default;
27
28SBTypeEnumMember::SBTypeEnumMember(
29 const lldb::TypeEnumMemberImplSP &enum_member_sp)
30 : m_opaque_sp(enum_member_sp) {}
31
32SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs) {
33 LLDB_INSTRUMENT_VA(this, rhs);
34
35 m_opaque_sp = clone(src: rhs.m_opaque_sp);
36}
37
38SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
39 LLDB_INSTRUMENT_VA(this, rhs);
40
41 if (this != &rhs)
42 m_opaque_sp = clone(src: rhs.m_opaque_sp);
43 return *this;
44}
45
46bool SBTypeEnumMember::IsValid() const {
47 LLDB_INSTRUMENT_VA(this);
48 return this->operator bool();
49}
50SBTypeEnumMember::operator bool() const {
51 LLDB_INSTRUMENT_VA(this);
52
53 return m_opaque_sp.get();
54}
55
56const 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
64int64_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
72uint64_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
80SBType 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
90void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
91 m_opaque_sp.reset(p: type_member_impl);
92}
93
94TypeEnumMemberImpl &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
100const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
101 return *m_opaque_sp.get();
102}
103
104SBTypeEnumMemberList::SBTypeEnumMemberList()
105 : m_opaque_up(new TypeEnumMemberListImpl()) {
106 LLDB_INSTRUMENT_VA(this);
107}
108
109SBTypeEnumMemberList::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(entry: const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(index: i));
117}
118
119bool SBTypeEnumMemberList::IsValid() {
120 LLDB_INSTRUMENT_VA(this);
121 return this->operator bool();
122}
123SBTypeEnumMemberList::operator bool() const {
124 LLDB_INSTRUMENT_VA(this);
125
126 return (m_opaque_up != nullptr);
127}
128
129SBTypeEnumMemberList &SBTypeEnumMemberList::
130operator=(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 entry: const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(index: i));
140 }
141 return *this;
142}
143
144void SBTypeEnumMemberList::Append(SBTypeEnumMember enum_member) {
145 LLDB_INSTRUMENT_VA(this, enum_member);
146
147 if (enum_member.IsValid())
148 m_opaque_up->Append(type: enum_member.m_opaque_sp);
149}
150
151SBTypeEnumMember
152SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
153 LLDB_INSTRUMENT_VA(this, index);
154
155 if (m_opaque_up)
156 return SBTypeEnumMember(m_opaque_up->GetTypeEnumMemberAtIndex(idx: index));
157 return SBTypeEnumMember();
158}
159
160uint32_t SBTypeEnumMemberList::GetSize() {
161 LLDB_INSTRUMENT_VA(this);
162
163 return m_opaque_up->GetSize();
164}
165
166SBTypeEnumMemberList::~SBTypeEnumMemberList() = default;
167
168bool 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(format: " %s", m_opaque_sp->GetName().GetCString());
178 }
179 } else {
180 strm.PutCString(cstr: "No value");
181 }
182 return true;
183}
184

source code of lldb/source/API/SBTypeEnumMember.cpp