lldb/source/API/SBError.cpp

   1 //===-- SBError.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/API/SBError.h"
  10 #include "Utils.h"
  11 #include "lldb/API/SBStream.h"
  12 #include "lldb/Utility/Instrumentation.h"
  13 #include "lldb/Utility/Status.h"
  14 #include "lldb/Utility/VASPrintf.h"
  15
  16 #include <cstdarg>
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBError::SBError() { LLDB_INSTRUMENT_VA(this); }
  22
  23 SBError::SBError(const SBError &rhs) {
  24   LLDB_INSTRUMENT_VA(this, rhs);
  25
  26   if (rhs.m_opaque_up)
  27     m_opaque_up = std::make_unique<Status>(rhs.m_opaque_up->Clone());
  28 }
  29
  30 SBError::SBError(const char *message) {
  31   LLDB_INSTRUMENT_VA(this, message);
  32
  33   SetErrorString(message);
  34 }
  35
  36 SBError::SBError(lldb_private::Status &&status)
  37     : m_opaque_up(new Status(std::move(status))) {
  38   LLDB_INSTRUMENT_VA(this, status);
  39 }
  40
  41 SBError::~SBError() = default;
  42
  43 const SBError &SBError::operator=(const SBError &rhs) {
  44   LLDB_INSTRUMENT_VA(this, rhs);
  45
  46   if (this != &rhs)
  47     if (rhs.m_opaque_up)
  48       m_opaque_up = std::make_unique<Status>(rhs.m_opaque_up->Clone());
  49
  50   return *this;
  51 }
  52
  53 const char *SBError::GetCString() const {
  54   LLDB_INSTRUMENT_VA(this);
  55
  56   if (m_opaque_up)
  57     return m_opaque_up->AsCString();
  58   return nullptr;
  59 }
  60
  61 void SBError::Clear() {
  62   LLDB_INSTRUMENT_VA(this);
  63
  64   if (m_opaque_up)
  65     m_opaque_up->Clear();
  66 }
  67
  68 bool SBError::Fail() const {
  69   LLDB_INSTRUMENT_VA(this);
  70
  71   bool ret_value = false;
  72   if (m_opaque_up)
  73     ret_value = m_opaque_up->Fail();
  74
  75
  76   return ret_value;
  77 }
  78
  79 bool SBError::Success() const {
  80   LLDB_INSTRUMENT_VA(this);
  81
  82   bool ret_value = true;
  83   if (m_opaque_up)
  84     ret_value = m_opaque_up->Success();
  85
  86   return ret_value;
  87 }
  88
  89 uint32_t SBError::GetError() const {
  90   LLDB_INSTRUMENT_VA(this);
  91
  92   uint32_t err = 0;
  93   if (m_opaque_up)
  94     err = m_opaque_up->GetError();
  95
  96
  97   return err;
  98 }
  99
 100 ErrorType SBError::GetType() const {
 101   LLDB_INSTRUMENT_VA(this);
 102
 103   ErrorType err_type = eErrorTypeInvalid;
 104   if (m_opaque_up)
 105     err_type = m_opaque_up->GetType();
 106
 107   return err_type;
 108 }
 109
 110 void SBError::SetError(uint32_t err, ErrorType type) {
 111   LLDB_INSTRUMENT_VA(this, err, type);
 112
 113   CreateIfNeeded();
 114   *m_opaque_up = Status(err, type);
 115 }
 116
 117 void SBError::SetError(Status &&lldb_error) {
 118   CreateIfNeeded();
 119   *m_opaque_up = std::move(lldb_error);
 120 }
 121
 122 void SBError::SetErrorToErrno() {
 123   LLDB_INSTRUMENT_VA(this);
 124
 125   CreateIfNeeded();
 126   *m_opaque_up = Status::FromErrno();
 127 }
 128
 129 void SBError::SetErrorToGenericError() {
 130   LLDB_INSTRUMENT_VA(this);
 131
 132   CreateIfNeeded();
 133   *m_opaque_up = Status(std::string("generic error"));
 134 }
 135
 136 void SBError::SetErrorString(const char *err_str) {
 137   LLDB_INSTRUMENT_VA(this, err_str);
 138
 139   CreateIfNeeded();
 140   *m_opaque_up = Status::FromErrorString(err_str);
 141 }
 142
 143 int SBError::SetErrorStringWithFormat(const char *format, ...) {
 144   CreateIfNeeded();
 145   std::string string;
 146   va_list args;
 147   va_start(args, format);
 148   if (format != nullptr && format[0]) {
 149     llvm::SmallString<1024> buf;
 150     VASprintf(buf, format, args);
 151     string = std::string(buf.str());
 152     *m_opaque_up = Status(std::move(string));
 153   }
 154   va_end(args);
 155   return string.size();
 156 }
 157
 158 bool SBError::IsValid() const {
 159   LLDB_INSTRUMENT_VA(this);
 160   return this->operator bool();
 161 }
 162 SBError::operator bool() const {
 163   LLDB_INSTRUMENT_VA(this);
 164
 165   return m_opaque_up != nullptr;
 166 }
 167
 168 void SBError::CreateIfNeeded() {
 169   if (m_opaque_up == nullptr)
 170     m_opaque_up = std::make_unique<Status>();
 171 }
 172
 173 lldb_private::Status *SBError::operator->() { return m_opaque_up.get(); }
 174
 175 lldb_private::Status *SBError::get() { return m_opaque_up.get(); }
 176
 177 lldb_private::Status &SBError::ref() {
 178   CreateIfNeeded();
 179   return *m_opaque_up;
 180 }
 181
 182 const lldb_private::Status &SBError::operator*() const {
 183   // Be sure to call "IsValid()" before calling this function or it will crash
 184   return *m_opaque_up;
 185 }
 186
 187 bool SBError::GetDescription(SBStream &description) {
 188   LLDB_INSTRUMENT_VA(this, description);
 189
 190   if (m_opaque_up) {
 191     if (m_opaque_up->Success())
 192       description.Printf("success");
 193     else {
 194       const char *err_string = GetCString();
 195       description.Printf("error: %s",
 196                          (err_string != nullptr ? err_string : ""));
 197     }
 198   } else
 199     description.Printf("error: <NULL>");
 200
 201   return true;
 202 }