1 //===-- SBTypeNameSpecifier.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/SBTypeNameSpecifier.h"
10 #include "SBReproducerPrivate.h"
11
12 #include "lldb/API/SBStream.h"
13 #include "lldb/API/SBType.h"
14
15 #include "lldb/DataFormatters/DataVisualization.h"
16
17 using namespace lldb;
18 using namespace lldb_private;
19
SBTypeNameSpecifier()20 SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {
21 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
22 }
23
SBTypeNameSpecifier(const char * name,bool is_regex)24 SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
25 : m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
26 LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name,
27 is_regex);
28
29 if (name == nullptr || (*name) == 0)
30 m_opaque_sp.reset();
31 }
32
SBTypeNameSpecifier(SBType type)33 SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
34 LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
35
36 if (type.IsValid())
37 m_opaque_sp = TypeNameSpecifierImplSP(
38 new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
39 }
40
SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier & rhs)41 SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
42 : m_opaque_sp(rhs.m_opaque_sp) {
43 LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
44 (const lldb::SBTypeNameSpecifier &), rhs);
45 }
46
47 SBTypeNameSpecifier::~SBTypeNameSpecifier() = default;
48
IsValid() const49 bool SBTypeNameSpecifier::IsValid() const {
50 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
51 return this->operator bool();
52 }
operator bool() const53 SBTypeNameSpecifier::operator bool() const {
54 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool);
55
56 return m_opaque_sp.get() != nullptr;
57 }
58
GetName()59 const char *SBTypeNameSpecifier::GetName() {
60 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
61
62 if (!IsValid())
63 return nullptr;
64
65 return m_opaque_sp->GetName();
66 }
67
GetType()68 SBType SBTypeNameSpecifier::GetType() {
69 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
70
71 if (!IsValid())
72 return LLDB_RECORD_RESULT(SBType());
73 lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
74 if (c_type.IsValid())
75 return LLDB_RECORD_RESULT(SBType(c_type));
76 return LLDB_RECORD_RESULT(SBType());
77 }
78
IsRegex()79 bool SBTypeNameSpecifier::IsRegex() {
80 LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
81
82 if (!IsValid())
83 return false;
84
85 return m_opaque_sp->IsRegex();
86 }
87
GetDescription(lldb::SBStream & description,lldb::DescriptionLevel description_level)88 bool SBTypeNameSpecifier::GetDescription(
89 lldb::SBStream &description, lldb::DescriptionLevel description_level) {
90 LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
91 (lldb::SBStream &, lldb::DescriptionLevel), description,
92 description_level);
93
94 if (!IsValid())
95 return false;
96 description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),
97 IsRegex() ? "regex" : "plain");
98 return true;
99 }
100
101 lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
operator =(const lldb::SBTypeNameSpecifier & rhs)102 operator=(const lldb::SBTypeNameSpecifier &rhs) {
103 LLDB_RECORD_METHOD(
104 lldb::SBTypeNameSpecifier &,
105 SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
106
107 if (this != &rhs) {
108 m_opaque_sp = rhs.m_opaque_sp;
109 }
110 return LLDB_RECORD_RESULT(*this);
111 }
112
operator ==(lldb::SBTypeNameSpecifier & rhs)113 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
114 LLDB_RECORD_METHOD(
115 bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
116
117 if (!IsValid())
118 return !rhs.IsValid();
119 return m_opaque_sp == rhs.m_opaque_sp;
120 }
121
IsEqualTo(lldb::SBTypeNameSpecifier & rhs)122 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
123 LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
124 (lldb::SBTypeNameSpecifier &), rhs);
125
126 if (!IsValid())
127 return !rhs.IsValid();
128
129 if (IsRegex() != rhs.IsRegex())
130 return false;
131 if (GetName() == nullptr || rhs.GetName() == nullptr)
132 return false;
133
134 return (strcmp(GetName(), rhs.GetName()) == 0);
135 }
136
operator !=(lldb::SBTypeNameSpecifier & rhs)137 bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
138 LLDB_RECORD_METHOD(
139 bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
140
141 if (!IsValid())
142 return !rhs.IsValid();
143 return m_opaque_sp != rhs.m_opaque_sp;
144 }
145
GetSP()146 lldb::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() {
147 return m_opaque_sp;
148 }
149
SetSP(const lldb::TypeNameSpecifierImplSP & type_namespec_sp)150 void SBTypeNameSpecifier::SetSP(
151 const lldb::TypeNameSpecifierImplSP &type_namespec_sp) {
152 m_opaque_sp = type_namespec_sp;
153 }
154
SBTypeNameSpecifier(const lldb::TypeNameSpecifierImplSP & type_namespec_sp)155 SBTypeNameSpecifier::SBTypeNameSpecifier(
156 const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
157 : m_opaque_sp(type_namespec_sp) {}
158
159 namespace lldb_private {
160 namespace repro {
161
162 template <>
RegisterMethods(Registry & R)163 void RegisterMethods<SBTypeNameSpecifier>(Registry &R) {
164 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
165 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
166 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
167 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
168 (const lldb::SBTypeNameSpecifier &));
169 LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
170 LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
171 LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
172 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
173 LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
174 LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
175 (lldb::SBStream &, lldb::DescriptionLevel));
176 LLDB_REGISTER_METHOD(
177 lldb::SBTypeNameSpecifier &,
178 SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
179 LLDB_REGISTER_METHOD(
180 bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
181 LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
182 (lldb::SBTypeNameSpecifier &));
183 LLDB_REGISTER_METHOD(
184 bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
185 }
186
187 }
188 }
189