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 
21 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
22   LLDB_INSTRUMENT_VA(this);
23 
24   m_opaque_up = std::make_unique<CommandInterpreterRunOptions>();
25 }
26 
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 
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 
46 bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
47   LLDB_INSTRUMENT_VA(this);
48 
49   return m_opaque_up->GetStopOnContinue();
50 }
51 
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 
58 bool SBCommandInterpreterRunOptions::GetStopOnError() const {
59   LLDB_INSTRUMENT_VA(this);
60 
61   return m_opaque_up->GetStopOnError();
62 }
63 
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 
70 bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
71   LLDB_INSTRUMENT_VA(this);
72 
73   return m_opaque_up->GetStopOnCrash();
74 }
75 
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 
82 bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
83   LLDB_INSTRUMENT_VA(this);
84 
85   return m_opaque_up->GetEchoCommands();
86 }
87 
88 void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
89   LLDB_INSTRUMENT_VA(this, echo_commands);
90 
91   m_opaque_up->SetEchoCommands(echo_commands);
92 }
93 
94 bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
95   LLDB_INSTRUMENT_VA(this);
96 
97   return m_opaque_up->GetEchoCommentCommands();
98 }
99 
100 void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
101   LLDB_INSTRUMENT_VA(this, echo);
102 
103   m_opaque_up->SetEchoCommentCommands(echo);
104 }
105 
106 bool SBCommandInterpreterRunOptions::GetPrintResults() const {
107   LLDB_INSTRUMENT_VA(this);
108 
109   return m_opaque_up->GetPrintResults();
110 }
111 
112 void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
113   LLDB_INSTRUMENT_VA(this, print_results);
114 
115   m_opaque_up->SetPrintResults(print_results);
116 }
117 
118 bool SBCommandInterpreterRunOptions::GetPrintErrors() const {
119   LLDB_INSTRUMENT_VA(this);
120 
121   return m_opaque_up->GetPrintErrors();
122 }
123 
124 void SBCommandInterpreterRunOptions::SetPrintErrors(bool print_errors) {
125   LLDB_INSTRUMENT_VA(this, print_errors);
126 
127   m_opaque_up->SetPrintErrors(print_errors);
128 }
129 
130 bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
131   LLDB_INSTRUMENT_VA(this);
132 
133   return m_opaque_up->GetAddToHistory();
134 }
135 
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 
142 bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
143   LLDB_INSTRUMENT_VA(this);
144 
145   return m_opaque_up->GetAutoHandleEvents();
146 }
147 
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 
155 bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
156   LLDB_INSTRUMENT_VA(this);
157 
158   return m_opaque_up->GetSpawnThread();
159 }
160 
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 *
168 SBCommandInterpreterRunOptions::get() const {
169   return m_opaque_up.get();
170 }
171 
172 lldb_private::CommandInterpreterRunOptions &
173 SBCommandInterpreterRunOptions::ref() const {
174   return *m_opaque_up;
175 }
176 
177 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult()
178     : m_opaque_up(new CommandInterpreterRunResult())
179 
180 {
181   LLDB_INSTRUMENT_VA(this);
182 }
183 
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 
192 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult(
193     const CommandInterpreterRunResult &rhs) {
194   m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs);
195 }
196 
197 SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default;
198 
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 
209 int SBCommandInterpreterRunResult::GetNumberOfErrors() const {
210   LLDB_INSTRUMENT_VA(this);
211 
212   return m_opaque_up->GetNumErrors();
213 }
214 
215 lldb::CommandInterpreterResult
216 SBCommandInterpreterRunResult::GetResult() const {
217   LLDB_INSTRUMENT_VA(this);
218 
219   return m_opaque_up->GetResult();
220 }
221