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