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