contrib/llvm-project/lldb/source/API/SBCommandReturnObject.cpp

   1 //===-- SBCommandReturnObject.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/SBCommandReturnObject.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "Utils.h"
  12 #include "lldb/API/SBError.h"
  13 #include "lldb/API/SBStream.h"
  14 #include "lldb/Interpreter/CommandReturnObject.h"
  15 #include "lldb/Utility/ConstString.h"
  16 #include "lldb/Utility/Status.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBCommandReturnObject::SBCommandReturnObject()
  22     : m_opaque_up(new CommandReturnObject()) {
  23   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
  24 }
  25
  26 SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
  27     : m_opaque_up() {
  28   LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
  29                           (const lldb::SBCommandReturnObject &), rhs);
  30
  31   m_opaque_up = clone(rhs.m_opaque_up);
  32 }
  33
  34 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
  35     : m_opaque_up(ptr) {
  36   LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
  37                           (lldb_private::CommandReturnObject *), ptr);
  38 }
  39
  40 SBCommandReturnObject::~SBCommandReturnObject() = default;
  41
  42 CommandReturnObject *SBCommandReturnObject::Release() {
  43   LLDB_RECORD_METHOD_NO_ARGS(lldb_private::CommandReturnObject *,
  44                              SBCommandReturnObject, Release);
  45
  46   return LLDB_RECORD_RESULT(m_opaque_up.release());
  47 }
  48
  49 const SBCommandReturnObject &SBCommandReturnObject::
  50 operator=(const SBCommandReturnObject &rhs) {
  51   LLDB_RECORD_METHOD(
  52       const lldb::SBCommandReturnObject &,
  53       SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
  54       rhs);
  55
  56   if (this != &rhs)
  57     m_opaque_up = clone(rhs.m_opaque_up);
  58   return LLDB_RECORD_RESULT(*this);
  59 }
  60
  61 bool SBCommandReturnObject::IsValid() const {
  62   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
  63   return this->operator bool();
  64 }
  65 SBCommandReturnObject::operator bool() const {
  66   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);
  67
  68   return m_opaque_up != nullptr;
  69 }
  70
  71 const char *SBCommandReturnObject::GetOutput() {
  72   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
  73
  74   if (m_opaque_up) {
  75     llvm::StringRef output = m_opaque_up->GetOutputData();
  76     ConstString result(output.empty() ? llvm::StringRef("") : output);
  77
  78     return result.AsCString();
  79   }
  80
  81   return nullptr;
  82 }
  83
  84 const char *SBCommandReturnObject::GetError() {
  85   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
  86
  87   if (m_opaque_up) {
  88     llvm::StringRef output = m_opaque_up->GetErrorData();
  89     ConstString result(output.empty() ? llvm::StringRef("") : output);
  90     return result.AsCString();
  91   }
  92
  93   return nullptr;
  94 }
  95
  96 size_t SBCommandReturnObject::GetOutputSize() {
  97   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
  98
  99   return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0);
 100 }
 101
 102 size_t SBCommandReturnObject::GetErrorSize() {
 103   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
 104
 105   return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0);
 106 }
 107
 108 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
 109   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
 110
 111   if (fh) {
 112     size_t num_bytes = GetOutputSize();
 113     if (num_bytes)
 114       return ::fprintf(fh, "%s", GetOutput());
 115   }
 116   return 0;
 117 }
 118
 119 size_t SBCommandReturnObject::PutError(FILE *fh) {
 120   LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
 121
 122   if (fh) {
 123     size_t num_bytes = GetErrorSize();
 124     if (num_bytes)
 125       return ::fprintf(fh, "%s", GetError());
 126   }
 127   return 0;
 128 }
 129
 130 void SBCommandReturnObject::Clear() {
 131   LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
 132
 133   if (m_opaque_up)
 134     m_opaque_up->Clear();
 135 }
 136
 137 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
 138   LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
 139                              GetStatus);
 140
 141   return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid);
 142 }
 143
 144 void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
 145   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
 146                      (lldb::ReturnStatus), status);
 147
 148   if (m_opaque_up)
 149     m_opaque_up->SetStatus(status);
 150 }
 151
 152 bool SBCommandReturnObject::Succeeded() {
 153   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
 154
 155   return (m_opaque_up ? m_opaque_up->Succeeded() : false);
 156 }
 157
 158 bool SBCommandReturnObject::HasResult() {
 159   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
 160
 161   return (m_opaque_up ? m_opaque_up->HasResult() : false);
 162 }
 163
 164 void SBCommandReturnObject::AppendMessage(const char *message) {
 165   LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
 166                      message);
 167
 168   if (m_opaque_up)
 169     m_opaque_up->AppendMessage(message);
 170 }
 171
 172 void SBCommandReturnObject::AppendWarning(const char *message) {
 173   LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
 174                      message);
 175
 176   if (m_opaque_up)
 177     m_opaque_up->AppendWarning(message);
 178 }
 179
 180 CommandReturnObject *SBCommandReturnObject::operator->() const {
 181   return m_opaque_up.get();
 182 }
 183
 184 CommandReturnObject *SBCommandReturnObject::get() const {
 185   return m_opaque_up.get();
 186 }
 187
 188 CommandReturnObject &SBCommandReturnObject::operator*() const {
 189   assert(m_opaque_up.get());
 190   return *(m_opaque_up.get());
 191 }
 192
 193 CommandReturnObject &SBCommandReturnObject::ref() const {
 194   assert(m_opaque_up.get());
 195   return *(m_opaque_up.get());
 196 }
 197
 198 void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) {
 199   if (m_opaque_up)
 200     m_opaque_up.reset(ptr);
 201 }
 202
 203 bool SBCommandReturnObject::GetDescription(SBStream &description) {
 204   LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
 205                      (lldb::SBStream &), description);
 206
 207   Stream &strm = description.ref();
 208
 209   if (m_opaque_up) {
 210     description.Printf("Error:  ");
 211     lldb::ReturnStatus status = m_opaque_up->GetStatus();
 212     if (status == lldb::eReturnStatusStarted)
 213       strm.PutCString("Started");
 214     else if (status == lldb::eReturnStatusInvalid)
 215       strm.PutCString("Invalid");
 216     else if (m_opaque_up->Succeeded())
 217       strm.PutCString("Success");
 218     else
 219       strm.PutCString("Fail");
 220
 221     if (GetOutputSize() > 0)
 222       strm.Printf("\nOutput Message:\n%s", GetOutput());
 223
 224     if (GetErrorSize() > 0)
 225       strm.Printf("\nError Message:\n%s", GetError());
 226   } else
 227     strm.PutCString("No value");
 228
 229   return true;
 230 }
 231
 232 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
 233   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
 234                      (FILE *), fh);
 235
 236   SetImmediateOutputFile(fh, false);
 237 }
 238
 239 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
 240   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
 241                      (FILE *), fh);
 242
 243   SetImmediateErrorFile(fh, false);
 244 }
 245
 246 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
 247                                                    bool transfer_ownership) {
 248   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
 249                      (FILE *, bool), fh, transfer_ownership);
 250
 251   if (m_opaque_up)
 252     m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership);
 253 }
 254
 255 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
 256                                                   bool transfer_ownership) {
 257   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
 258                      (FILE *, bool), fh, transfer_ownership);
 259
 260   if (m_opaque_up)
 261     m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership);
 262 }
 263
 264 void SBCommandReturnObject::PutCString(const char *string, int len) {
 265   LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
 266                      (const char *, int), string, len);
 267
 268   if (m_opaque_up) {
 269     if (len == 0 || string == nullptr || *string == 0) {
 270       return;
 271     } else if (len > 0) {
 272       std::string buffer(string, len);
 273       m_opaque_up->AppendMessage(buffer.c_str());
 274     } else
 275       m_opaque_up->AppendMessage(string);
 276   }
 277 }
 278
 279 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
 280   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
 281                      only_if_no_immediate);
 282
 283   if (!m_opaque_up)
 284     return nullptr;
 285   if (!only_if_no_immediate ||
 286       m_opaque_up->GetImmediateOutputStream().get() == nullptr)
 287     return GetOutput();
 288   return nullptr;
 289 }
 290
 291 const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
 292   LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
 293                      only_if_no_immediate);
 294
 295   if (!m_opaque_up)
 296     return nullptr;
 297   if (!only_if_no_immediate ||
 298       m_opaque_up->GetImmediateErrorStream().get() == nullptr)
 299     return GetError();
 300   return nullptr;
 301 }
 302
 303 size_t SBCommandReturnObject::Printf(const char *format, ...) {
 304   if (m_opaque_up) {
 305     va_list args;
 306     va_start(args, format);
 307     size_t result = m_opaque_up->GetOutputStream().PrintfVarArg(format, args);
 308     va_end(args);
 309     return result;
 310   }
 311   return 0;
 312 }
 313
 314 void SBCommandReturnObject::SetError(lldb::SBError &error,
 315                                      const char *fallback_error_cstr) {
 316   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError,
 317                      (lldb::SBError &, const char *), error,
 318                      fallback_error_cstr);
 319
 320   if (m_opaque_up) {
 321     if (error.IsValid())
 322       m_opaque_up->SetError(error.ref(), fallback_error_cstr);
 323     else if (fallback_error_cstr)
 324       m_opaque_up->SetError(Status(), fallback_error_cstr);
 325   }
 326 }
 327
 328 void SBCommandReturnObject::SetError(const char *error_cstr) {
 329   LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
 330                      error_cstr);
 331
 332   if (m_opaque_up && error_cstr)
 333     m_opaque_up->SetError(error_cstr);
 334 }
 335
 336 namespace lldb_private {
 337 namespace repro {
 338
 339 template <>
 340 void RegisterMethods<SBCommandReturnObject>(Registry &R) {
 341   LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject, ());
 342   LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
 343                             (const lldb::SBCommandReturnObject &));
 344   LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
 345                             (lldb_private::CommandReturnObject *));
 346   LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
 347                        SBCommandReturnObject, Release, ());
 348   LLDB_REGISTER_METHOD(
 349       const lldb::SBCommandReturnObject &,
 350       SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
 351   LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
 352   LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
 353   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
 354   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
 355   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
 356   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
 357   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
 358   LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
 359   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
 360   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
 361                        ());
 362   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetStatus,
 363                        (lldb::ReturnStatus));
 364   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, Succeeded, ());
 365   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, HasResult, ());
 366   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendMessage,
 367                        (const char *));
 368   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
 369                        (const char *));
 370   LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
 371                        (lldb::SBStream &));
 372   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
 373                        (FILE *));
 374   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
 375                        (FILE *));
 376   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
 377                        (FILE *, bool));
 378   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
 379                        (FILE *, bool));
 380   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
 381                        (const char *, int));
 382   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
 383                        (bool));
 384   LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, (bool));
 385   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
 386                        (lldb::SBError &, const char *));
 387   LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
 388 }
 389
 390 }
 391 }