1 //===-- SBTypeNameSpecifier.cpp ------------------------------------*- C++
2 //-*-===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/API/SBTypeNameSpecifier.h"
11 #include "SBReproducerPrivate.h"
12 
13 #include "lldb/API/SBStream.h"
14 #include "lldb/API/SBType.h"
15 
16 #include "lldb/DataFormatters/DataVisualization.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 SBTypeNameSpecifier::SBTypeNameSpecifier() : m_opaque_sp() {
22   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeNameSpecifier);
23 }
24 
25 SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
26     : m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
27   LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool), name,
28                           is_regex);
29 
30   if (name == NULL || (*name) == 0)
31     m_opaque_sp.reset();
32 }
33 
34 SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
35   LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType), type);
36 
37   if (type.IsValid())
38     m_opaque_sp = TypeNameSpecifierImplSP(
39         new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
40 }
41 
42 SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
43     : m_opaque_sp(rhs.m_opaque_sp) {
44   LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
45                           (const lldb::SBTypeNameSpecifier &), rhs);
46 }
47 
48 SBTypeNameSpecifier::~SBTypeNameSpecifier() {}
49 
50 bool SBTypeNameSpecifier::IsValid() const {
51   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
52 
53   return m_opaque_sp.get() != NULL;
54 }
55 
56 const char *SBTypeNameSpecifier::GetName() {
57   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
58 
59   if (!IsValid())
60     return NULL;
61 
62   return m_opaque_sp->GetName();
63 }
64 
65 SBType SBTypeNameSpecifier::GetType() {
66   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBTypeNameSpecifier, GetType);
67 
68   if (!IsValid())
69     return LLDB_RECORD_RESULT(SBType());
70   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
71   if (c_type.IsValid())
72     return LLDB_RECORD_RESULT(SBType(c_type));
73   return LLDB_RECORD_RESULT(SBType());
74 }
75 
76 bool SBTypeNameSpecifier::IsRegex() {
77   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeNameSpecifier, IsRegex);
78 
79   if (!IsValid())
80     return false;
81 
82   return m_opaque_sp->IsRegex();
83 }
84 
85 bool SBTypeNameSpecifier::GetDescription(
86     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
87   LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, GetDescription,
88                      (lldb::SBStream &, lldb::DescriptionLevel), description,
89                      description_level);
90 
91   if (!IsValid())
92     return false;
93   description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),
94                      IsRegex() ? "regex" : "plain");
95   return true;
96 }
97 
98 lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
99 operator=(const lldb::SBTypeNameSpecifier &rhs) {
100   LLDB_RECORD_METHOD(
101       lldb::SBTypeNameSpecifier &,
102       SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &), rhs);
103 
104   if (this != &rhs) {
105     m_opaque_sp = rhs.m_opaque_sp;
106   }
107   return *this;
108 }
109 
110 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
111   LLDB_RECORD_METHOD(
112       bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &), rhs);
113 
114   if (!IsValid())
115     return !rhs.IsValid();
116   return m_opaque_sp == rhs.m_opaque_sp;
117 }
118 
119 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
120   LLDB_RECORD_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
121                      (lldb::SBTypeNameSpecifier &), rhs);
122 
123   if (!IsValid())
124     return !rhs.IsValid();
125 
126   if (IsRegex() != rhs.IsRegex())
127     return false;
128   if (GetName() == NULL || rhs.GetName() == NULL)
129     return false;
130 
131   return (strcmp(GetName(), rhs.GetName()) == 0);
132 }
133 
134 bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
135   LLDB_RECORD_METHOD(
136       bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &), rhs);
137 
138   if (!IsValid())
139     return !rhs.IsValid();
140   return m_opaque_sp != rhs.m_opaque_sp;
141 }
142 
143 lldb::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() {
144   return m_opaque_sp;
145 }
146 
147 void SBTypeNameSpecifier::SetSP(
148     const lldb::TypeNameSpecifierImplSP &type_namespec_sp) {
149   m_opaque_sp = type_namespec_sp;
150 }
151 
152 SBTypeNameSpecifier::SBTypeNameSpecifier(
153     const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
154     : m_opaque_sp(type_namespec_sp) {}
155