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 "lldb/Utility/Instrumentation.h"
11
12#include "lldb/API/SBStream.h"
13#include "lldb/API/SBType.h"
14
15#include "lldb/DataFormatters/DataVisualization.h"
16
17using namespace lldb;
18using namespace lldb_private;
19
20SBTypeNameSpecifier::SBTypeNameSpecifier() { LLDB_INSTRUMENT_VA(this); }
21
22SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
23 : SBTypeNameSpecifier(name, is_regex ? eFormatterMatchRegex
24 : eFormatterMatchExact) {
25 LLDB_INSTRUMENT_VA(this, name, is_regex);
26}
27
28SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name,
29 FormatterMatchType match_type)
30 : m_opaque_sp(new TypeNameSpecifierImpl(name, match_type)) {
31 LLDB_INSTRUMENT_VA(this, name, match_type);
32
33 if (name == nullptr || (*name) == 0)
34 m_opaque_sp.reset();
35}
36
37SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
38 LLDB_INSTRUMENT_VA(this, type);
39
40 if (type.IsValid())
41 m_opaque_sp = TypeNameSpecifierImplSP(
42 new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(prefer_dynamic: true)));
43}
44
45SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
46 : m_opaque_sp(rhs.m_opaque_sp) {
47 LLDB_INSTRUMENT_VA(this, rhs);
48}
49
50SBTypeNameSpecifier::~SBTypeNameSpecifier() = default;
51
52bool SBTypeNameSpecifier::IsValid() const {
53 LLDB_INSTRUMENT_VA(this);
54 return this->operator bool();
55}
56SBTypeNameSpecifier::operator bool() const {
57 LLDB_INSTRUMENT_VA(this);
58
59 return m_opaque_sp.get() != nullptr;
60}
61
62const char *SBTypeNameSpecifier::GetName() {
63 LLDB_INSTRUMENT_VA(this);
64
65 if (!IsValid())
66 return nullptr;
67
68 return ConstString(m_opaque_sp->GetName()).GetCString();
69}
70
71SBType SBTypeNameSpecifier::GetType() {
72 LLDB_INSTRUMENT_VA(this);
73
74 if (!IsValid())
75 return SBType();
76 lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
77 if (c_type.IsValid())
78 return SBType(c_type);
79 return SBType();
80}
81
82FormatterMatchType SBTypeNameSpecifier::GetMatchType() {
83 LLDB_INSTRUMENT_VA(this);
84 if (!IsValid())
85 return eFormatterMatchExact;
86 return m_opaque_sp->GetMatchType();
87}
88
89bool SBTypeNameSpecifier::IsRegex() {
90 LLDB_INSTRUMENT_VA(this);
91
92 if (!IsValid())
93 return false;
94
95 return m_opaque_sp->GetMatchType() == eFormatterMatchRegex;
96}
97
98bool SBTypeNameSpecifier::GetDescription(
99 lldb::SBStream &description, lldb::DescriptionLevel description_level) {
100 LLDB_INSTRUMENT_VA(this, description, description_level);
101
102 lldb::FormatterMatchType match_type = GetMatchType();
103 const char *match_type_str =
104 (match_type == eFormatterMatchExact ? "plain"
105 : match_type == eFormatterMatchRegex ? "regex"
106 : "callback");
107 if (!IsValid())
108 return false;
109 description.Printf(format: "SBTypeNameSpecifier(%s,%s)", GetName(), match_type_str);
110 return true;
111}
112
113lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
114operator=(const lldb::SBTypeNameSpecifier &rhs) {
115 LLDB_INSTRUMENT_VA(this, rhs);
116
117 if (this != &rhs) {
118 m_opaque_sp = rhs.m_opaque_sp;
119 }
120 return *this;
121}
122
123bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
124 LLDB_INSTRUMENT_VA(this, rhs);
125
126 if (!IsValid())
127 return !rhs.IsValid();
128 return m_opaque_sp == rhs.m_opaque_sp;
129}
130
131bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
132 LLDB_INSTRUMENT_VA(this, rhs);
133
134 if (!IsValid())
135 return !rhs.IsValid();
136
137 if (GetMatchType() != rhs.GetMatchType())
138 return false;
139 if (GetName() == nullptr || rhs.GetName() == nullptr)
140 return false;
141
142 return (strcmp(s1: GetName(), s2: rhs.GetName()) == 0);
143}
144
145bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
146 LLDB_INSTRUMENT_VA(this, rhs);
147
148 if (!IsValid())
149 return !rhs.IsValid();
150 return m_opaque_sp != rhs.m_opaque_sp;
151}
152
153lldb::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() {
154 return m_opaque_sp;
155}
156
157void SBTypeNameSpecifier::SetSP(
158 const lldb::TypeNameSpecifierImplSP &type_namespec_sp) {
159 m_opaque_sp = type_namespec_sp;
160}
161
162SBTypeNameSpecifier::SBTypeNameSpecifier(
163 const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
164 : m_opaque_sp(type_namespec_sp) {}
165

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