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