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>(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 167lldb_private::CommandInterpreterRunOptions * 168SBCommandInterpreterRunOptions::get() const { 169 return m_opaque_up.get(); 170} 171 172lldb_private::CommandInterpreterRunOptions & 173SBCommandInterpreterRunOptions::ref() const { 174 return *m_opaque_up; 175} 176 177SBCommandInterpreterRunResult::SBCommandInterpreterRunResult() 178 : m_opaque_up(new CommandInterpreterRunResult()) 179 180{ 181 LLDB_INSTRUMENT_VA(this); 182} 183 184SBCommandInterpreterRunResult::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 192SBCommandInterpreterRunResult::SBCommandInterpreterRunResult( 193 const CommandInterpreterRunResult &rhs) { 194 m_opaque_up = std::make_unique<CommandInterpreterRunResult>(rhs); 195} 196 197SBCommandInterpreterRunResult::~SBCommandInterpreterRunResult() = default; 198 199SBCommandInterpreterRunResult &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 209int SBCommandInterpreterRunResult::GetNumberOfErrors() const { 210 LLDB_INSTRUMENT_VA(this); 211 212 return m_opaque_up->GetNumErrors(); 213} 214 215lldb::CommandInterpreterResult 216SBCommandInterpreterRunResult::GetResult() const { 217 LLDB_INSTRUMENT_VA(this); 218 219 return m_opaque_up->GetResult(); 220} 221