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
18 using namespace lldb;
19 using namespace lldb_private;
20
SBCommandInterpreterRunOptions()21 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
22 LLDB_INSTRUMENT_VA(this);
23
24 m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
25 }
26
SBCommandInterpreterRunOptions(const SBCommandInterpreterRunOptions & rhs)27 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(
28 const SBCommandInterpreterRunOptions &rhs) {
29 LLDB_INSTRUMENT_VA(this, rhs);
30
31 m_opaque_up = std::make_unique<CommandInterpreterRunOptions>(rhs.ref());
32 }
33
34 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
35
operator =(const SBCommandInterpreterRunOptions & rhs)36 SBCommandInterpreterRunOptions &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
GetStopOnContinue() const46 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
47 LLDB_INSTRUMENT_VA(this);
48
49 return m_opaque_up->GetStopOnContinue();
50 }
51
SetStopOnContinue(bool stop_on_continue)52 void 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
GetStopOnError() const58 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
59 LLDB_INSTRUMENT_VA(this);
60
61 return m_opaque_up->GetStopOnError();
62 }
63
SetStopOnError(bool stop_on_error)64 void 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
GetStopOnCrash() const70 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
71 LLDB_INSTRUMENT_VA(this);
72
73 return m_opaque_up->GetStopOnCrash();
74 }
75
SetStopOnCrash(bool stop_on_crash)76 void 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
GetEchoCommands() const82 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
83 LLDB_INSTRUMENT_VA(this);
84
85 return m_opaque_up->GetEchoCommands();
86 }
87
SetEchoCommands(bool echo_commands)88 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
89 LLDB_INSTRUMENT_VA(this, echo_commands);
90
91 m_opaque_up->SetEchoCommands(echo_commands);
92 }
93
GetEchoCommentCommands() const94 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
95 LLDB_INSTRUMENT_VA(this);
96
97 return m_opaque_up->GetEchoCommentCommands();
98 }
99
SetEchoCommentCommands(bool echo)100 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
101 LLDB_INSTRUMENT_VA(this, echo);
102
103 m_opaque_up->SetEchoCommentCommands(echo);
104 }
105
GetPrintResults() const106 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
107 LLDB_INSTRUMENT_VA(this);
108
109 return m_opaque_up->GetPrintResults();
110 }
111
SetPrintResults(bool print_results)112 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
113 LLDB_INSTRUMENT_VA(this, print_results);
114
115 m_opaque_up->SetPrintResults(print_results);
116 }
117
GetPrintErrors() const118 bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
119 LLDB_INSTRUMENT_VA(this);
120
121 return m_opaque_up->GetPrintErrors();
122 }
123
SetPrintErrors(bool print_errors)124 void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
125 LLDB_INSTRUMENT_VA(this, print_errors);
126
127 m_opaque_up->SetPrintErrors(print_errors);
128 }
129
GetAddToHistory() const130 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
131 LLDB_INSTRUMENT_VA(this);
132
133 return m_opaque_up->GetAddToHistory();
134 }
135
SetAddToHistory(bool add_to_history)136 void 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
GetAutoHandleEvents() const142 bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
143 LLDB_INSTRUMENT_VA(this);
144
145 return m_opaque_up->GetAutoHandleEvents();
146 }
147
SetAutoHandleEvents(bool auto_handle_events)148 void 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
GetSpawnThread() const155 bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
156 LLDB_INSTRUMENT_VA(this);
157
158 return m_opaque_up->GetSpawnThread();
159 }
160
SetSpawnThread(bool spawn_thread)161 void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
162 LLDB_INSTRUMENT_VA(this, spawn_thread);
163
164 m_opaque_up->SetSpawnThread(spawn_thread);
165 }
166
167 lldb_private::CommandInterpreterRunOptions *
get() const168 SBCommandInterpreterRunOptions::get() const {
169 return m_opaque_up.get();
170 }
171
172 lldb_private::CommandInterpreterRunOptions &
ref() const173 SBCommandInterpreterRunOptions::ref() const {
174 return *m_opaque_up;
175 }
176
SBCommandInterpreterRunResult()177 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
178 : m_opaque_up(new CommandInterpreterRunResult())
179
180 {
181 LLDB_INSTRUMENT_VA(this);
182 }
183
SBCommandInterpreterRunResult(const SBCommandInterpreterRunResult & rhs)184 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
185 const SBCommandInterpreterRunResult &rhs)
186 : m_opaque_up(new CommandInterpreterRunResult()) {
187 LLDB_INSTRUMENT_VA(this, rhs);
188
189 *m_opaque_up = *rhs.m_opaque_up;
190 }
191
SBCommandInterpreterRunResult(const CommandInterpreterRunResult & rhs)192 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
193 const CommandInterpreterRunResult &rhs) {
194 m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs);
195 }
196
197 SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
198
operator =(const SBCommandInterpreterRunResult & rhs)199 SBCommandInterpreterRunResult &SBCommandInterpreterRunResult::operator=(
200 const SBCommandInterpreterRunResult &rhs) {
201 LLDB_INSTRUMENT_VA(this, rhs);
202
203 if (this == &rhs)
204 return *this;
205 *m_opaque_up = *rhs.m_opaque_up;
206 return *this;
207 }
208
GetNumberOfErrors() const209 int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
210 LLDB_INSTRUMENT_VA(this);
211
212 return m_opaque_up->GetNumErrors();
213 }
214
215 lldb::CommandInterpreterResult
GetResult() const216 SBCommandInterpreterRunResult::GetResult() const {
217 LLDB_INSTRUMENT_VA(this);
218
219 return m_opaque_up->GetResult();
220 }
221