1 //===-- SBTypeFormat.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/SBTypeFormat.h"
10 #include "lldb/Utility/Instrumentation.h"
11 
12 #include "lldb/API/SBStream.h"
13 
14 #include "lldb/DataFormatters/DataVisualization.h"
15 
16 using namespace lldb;
17 using namespace lldb_private;
18 
19 SBTypeFormat::SBTypeFormat() { LLDB_INSTRUMENT_VA(this); }
20 
21 SBTypeFormat::SBTypeFormat(lldb::Format format, uint32_t options)
22     : m_opaque_sp(
23           TypeFormatImplSP(new TypeFormatImpl_Format(format, options))) {
24   LLDB_INSTRUMENT_VA(this, format, options);
25 }
26 
27 SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
28     : m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
29           ConstString(type ? type : ""), options))) {
30   LLDB_INSTRUMENT_VA(this, type, options);
31 }
32 
33 SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
34     : m_opaque_sp(rhs.m_opaque_sp) {
35   LLDB_INSTRUMENT_VA(this, rhs);
36 }
37 
38 SBTypeFormat::~SBTypeFormat() = default;
39 
40 bool SBTypeFormat::IsValid() const {
41   LLDB_INSTRUMENT_VA(this);
42   return this->operator bool();
43 }
44 SBTypeFormat::operator bool() const {
45   LLDB_INSTRUMENT_VA(this);
46 
47   return m_opaque_sp.get() != nullptr;
48 }
49 
50 lldb::Format SBTypeFormat::GetFormat() {
51   LLDB_INSTRUMENT_VA(this);
52 
53   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
54     return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
55   return lldb::eFormatInvalid;
56 }
57 
58 const char *SBTypeFormat::GetTypeName() {
59   LLDB_INSTRUMENT_VA(this);
60 
61   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)
62     return ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
63         ->GetTypeName()
64         .AsCString("");
65   return "";
66 }
67 
68 uint32_t SBTypeFormat::GetOptions() {
69   LLDB_INSTRUMENT_VA(this);
70 
71   if (IsValid())
72     return m_opaque_sp->GetOptions();
73   return 0;
74 }
75 
76 void SBTypeFormat::SetFormat(lldb::Format fmt) {
77   LLDB_INSTRUMENT_VA(this, fmt);
78 
79   if (CopyOnWrite_Impl(Type::eTypeFormat))
80     ((TypeFormatImpl_Format *)m_opaque_sp.get())->SetFormat(fmt);
81 }
82 
83 void SBTypeFormat::SetTypeName(const char *type) {
84   LLDB_INSTRUMENT_VA(this, type);
85 
86   if (CopyOnWrite_Impl(Type::eTypeEnum))
87     ((TypeFormatImpl_EnumType *)m_opaque_sp.get())
88         ->SetTypeName(ConstString(type ? type : ""));
89 }
90 
91 void SBTypeFormat::SetOptions(uint32_t value) {
92   LLDB_INSTRUMENT_VA(this, value);
93 
94   if (CopyOnWrite_Impl(Type::eTypeKeepSame))
95     m_opaque_sp->SetOptions(value);
96 }
97 
98 bool SBTypeFormat::GetDescription(lldb::SBStream &description,
99                                   lldb::DescriptionLevel description_level) {
100   LLDB_INSTRUMENT_VA(this, description, description_level);
101 
102   if (!IsValid())
103     return false;
104   else {
105     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
106     return true;
107   }
108 }
109 
110 lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
111   LLDB_INSTRUMENT_VA(this, rhs);
112 
113   if (this != &rhs) {
114     m_opaque_sp = rhs.m_opaque_sp;
115   }
116   return *this;
117 }
118 
119 bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
120   LLDB_INSTRUMENT_VA(this, rhs);
121 
122   if (!IsValid())
123     return !rhs.IsValid();
124   return m_opaque_sp == rhs.m_opaque_sp;
125 }
126 
127 bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
128   LLDB_INSTRUMENT_VA(this, rhs);
129 
130   if (!IsValid())
131     return !rhs.IsValid();
132 
133   if (GetFormat() == rhs.GetFormat())
134     return GetOptions() == rhs.GetOptions();
135   else
136     return false;
137 }
138 
139 bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {
140   LLDB_INSTRUMENT_VA(this, rhs);
141 
142   if (!IsValid())
143     return !rhs.IsValid();
144   return m_opaque_sp != rhs.m_opaque_sp;
145 }
146 
147 lldb::TypeFormatImplSP SBTypeFormat::GetSP() { return m_opaque_sp; }
148 
149 void SBTypeFormat::SetSP(const lldb::TypeFormatImplSP &typeformat_impl_sp) {
150   m_opaque_sp = typeformat_impl_sp;
151 }
152 
153 SBTypeFormat::SBTypeFormat(const lldb::TypeFormatImplSP &typeformat_impl_sp)
154     : m_opaque_sp(typeformat_impl_sp) {}
155 
156 bool SBTypeFormat::CopyOnWrite_Impl(Type type) {
157   if (!IsValid())
158     return false;
159 
160   if (m_opaque_sp.unique() &&
161       ((type == Type::eTypeKeepSame) ||
162        (type == Type::eTypeFormat &&
163         m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat) ||
164        (type == Type::eTypeEnum &&
165         m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeEnum)))
166     return true;
167 
168   if (type == Type::eTypeKeepSame) {
169     if (m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
170       type = Type::eTypeFormat;
171     else
172       type = Type::eTypeEnum;
173   }
174 
175   if (type == Type::eTypeFormat)
176     SetSP(
177         TypeFormatImplSP(new TypeFormatImpl_Format(GetFormat(), GetOptions())));
178   else
179     SetSP(TypeFormatImplSP(
180         new TypeFormatImpl_EnumType(ConstString(GetTypeName()), GetOptions())));
181 
182   return true;
183 }
184