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 bool SBCommandInterpreterRunOptions::GetAllowRepeats() const { 168 LLDB_INSTRUMENT_VA(this); 169 170 return m_opaque_up->GetAllowRepeats(); 171 } 172 173 void SBCommandInterpreterRunOptions::SetAllowRepeats(bool allow_repeats) { 174 LLDB_INSTRUMENT_VA(this, allow_repeats); 175 176 m_opaque_up->SetAllowRepeats(allow_repeats); 177 } 178 179 lldb_private::CommandInterpreterRunOptions * 180 SBCommandInterpreterRunOptions::get() const { 181 return m_opaque_up.get(); 182 } 183 184 lldb_private::CommandInterpreterRunOptions & 185 SBCommandInterpreterRunOptions::ref() const { 186 return *m_opaque_up; 187 } 188 189 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult() 190 : m_opaque_up(new CommandInterpreterRunResult()) 191 192 { 193 LLDB_INSTRUMENT_VA(this); 194 } 195 196 SBCommandInterpreterRunResult::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 204 SBCommandInterpreterRunResult::SBCommandInterpreterRunResult( 205 const CommandInterpreterRunResult &rhs) { 206 m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs); 207 } 208 209 SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default; 210 211 SBCommandInterpreterRunResult &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 221 int SBCommandInterpreterRunResult::GetNumberOfErrors() const { 222 LLDB_INSTRUMENT_VA(this); 223 224 return m_opaque_up->GetNumErrors(); 225 } 226 227 lldb::CommandInterpreterResult 228 SBCommandInterpreterRunResult::GetResult() const { 229 LLDB_INSTRUMENT_VA(this); 230 231 return m_opaque_up->GetResult(); 232 } 233