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 "lldb/API/SBTarget.h"
11#include "lldb/Target/Target.h"
12#include "lldb/Utility/Instrumentation.h"
13
14#include "lldb/lldb-private.h"
15
16using namespace lldb;
17using namespace lldb_private;
18
19class VariablesOptionsImpl {
20public:
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
32 bool GetIncludeArguments() const { return m_include_arguments; }
33
34 void SetIncludeArguments(bool b) { m_include_arguments = b; }
35
36 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
42 void SetIncludeRecognizedArguments(bool b) {
43 m_include_recognized_arguments = b ? eLazyBoolYes : eLazyBoolNo;
44 }
45
46 bool GetIncludeLocals() const { return m_include_locals; }
47
48 void SetIncludeLocals(bool b) { m_include_locals = b; }
49
50 bool GetIncludeStatics() const { return m_include_statics; }
51
52 void SetIncludeStatics(bool b) { m_include_statics = b; }
53
54 bool GetInScopeOnly() const { return m_in_scope_only; }
55
56 void SetInScopeOnly(bool b) { m_in_scope_only = b; }
57
58 bool GetIncludeRuntimeSupportValues() const {
59 return m_include_runtime_support_values;
60 }
61
62 void SetIncludeRuntimeSupportValues(bool b) {
63 m_include_runtime_support_values = b;
64 }
65
66 lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
67
68 void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; }
69
70private:
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
81SBVariablesOptions::SBVariablesOptions()
82 : m_opaque_up(new VariablesOptionsImpl()) {
83 LLDB_INSTRUMENT_VA(this);
84}
85
86SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
87 : m_opaque_up(new VariablesOptionsImpl(options.ref())) {
88 LLDB_INSTRUMENT_VA(this, options);
89}
90
91SBVariablesOptions &SBVariablesOptions::
92operator=(const SBVariablesOptions &options) {
93 LLDB_INSTRUMENT_VA(this, options);
94
95 m_opaque_up = std::make_unique<VariablesOptionsImpl>(args: options.ref());
96 return *this;
97}
98
99SBVariablesOptions::~SBVariablesOptions() = default;
100
101bool SBVariablesOptions::IsValid() const {
102 LLDB_INSTRUMENT_VA(this);
103 return this->operator bool();
104}
105SBVariablesOptions::operator bool() const {
106 LLDB_INSTRUMENT_VA(this);
107
108 return m_opaque_up != nullptr;
109}
110
111bool SBVariablesOptions::GetIncludeArguments() const {
112 LLDB_INSTRUMENT_VA(this);
113
114 return m_opaque_up->GetIncludeArguments();
115}
116
117void SBVariablesOptions::SetIncludeArguments(bool arguments) {
118 LLDB_INSTRUMENT_VA(this, arguments);
119
120 m_opaque_up->SetIncludeArguments(arguments);
121}
122
123bool SBVariablesOptions::GetIncludeRecognizedArguments(
124 const lldb::SBTarget &target) const {
125 LLDB_INSTRUMENT_VA(this, target);
126
127 return m_opaque_up->GetIncludeRecognizedArguments(target_sp: target.GetSP());
128}
129
130void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
131 LLDB_INSTRUMENT_VA(this, arguments);
132
133 m_opaque_up->SetIncludeRecognizedArguments(arguments);
134}
135
136bool SBVariablesOptions::GetIncludeLocals() const {
137 LLDB_INSTRUMENT_VA(this);
138
139 return m_opaque_up->GetIncludeLocals();
140}
141
142void SBVariablesOptions::SetIncludeLocals(bool locals) {
143 LLDB_INSTRUMENT_VA(this, locals);
144
145 m_opaque_up->SetIncludeLocals(locals);
146}
147
148bool SBVariablesOptions::GetIncludeStatics() const {
149 LLDB_INSTRUMENT_VA(this);
150
151 return m_opaque_up->GetIncludeStatics();
152}
153
154void SBVariablesOptions::SetIncludeStatics(bool statics) {
155 LLDB_INSTRUMENT_VA(this, statics);
156
157 m_opaque_up->SetIncludeStatics(statics);
158}
159
160bool SBVariablesOptions::GetInScopeOnly() const {
161 LLDB_INSTRUMENT_VA(this);
162
163 return m_opaque_up->GetInScopeOnly();
164}
165
166void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
167 LLDB_INSTRUMENT_VA(this, in_scope_only);
168
169 m_opaque_up->SetInScopeOnly(in_scope_only);
170}
171
172bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
173 LLDB_INSTRUMENT_VA(this);
174
175 return m_opaque_up->GetIncludeRuntimeSupportValues();
176}
177
178void SBVariablesOptions::SetIncludeRuntimeSupportValues(
179 bool runtime_support_values) {
180 LLDB_INSTRUMENT_VA(this, runtime_support_values);
181
182 m_opaque_up->SetIncludeRuntimeSupportValues(runtime_support_values);
183}
184
185lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
186 LLDB_INSTRUMENT_VA(this);
187
188 return m_opaque_up->GetUseDynamic();
189}
190
191void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
192 LLDB_INSTRUMENT_VA(this, dynamic);
193
194 m_opaque_up->SetUseDynamic(dynamic);
195}
196
197VariablesOptionsImpl *SBVariablesOptions::operator->() {
198 return m_opaque_up.operator->();
199}
200
201const VariablesOptionsImpl *SBVariablesOptions::operator->() const {
202 return m_opaque_up.operator->();
203}
204
205VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_up.get(); }
206
207VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_up; }
208
209const VariablesOptionsImpl &SBVariablesOptions::ref() const {
210 return *m_opaque_up;
211}
212
213SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
214 : m_opaque_up(std::move(lldb_object_ptr)) {}
215
216void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
217 m_opaque_up.reset(p: std::move(lldb_object_ptr));
218}
219

source code of lldb/source/API/SBVariablesOptions.cpp