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