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 "lldb/Utility/Instrumentation.h"
12
13#include "lldb/API/SBCommandInterpreterRunOptions.h"
14#include "lldb/Interpreter/CommandInterpreter.h"
15
16#include <memory>
17
18using namespace lldb;
19using namespace lldb_private;
20
21SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
22 LLDB_INSTRUMENT_VA(this);
23
24 m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
25}
26
27SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(
28 const SBCommandInterpreterRunOptions &rhs) {
29 LLDB_INSTRUMENT_VA(this, rhs);
30
31 m_opaque_up = std::make_unique<CommandInterpreterRunOptions>(args&: rhs.ref());
32}
33
34SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
35
36SBCommandInterpreterRunOptions &SBCommandInterpreterRunOptions::operator=(
37 const SBCommandInterpreterRunOptions &rhs) {
38 LLDB_INSTRUMENT_VA(this, rhs);
39
40 if (this == &rhs)
41 return *this;
42 *m_opaque_up = *rhs.m_opaque_up;
43 return *this;
44}
45
46bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
47 LLDB_INSTRUMENT_VA(this);
48
49 return m_opaque_up->GetStopOnContinue();
50}
51
52void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
53 LLDB_INSTRUMENT_VA(this, stop_on_continue);
54
55 m_opaque_up->SetStopOnContinue(stop_on_continue);
56}
57
58bool SBCommandInterpreterRunOptions::GetStopOnError() const {
59 LLDB_INSTRUMENT_VA(this);
60
61 return m_opaque_up->GetStopOnError();
62}
63
64void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
65 LLDB_INSTRUMENT_VA(this, stop_on_error);
66
67 m_opaque_up->SetStopOnError(stop_on_error);
68}
69
70bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
71 LLDB_INSTRUMENT_VA(this);
72
73 return m_opaque_up->GetStopOnCrash();
74}
75
76void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
77 LLDB_INSTRUMENT_VA(this, stop_on_crash);
78
79 m_opaque_up->SetStopOnCrash(stop_on_crash);
80}
81
82bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
83 LLDB_INSTRUMENT_VA(this);
84
85 return m_opaque_up->GetEchoCommands();
86}
87
88void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
89 LLDB_INSTRUMENT_VA(this, echo_commands);
90
91 m_opaque_up->SetEchoCommands(echo_commands);
92}
93
94bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
95 LLDB_INSTRUMENT_VA(this);
96
97 return m_opaque_up->GetEchoCommentCommands();
98}
99
100void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
101 LLDB_INSTRUMENT_VA(this, echo);
102
103 m_opaque_up->SetEchoCommentCommands(echo);
104}
105
106bool SBCommandInterpreterRunOptions::GetPrintResults() const {
107 LLDB_INSTRUMENT_VA(this);
108
109 return m_opaque_up->GetPrintResults();
110}
111
112void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
113 LLDB_INSTRUMENT_VA(this, print_results);
114
115 m_opaque_up->SetPrintResults(print_results);
116}
117
118bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
119 LLDB_INSTRUMENT_VA(this);
120
121 return m_opaque_up->GetPrintErrors();
122}
123
124void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
125 LLDB_INSTRUMENT_VA(this, print_errors);
126
127 m_opaque_up->SetPrintErrors(print_errors);
128}
129
130bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
131 LLDB_INSTRUMENT_VA(this);
132
133 return m_opaque_up->GetAddToHistory();
134}
135
136void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
137 LLDB_INSTRUMENT_VA(this, add_to_history);
138
139 m_opaque_up->SetAddToHistory(add_to_history);
140}
141
142bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
143 LLDB_INSTRUMENT_VA(this);
144
145 return m_opaque_up->GetAutoHandleEvents();
146}
147
148void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
149 bool auto_handle_events) {
150 LLDB_INSTRUMENT_VA(this, auto_handle_events);
151
152 m_opaque_up->SetAutoHandleEvents(auto_handle_events);
153}
154
155bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
156 LLDB_INSTRUMENT_VA(this);
157
158 return m_opaque_up->GetSpawnThread();
159}
160
161void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
162 LLDB_INSTRUMENT_VA(this, spawn_thread);
163
164 m_opaque_up->SetSpawnThread(spawn_thread);
165}
166
167bool SBCommandInterpreterRunOptions::GetAllowRepeats() const {
168 LLDB_INSTRUMENT_VA(this);
169
170 return m_opaque_up->GetAllowRepeats();
171}
172
173void SBCommandInterpreterRunOptions::SetAllowRepeats(bool allow_repeats) {
174 LLDB_INSTRUMENT_VA(this, allow_repeats);
175
176 m_opaque_up->SetAllowRepeats(allow_repeats);
177}
178
179lldb_private::CommandInterpreterRunOptions *
180SBCommandInterpreterRunOptions::get() const {
181 return m_opaque_up.get();
182}
183
184lldb_private::CommandInterpreterRunOptions &
185SBCommandInterpreterRunOptions::ref() const {
186 return *m_opaque_up;
187}
188
189SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
190 : m_opaque_up(new CommandInterpreterRunResult())
191
192{
193 LLDB_INSTRUMENT_VA(this);
194}
195
196SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
197 const SBCommandInterpreterRunResult &rhs)
198 : m_opaque_up(new CommandInterpreterRunResult()) {
199 LLDB_INSTRUMENT_VA(this, rhs);
200
201 *m_opaque_up = *rhs.m_opaque_up;
202}
203
204SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
205 const CommandInterpreterRunResult &rhs) {
206 m_opaque_up = std::make_unique<CommandInterpreterRunResult>(args: rhs);
207}
208
209SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
210
211SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
212 const SBCommandInterpreterRunResult &rhs) {
213 LLDB_INSTRUMENT_VA(this, rhs);
214
215 if (this == &rhs)
216 return *this;
217 *m_opaque_up = *rhs.m_opaque_up;
218 return *this;
219}
220
221int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
222 LLDB_INSTRUMENT_VA(this);
223
224 return m_opaque_up->GetNumErrors();
225}
226
227lldb::CommandInterpreterResult
228SBCommandInterpreterRunResult::GetResult() const {
229 LLDB_INSTRUMENT_VA(this);
230
231 return m_opaque_up->GetResult();
232}
233

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