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