contrib/llvm/tools/lldb/source/API/SBExpressionOptions.cpp

   1 //===-- SBExpressionOptions.cpp ---------------------------------------------*-
   2 //C++ -*-===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is distributed under the University of Illinois Open Source
   7 // License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #include "lldb/API/SBExpressionOptions.h"
  12 #include "lldb/API/SBStream.h"
  13
  14 #include "lldb/Target/Target.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 SBExpressionOptions::SBExpressionOptions()
  20     : m_opaque_ap(new EvaluateExpressionOptions()) {}
  21
  22 SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) {
  23   m_opaque_ap.reset(new EvaluateExpressionOptions());
  24   *(m_opaque_ap.get()) = rhs.ref();
  25 }
  26
  27 const SBExpressionOptions &SBExpressionOptions::
  28 operator=(const SBExpressionOptions &rhs) {
  29   if (this != &rhs) {
  30     this->ref() = rhs.ref();
  31   }
  32   return *this;
  33 }
  34
  35 SBExpressionOptions::~SBExpressionOptions() {}
  36
  37 bool SBExpressionOptions::GetCoerceResultToId() const {
  38   return m_opaque_ap->DoesCoerceToId();
  39 }
  40
  41 void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
  42   m_opaque_ap->SetCoerceToId(coerce);
  43 }
  44
  45 bool SBExpressionOptions::GetUnwindOnError() const {
  46   return m_opaque_ap->DoesUnwindOnError();
  47 }
  48
  49 void SBExpressionOptions::SetUnwindOnError(bool unwind) {
  50   m_opaque_ap->SetUnwindOnError(unwind);
  51 }
  52
  53 bool SBExpressionOptions::GetIgnoreBreakpoints() const {
  54   return m_opaque_ap->DoesIgnoreBreakpoints();
  55 }
  56
  57 void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
  58   m_opaque_ap->SetIgnoreBreakpoints(ignore);
  59 }
  60
  61 lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
  62   return m_opaque_ap->GetUseDynamic();
  63 }
  64
  65 void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
  66   m_opaque_ap->SetUseDynamic(dynamic);
  67 }
  68
  69 uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
  70   return m_opaque_ap->GetTimeout() ? m_opaque_ap->GetTimeout()->count() : 0;
  71 }
  72
  73 void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
  74   m_opaque_ap->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None)
  75                                        : std::chrono::microseconds(timeout));
  76 }
  77
  78 uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
  79   return m_opaque_ap->GetOneThreadTimeout() ? m_opaque_ap->GetOneThreadTimeout()->count() : 0;
  80 }
  81
  82 void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
  83   m_opaque_ap->SetOneThreadTimeout(timeout == 0
  84                                        ? Timeout<std::micro>(llvm::None)
  85                                        : std::chrono::microseconds(timeout));
  86 }
  87
  88 bool SBExpressionOptions::GetTryAllThreads() const {
  89   return m_opaque_ap->GetTryAllThreads();
  90 }
  91
  92 void SBExpressionOptions::SetTryAllThreads(bool run_others) {
  93   m_opaque_ap->SetTryAllThreads(run_others);
  94 }
  95
  96 bool SBExpressionOptions::GetStopOthers() const {
  97   return m_opaque_ap->GetStopOthers();
  98 }
  99
 100 void SBExpressionOptions::SetStopOthers(bool run_others) {
 101   m_opaque_ap->SetStopOthers(run_others);
 102 }
 103
 104 bool SBExpressionOptions::GetTrapExceptions() const {
 105   return m_opaque_ap->GetTrapExceptions();
 106 }
 107
 108 void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
 109   m_opaque_ap->SetTrapExceptions(trap_exceptions);
 110 }
 111
 112 void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
 113   m_opaque_ap->SetLanguage(language);
 114 }
 115
 116 void SBExpressionOptions::SetCancelCallback(
 117     lldb::ExpressionCancelCallback callback, void *baton) {
 118   m_opaque_ap->SetCancelCallback(callback, baton);
 119 }
 120
 121 bool SBExpressionOptions::GetGenerateDebugInfo() {
 122   return m_opaque_ap->GetGenerateDebugInfo();
 123 }
 124
 125 void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
 126   return m_opaque_ap->SetGenerateDebugInfo(b);
 127 }
 128
 129 bool SBExpressionOptions::GetSuppressPersistentResult() {
 130   return m_opaque_ap->GetResultIsInternal();
 131 }
 132
 133 void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
 134   return m_opaque_ap->SetResultIsInternal(b);
 135 }
 136
 137 const char *SBExpressionOptions::GetPrefix() const {
 138   return m_opaque_ap->GetPrefix();
 139 }
 140
 141 void SBExpressionOptions::SetPrefix(const char *prefix) {
 142   return m_opaque_ap->SetPrefix(prefix);
 143 }
 144
 145 bool SBExpressionOptions::GetAutoApplyFixIts() {
 146   return m_opaque_ap->GetAutoApplyFixIts();
 147 }
 148
 149 void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
 150   return m_opaque_ap->SetAutoApplyFixIts(b);
 151 }
 152
 153 bool SBExpressionOptions::GetTopLevel() {
 154   return m_opaque_ap->GetExecutionPolicy() == eExecutionPolicyTopLevel;
 155 }
 156
 157 void SBExpressionOptions::SetTopLevel(bool b) {
 158   m_opaque_ap->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
 159                                     : m_opaque_ap->default_execution_policy);
 160 }
 161
 162 bool SBExpressionOptions::GetAllowJIT() {
 163   return m_opaque_ap->GetExecutionPolicy() != eExecutionPolicyNever;
 164 }
 165
 166 void SBExpressionOptions::SetAllowJIT(bool allow) {
 167   m_opaque_ap->SetExecutionPolicy(allow ? m_opaque_ap->default_execution_policy
 168                                     : eExecutionPolicyNever);
 169 }
 170
 171 EvaluateExpressionOptions *SBExpressionOptions::get() const {
 172   return m_opaque_ap.get();
 173 }
 174
 175 EvaluateExpressionOptions &SBExpressionOptions::ref() const {
 176   return *(m_opaque_ap.get());
 177 }