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 
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() : m_opaque_sp() {}
21 
22 SBTypeNameSpecifier::SBTypeNameSpecifier(const char *name, bool is_regex)
23     : m_opaque_sp(new TypeNameSpecifierImpl(name, is_regex)) {
24   if (name == NULL || (*name) == 0)
25     m_opaque_sp.reset();
26 }
27 
28 SBTypeNameSpecifier::SBTypeNameSpecifier(SBType type) : m_opaque_sp() {
29   if (type.IsValid())
30     m_opaque_sp = TypeNameSpecifierImplSP(
31         new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
32 }
33 
34 SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
35     : m_opaque_sp(rhs.m_opaque_sp) {}
36 
37 SBTypeNameSpecifier::~SBTypeNameSpecifier() {}
38 
39 bool SBTypeNameSpecifier::IsValid() const { return m_opaque_sp.get() != NULL; }
40 
41 const char *SBTypeNameSpecifier::GetName() {
42   if (!IsValid())
43     return NULL;
44 
45   return m_opaque_sp->GetName();
46 }
47 
48 SBType SBTypeNameSpecifier::GetType() {
49   if (!IsValid())
50     return SBType();
51   lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType();
52   if (c_type.IsValid())
53     return SBType(c_type);
54   return SBType();
55 }
56 
57 bool SBTypeNameSpecifier::IsRegex() {
58   if (!IsValid())
59     return false;
60 
61   return m_opaque_sp->IsRegex();
62 }
63 
64 bool SBTypeNameSpecifier::GetDescription(
65     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
66   if (!IsValid())
67     return false;
68   description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),
69                      IsRegex() ? "regex" : "plain");
70   return true;
71 }
72 
73 lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
74 operator=(const lldb::SBTypeNameSpecifier &rhs) {
75   if (this != &rhs) {
76     m_opaque_sp = rhs.m_opaque_sp;
77   }
78   return *this;
79 }
80 
81 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
82   if (!IsValid())
83     return !rhs.IsValid();
84   return m_opaque_sp == rhs.m_opaque_sp;
85 }
86 
87 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
88   if (!IsValid())
89     return !rhs.IsValid();
90 
91   if (IsRegex() != rhs.IsRegex())
92     return false;
93   if (GetName() == NULL || rhs.GetName() == NULL)
94     return false;
95 
96   return (strcmp(GetName(), rhs.GetName()) == 0);
97 }
98 
99 bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {
100   if (!IsValid())
101     return !rhs.IsValid();
102   return m_opaque_sp != rhs.m_opaque_sp;
103 }
104 
105 lldb::TypeNameSpecifierImplSP SBTypeNameSpecifier::GetSP() {
106   return m_opaque_sp;
107 }
108 
109 void SBTypeNameSpecifier::SetSP(
110     const lldb::TypeNameSpecifierImplSP &type_namespec_sp) {
111   m_opaque_sp = type_namespec_sp;
112 }
113 
114 SBTypeNameSpecifier::SBTypeNameSpecifier(
115     const lldb::TypeNameSpecifierImplSP &type_namespec_sp)
116     : m_opaque_sp(type_namespec_sp) {}
117