1 //===-- SBVariablesOptions.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/SBVariablesOptions.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBTarget.h"
12 #include "lldb/Target/Target.h"
13
14 #include "lldb/lldb-private.h"
15
16 using namespace lldb;
17 using namespace lldb_private;
18
19 class VariablesOptionsImpl {
20 public:
VariablesOptionsImpl()21 VariablesOptionsImpl()
22 : m_include_arguments(false), m_include_locals(false),
23 m_include_statics(false), m_in_scope_only(false),
24 m_include_runtime_support_values(false) {}
25
26 VariablesOptionsImpl(const VariablesOptionsImpl &) = default;
27
28 ~VariablesOptionsImpl() = default;
29
30 VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default;
31
GetIncludeArguments() const32 bool GetIncludeArguments() const { return m_include_arguments; }
33
SetIncludeArguments(bool b)34 void SetIncludeArguments(bool b) { m_include_arguments = b; }
35
GetIncludeRecognizedArguments(const lldb::TargetSP & target_sp) const36 bool GetIncludeRecognizedArguments(const lldb::TargetSP &target_sp) const {
37 if (m_include_recognized_arguments != eLazyBoolCalculate)
38 return m_include_recognized_arguments;
39 return target_sp ? target_sp->GetDisplayRecognizedArguments() : false;
40 }
41
SetIncludeRecognizedArguments(bool b)42 void SetIncludeRecognizedArguments(bool b) {
43 m_include_recognized_arguments = b ? eLazyBoolYes : eLazyBoolNo;
44 }
45
GetIncludeLocals() const46 bool GetIncludeLocals() const { return m_include_locals; }
47
SetIncludeLocals(bool b)48 void SetIncludeLocals(bool b) { m_include_locals = b; }
49
GetIncludeStatics() const50 bool GetIncludeStatics() const { return m_include_statics; }
51
SetIncludeStatics(bool b)52 void SetIncludeStatics(bool b) { m_include_statics = b; }
53
GetInScopeOnly() const54 bool GetInScopeOnly() const { return m_in_scope_only; }
55
SetInScopeOnly(bool b)56 void SetInScopeOnly(bool b) { m_in_scope_only = b; }
57
GetIncludeRuntimeSupportValues() const58 bool GetIncludeRuntimeSupportValues() const {
59 return m_include_runtime_support_values;
60 }
61
SetIncludeRuntimeSupportValues(bool b)62 void SetIncludeRuntimeSupportValues(bool b) {
63 m_include_runtime_support_values = b;
64 }
65
GetUseDynamic() const66 lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
67
SetUseDynamic(lldb::DynamicValueType d)68 void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; }
69
70 private:
71 bool m_include_arguments : 1;
72 bool m_include_locals : 1;
73 bool m_include_statics : 1;
74 bool m_in_scope_only : 1;
75 bool m_include_runtime_support_values : 1;
76 LazyBool m_include_recognized_arguments =
77 eLazyBoolCalculate; // can be overridden with a setting
78 lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
79 };
80
SBVariablesOptions()81 SBVariablesOptions::SBVariablesOptions()
82 : m_opaque_up(new VariablesOptionsImpl()) {
83 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
84 }
85
SBVariablesOptions(const SBVariablesOptions & options)86 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
87 : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
88 LLDB_RECORD_CONSTRUCTOR(SBVariablesOptions,
89 (const lldb::SBVariablesOptions &), options);
90 }
91
92 SBVariablesOptions &SBVariablesOptions::
operator =(const SBVariablesOptions & options)93 operator=(const SBVariablesOptions &options) {
94 LLDB_RECORD_METHOD(
95 lldb::SBVariablesOptions &,
96 SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &),
97 options);
98
99 m_opaque_up = std::make_unique<VariablesOptionsImpl>(options.ref());
100 return LLDB_RECORD_RESULT(*this);
101 }
102
103 SBVariablesOptions::~SBVariablesOptions() = default;
104
IsValid() const105 bool SBVariablesOptions::IsValid() const {
106 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
107 return this->operator bool();
108 }
operator bool() const109 SBVariablesOptions::operator bool() const {
110 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
111
112 return m_opaque_up != nullptr;
113 }
114
GetIncludeArguments() const115 bool SBVariablesOptions::GetIncludeArguments() const {
116 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
117 GetIncludeArguments);
118
119 return m_opaque_up->GetIncludeArguments();
120 }
121
SetIncludeArguments(bool arguments)122 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
123 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool),
124 arguments);
125
126 m_opaque_up->SetIncludeArguments(arguments);
127 }
128
GetIncludeRecognizedArguments(const lldb::SBTarget & target) const129 bool SBVariablesOptions::GetIncludeRecognizedArguments(
130 const lldb::SBTarget &target) const {
131 LLDB_RECORD_METHOD_CONST(bool, SBVariablesOptions,
132 GetIncludeRecognizedArguments,
133 (const lldb::SBTarget &), target);
134
135 return m_opaque_up->GetIncludeRecognizedArguments(target.GetSP());
136 }
137
SetIncludeRecognizedArguments(bool arguments)138 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
139 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRecognizedArguments,
140 (bool), arguments);
141
142 m_opaque_up->SetIncludeRecognizedArguments(arguments);
143 }
144
GetIncludeLocals() const145 bool SBVariablesOptions::GetIncludeLocals() const {
146 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeLocals);
147
148 return m_opaque_up->GetIncludeLocals();
149 }
150
SetIncludeLocals(bool locals)151 void SBVariablesOptions::SetIncludeLocals(bool locals) {
152 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool),
153 locals);
154
155 m_opaque_up->SetIncludeLocals(locals);
156 }
157
GetIncludeStatics() const158 bool SBVariablesOptions::GetIncludeStatics() const {
159 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetIncludeStatics);
160
161 return m_opaque_up->GetIncludeStatics();
162 }
163
SetIncludeStatics(bool statics)164 void SBVariablesOptions::SetIncludeStatics(bool statics) {
165 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool),
166 statics);
167
168 m_opaque_up->SetIncludeStatics(statics);
169 }
170
GetInScopeOnly() const171 bool SBVariablesOptions::GetInScopeOnly() const {
172 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, GetInScopeOnly);
173
174 return m_opaque_up->GetInScopeOnly();
175 }
176
SetInScopeOnly(bool in_scope_only)177 void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
178 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool),
179 in_scope_only);
180
181 m_opaque_up->SetInScopeOnly(in_scope_only);
182 }
183
GetIncludeRuntimeSupportValues() const184 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
185 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
186 GetIncludeRuntimeSupportValues);
187
188 return m_opaque_up->GetIncludeRuntimeSupportValues();
189 }
190
SetIncludeRuntimeSupportValues(bool runtime_support_values)191 void SBVariablesOptions::SetIncludeRuntimeSupportValues(
192 bool runtime_support_values) {
193 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetIncludeRuntimeSupportValues,
194 (bool), runtime_support_values);
195
196 m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
197 }
198
GetUseDynamic() const199 lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
200 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBVariablesOptions,
201 GetUseDynamic);
202
203 return m_opaque_up->GetUseDynamic();
204 }
205
SetUseDynamic(lldb::DynamicValueType dynamic)206 void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
207 LLDB_RECORD_METHOD(void, SBVariablesOptions, SetUseDynamic,
208 (lldb::DynamicValueType), dynamic);
209
210 m_opaque_up->SetUseDynamic(dynamic);
211 }
212
operator ->()213 VariablesOptionsImpl *SBVariablesOptions::operator->() {
214 return m_opaque_up.operator->();
215 }
216
operator ->() const217 const VariablesOptionsImpl *SBVariablesOptions::operator->() const {
218 return m_opaque_up.operator->();
219 }
220
get()221 VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); }
222
ref()223 VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; }
224
ref() const225 const VariablesOptionsImpl &SBVariablesOptions::ref() const {
226 return *m_opaque_up;
227 }
228
SBVariablesOptions(VariablesOptionsImpl * lldb_object_ptr)229 SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
230 : m_opaque_up(std::move(lldb_object_ptr)) {}
231
SetOptions(VariablesOptionsImpl * lldb_object_ptr)232 void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
233 m_opaque_up.reset(std::move(lldb_object_ptr));
234 }
235
236 namespace lldb_private {
237 namespace repro {
238
239 template <>
RegisterMethods(Registry & R)240 void RegisterMethods<SBVariablesOptions>(Registry &R) {
241 LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
242 LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
243 (const lldb::SBVariablesOptions &));
244 LLDB_REGISTER_METHOD(
245 lldb::SBVariablesOptions &,
246 SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
247 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
248 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
249 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
250 ());
251 LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
252 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
253 GetIncludeRecognizedArguments,
254 (const lldb::SBTarget &));
255 LLDB_REGISTER_METHOD(void, SBVariablesOptions,
256 SetIncludeRecognizedArguments, (bool));
257 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeLocals, ());
258 LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeLocals, (bool));
259 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeStatics, ());
260 LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeStatics, (bool));
261 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetInScopeOnly, ());
262 LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetInScopeOnly, (bool));
263 LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
264 GetIncludeRuntimeSupportValues, ());
265 LLDB_REGISTER_METHOD(void, SBVariablesOptions,
266 SetIncludeRuntimeSupportValues, (bool));
267 LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBVariablesOptions,
268 GetUseDynamic, ());
269 LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetUseDynamic,
270 (lldb::DynamicValueType));
271 }
272
273 }
274 }
275