lldb/source/API/SBCommandInterpreterRunOptions.cpp

   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 }