1 //===-- SBCommandInterpreterRunOptions.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/lldb-types.h"
10
11 #include "SBReproducerPrivate.h"
12
13 #include "lldb/API/SBCommandInterpreterRunOptions.h"
14 #include "lldb/Interpreter/CommandInterpreter.h"
15
16 #include <memory>
17
18 using namespace lldb;
19 using namespace lldb_private;
20
SBCommandInterpreterRunOptions()21 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
22 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
23
24 m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
25 }
26
SBCommandInterpreterRunOptions(const SBCommandInterpreterRunOptions & rhs)27 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(
28 const SBCommandInterpreterRunOptions &rhs)
29 : m_opaque_up() {
30 LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunOptions,
31 (const lldb::SBCommandInterpreterRunOptions &), rhs);
32
33 m_opaque_up = std::make_unique<CommandInterpreterRunOptions>(rhs.ref());
34 }
35
36 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
37
operator =(const SBCommandInterpreterRunOptions & rhs)38 SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
39 const SBCommandInterpreterRunOptions &rhs) {
40 LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunOptions &,
41 SBCommandInterpreterRunOptions, operator=,
42 (const lldb::SBCommandInterpreterRunOptions &), rhs);
43
44 if (this == &rhs)
45 return LLDB_RECORD_RESULT(*this);
46 *m_opaque_up = *rhs.m_opaque_up;
47 return LLDB_RECORD_RESULT(*this);
48 }
49
GetStopOnContinue() const50 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
51 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
52 GetStopOnContinue);
53
54 return m_opaque_up->GetStopOnContinue();
55 }
56
SetStopOnContinue(bool stop_on_continue)57 void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
58 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
59 (bool), stop_on_continue);
60
61 m_opaque_up->SetStopOnContinue(stop_on_continue);
62 }
63
GetStopOnError() const64 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
65 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
66 GetStopOnError);
67
68 return m_opaque_up->GetStopOnError();
69 }
70
SetStopOnError(bool stop_on_error)71 void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
72 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
73 (bool), stop_on_error);
74
75 m_opaque_up->SetStopOnError(stop_on_error);
76 }
77
GetStopOnCrash() const78 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
79 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
80 GetStopOnCrash);
81
82 return m_opaque_up->GetStopOnCrash();
83 }
84
SetStopOnCrash(bool stop_on_crash)85 void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
86 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
87 (bool), stop_on_crash);
88
89 m_opaque_up->SetStopOnCrash(stop_on_crash);
90 }
91
GetEchoCommands() const92 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
93 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
94 GetEchoCommands);
95
96 return m_opaque_up->GetEchoCommands();
97 }
98
SetEchoCommands(bool echo_commands)99 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
100 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
101 (bool), echo_commands);
102
103 m_opaque_up->SetEchoCommands(echo_commands);
104 }
105
GetEchoCommentCommands() const106 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
107 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
108 GetEchoCommentCommands);
109
110 return m_opaque_up->GetEchoCommentCommands();
111 }
112
SetEchoCommentCommands(bool echo)113 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
114 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
115 SetEchoCommentCommands, (bool), echo);
116
117 m_opaque_up->SetEchoCommentCommands(echo);
118 }
119
GetPrintResults() const120 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
121 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
122 GetPrintResults);
123
124 return m_opaque_up->GetPrintResults();
125 }
126
SetPrintResults(bool print_results)127 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
128 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
129 (bool), print_results);
130
131 m_opaque_up->SetPrintResults(print_results);
132 }
133
GetPrintErrors() const134 bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
135 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
136 GetPrintErrors);
137
138 return m_opaque_up->GetPrintErrors();
139 }
140
SetPrintErrors(bool print_errors)141 void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
142 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
143 (bool), print_errors);
144
145 m_opaque_up->SetPrintErrors(print_errors);
146 }
147
GetAddToHistory() const148 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
149 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
150 GetAddToHistory);
151
152 return m_opaque_up->GetAddToHistory();
153 }
154
SetAddToHistory(bool add_to_history)155 void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
156 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
157 (bool), add_to_history);
158
159 m_opaque_up->SetAddToHistory(add_to_history);
160 }
161
GetAutoHandleEvents() const162 bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
163 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
164 GetAutoHandleEvents);
165
166 return m_opaque_up->GetAutoHandleEvents();
167 }
168
SetAutoHandleEvents(bool auto_handle_events)169 void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
170 bool auto_handle_events) {
171 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
172 (bool), auto_handle_events);
173
174 m_opaque_up->SetAutoHandleEvents(auto_handle_events);
175 }
176
GetSpawnThread() const177 bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
178 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
179 GetSpawnThread);
180
181 return m_opaque_up->GetSpawnThread();
182 }
183
SetSpawnThread(bool spawn_thread)184 void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
185 LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
186 (bool), spawn_thread);
187
188 m_opaque_up->SetSpawnThread(spawn_thread);
189 }
190
191 lldb_private::CommandInterpreterRunOptions *
get() const192 SBCommandInterpreterRunOptions::get() const {
193 return m_opaque_up.get();
194 }
195
196 lldb_private::CommandInterpreterRunOptions &
ref() const197 SBCommandInterpreterRunOptions::ref() const {
198 return *m_opaque_up;
199 }
200
SBCommandInterpreterRunResult()201 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
202 : m_opaque_up(new CommandInterpreterRunResult())
203
204 {
205 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunResult);
206 }
207
SBCommandInterpreterRunResult(const SBCommandInterpreterRunResult & rhs)208 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
209 const SBCommandInterpreterRunResult &rhs)
210 : m_opaque_up(new CommandInterpreterRunResult()) {
211 LLDB_RECORD_CONSTRUCTOR(SBCommandInterpreterRunResult,
212 (const lldb::SBCommandInterpreterRunResult &), rhs);
213
214 *m_opaque_up = *rhs.m_opaque_up;
215 }
216
SBCommandInterpreterRunResult(const CommandInterpreterRunResult & rhs)217 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
218 const CommandInterpreterRunResult &rhs)
219 : m_opaque_up() {
220 m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs);
221 }
222
223 SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
224
operator =(const SBCommandInterpreterRunResult & rhs)225 SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
226 const SBCommandInterpreterRunResult &rhs) {
227 LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult &,
228 SBCommandInterpreterRunResult, operator=,
229 (const lldb::SBCommandInterpreterRunResult &), rhs);
230
231 if (this == &rhs)
232 return LLDB_RECORD_RESULT(*this);
233 *m_opaque_up = *rhs.m_opaque_up;
234 return LLDB_RECORD_RESULT(*this);
235 }
236
GetNumberOfErrors() const237 int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
238 LLDB_RECORD_METHOD_CONST_NO_ARGS(int, SBCommandInterpreterRunResult,
239 GetNumberOfErrors);
240
241 return m_opaque_up->GetNumErrors();
242 }
243
244 lldb::CommandInterpreterResult
GetResult() const245 SBCommandInterpreterRunResult::GetResult() const {
246 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::CommandInterpreterResult,
247 SBCommandInterpreterRunResult, GetResult);
248
249 return m_opaque_up->GetResult();
250 }
251
252 namespace lldb_private {
253 namespace repro {
254
RegisterMethods(Registry & R)255 template <> void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
256 LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
257 LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions,
258 (const lldb::SBCommandInterpreterRunOptions &));
259 LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunOptions &,
260 SBCommandInterpreterRunOptions, operator=,
261 (const lldb::SBCommandInterpreterRunOptions &));
262 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
263 GetStopOnContinue, ());
264 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
265 (bool));
266 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
267 GetStopOnError, ());
268 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
269 (bool));
270 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
271 GetStopOnCrash, ());
272 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
273 (bool));
274 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
275 GetEchoCommands, ());
276 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
277 (bool));
278 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
279 GetEchoCommentCommands, ());
280 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
281 SetEchoCommentCommands, (bool));
282 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
283 GetPrintResults, ());
284 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
285 (bool));
286 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
287 GetPrintErrors, ());
288 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintErrors,
289 (bool));
290 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
291 GetAddToHistory, ());
292 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
293 (bool));
294 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
295 GetAutoHandleEvents, ());
296 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
297 SetAutoHandleEvents, (bool));
298 LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
299 GetSpawnThread, ());
300 LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
301 (bool));
302 LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResult, ());
303 LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunResult,
304 (const lldb::SBCommandInterpreterRunResult &));
305 LLDB_REGISTER_METHOD(lldb::SBCommandInterpreterRunResult &,
306 SBCommandInterpreterRunResult, operator=,
307 (const lldb::SBCommandInterpreterRunResult &));
308 LLDB_REGISTER_METHOD_CONST(int, SBCommandInterpreterRunResult,
309 GetNumberOfErrors, ());
310 LLDB_REGISTER_METHOD_CONST(lldb::CommandInterpreterResult,
311 SBCommandInterpreterRunResult, GetResult, ());
312 }
313
314 } // namespace repro
315 } // namespace lldb_private
316