contrib/llvm/tools/lldb/source/API/SBTypeNameSpecifier.cpp

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