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 "SBReproducerPrivate.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 LLDB_RECORD_RESULT(SBType()); 73 lldb_private::CompilerType c_type = m_opaque_sp->GetCompilerType(); 74 if (c_type.IsValid()) 75 return LLDB_RECORD_RESULT(SBType(c_type)); 76 return LLDB_RECORD_RESULT(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 LLDB_RECORD_RESULT(*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 159 namespace lldb_private { 160 namespace repro { 161 162 template <> 163 void RegisterMethods<SBTypeNameSpecifier>(Registry &R) { 164 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ()); 165 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool)); 166 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType)); 167 LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, 168 (const lldb::SBTypeNameSpecifier &)); 169 LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ()); 170 LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ()); 171 LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ()); 172 LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ()); 173 LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ()); 174 LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription, 175 (lldb::SBStream &, lldb::DescriptionLevel)); 176 LLDB_REGISTER_METHOD( 177 lldb::SBTypeNameSpecifier &, 178 SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &)); 179 LLDB_REGISTER_METHOD( 180 bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &)); 181 LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo, 182 (lldb::SBTypeNameSpecifier &)); 183 LLDB_REGISTER_METHOD( 184 bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &)); 185 } 186 187 } 188 } 189