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/ReproducerInstrumentation.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 
20 SBTypeNameSpecifier::SBTypeNameSpecifier() {
21   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
22 }
23 
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 
33 SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) {
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 
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 
49 bool SBTypeNameSpecifier::IsValid() const {
50   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
51   return this->operator bool();
52 }
53 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 
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 
68 SBType SBTypeNameSpecifier::GetType() {
69   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
70 
71   if (!IsValid())
72     return SBType();
73   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
74   if (c_type.IsValid())
75     return SBType(c_type);
76   return SBType();
77 }
78 
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 
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::
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 *this;
111 }
112 
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 
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 
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 
146 lldb::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() {
147   return m_opaque_sp;
148 }
149 
150 void SBTypeNameSpecifier::SetSP(
151     const lldb::TypeNameSpecifierImplSP &type_namespec_sp) {
152   m_opaque_sp = type_namespec_sp;
153 }
154 
155 SBTypeNameSpecifier::SBTypeNameSpecifier(
156     const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
157     : m_opaque_sp(type_namespec_sp) {}
158