1 //===-- SBCommandReturnObject.cpp -------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/API/SBCommandReturnObject.h"
10 #include "SBReproducerPrivate.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"
19 using namespace lldb_private;
21 SBCommandReturnObject::SBCommandReturnObject()
22 : m_opaque_up(new CommandReturnObject()) {
23 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
26 SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
28 LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
29 (const lldb::SBCommandReturnObject &), rhs);
31 m_opaque_up = clone(rhs.m_opaque_up);
34 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
36 LLDB_RECORD_CONSTRUCTOR(SBCommandReturnObject,
37 (lldb_private::CommandReturnObject *), ptr);
40 SBCommandReturnObject::~SBCommandReturnObject() = default;
42 CommandReturnObject *SBCommandReturnObject::Release() {
43 LLDB_RECORD_METHOD_NO_ARGS(lldb_private::CommandReturnObject *,
44 SBCommandReturnObject, Release);
46 return LLDB_RECORD_RESULT(m_opaque_up.release());
49 const SBCommandReturnObject &SBCommandReturnObject::
50 operator=(const SBCommandReturnObject &rhs) {
52 const lldb::SBCommandReturnObject &,
53 SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &),
57 m_opaque_up = clone(rhs.m_opaque_up);
58 return LLDB_RECORD_RESULT(*this);
61 bool SBCommandReturnObject::IsValid() const {
62 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
63 return this->operator bool();
65 SBCommandReturnObject::operator bool() const {
66 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);
68 return m_opaque_up != nullptr;
71 const char *SBCommandReturnObject::GetOutput() {
72 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
75 llvm::StringRef output = m_opaque_up->GetOutputData();
76 ConstString result(output.empty() ? llvm::StringRef("") : output);
78 return result.AsCString();
84 const char *SBCommandReturnObject::GetError() {
85 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetError);
88 llvm::StringRef output = m_opaque_up->GetErrorData();
89 ConstString result(output.empty() ? llvm::StringRef("") : output);
90 return result.AsCString();
96 size_t SBCommandReturnObject::GetOutputSize() {
97 LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetOutputSize);
99 return (m_opaque_up ? m_opaque_up->GetOutputData().size() : 0);
102 size_t SBCommandReturnObject::GetErrorSize() {
103 LLDB_RECORD_METHOD_NO_ARGS(size_t, SBCommandReturnObject, GetErrorSize);
105 return (m_opaque_up ? m_opaque_up->GetErrorData().size() : 0);
108 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
109 LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *), fh);
112 size_t num_bytes = GetOutputSize();
114 return ::fprintf(fh, "%s", GetOutput());
119 size_t SBCommandReturnObject::PutError(FILE *fh) {
120 LLDB_RECORD_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *), fh);
123 size_t num_bytes = GetErrorSize();
125 return ::fprintf(fh, "%s", GetError());
130 void SBCommandReturnObject::Clear() {
131 LLDB_RECORD_METHOD_NO_ARGS(void, SBCommandReturnObject, Clear);
134 m_opaque_up->Clear();
137 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
138 LLDB_RECORD_METHOD_NO_ARGS(lldb::ReturnStatus, SBCommandReturnObject,
141 return (m_opaque_up ? m_opaque_up->GetStatus() : lldb::eReturnStatusInvalid);
144 void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
145 LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetStatus,
146 (lldb::ReturnStatus), status);
149 m_opaque_up->SetStatus(status);
152 bool SBCommandReturnObject::Succeeded() {
153 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, Succeeded);
155 return (m_opaque_up ? m_opaque_up->Succeeded() : false);
158 bool SBCommandReturnObject::HasResult() {
159 LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommandReturnObject, HasResult);
161 return (m_opaque_up ? m_opaque_up->HasResult() : false);
164 void SBCommandReturnObject::AppendMessage(const char *message) {
165 LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendMessage, (const char *),
169 m_opaque_up->AppendMessage(message);
172 void SBCommandReturnObject::AppendWarning(const char *message) {
173 LLDB_RECORD_METHOD(void, SBCommandReturnObject, AppendWarning, (const char *),
177 m_opaque_up->AppendWarning(message);
180 CommandReturnObject *SBCommandReturnObject::operator->() const {
181 return m_opaque_up.get();
184 CommandReturnObject *SBCommandReturnObject::get() const {
185 return m_opaque_up.get();
188 CommandReturnObject &SBCommandReturnObject::operator*() const {
189 assert(m_opaque_up.get());
190 return *(m_opaque_up.get());
193 CommandReturnObject &SBCommandReturnObject::ref() const {
194 assert(m_opaque_up.get());
195 return *(m_opaque_up.get());
198 void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) {
200 m_opaque_up.reset(ptr);
203 bool SBCommandReturnObject::GetDescription(SBStream &description) {
204 LLDB_RECORD_METHOD(bool, SBCommandReturnObject, GetDescription,
205 (lldb::SBStream &), description);
207 Stream &strm = description.ref();
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");
219 strm.PutCString("Fail");
221 if (GetOutputSize() > 0)
222 strm.Printf("\nOutput Message:\n%s", GetOutput());
224 if (GetErrorSize() > 0)
225 strm.Printf("\nError Message:\n%s", GetError());
227 strm.PutCString("No value");
232 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
233 LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
236 SetImmediateOutputFile(fh, false);
239 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
240 LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
243 SetImmediateErrorFile(fh, false);
246 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
247 bool transfer_ownership) {
248 LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
249 (FILE *, bool), fh, transfer_ownership);
252 m_opaque_up->SetImmediateOutputFile(fh, transfer_ownership);
255 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
256 bool transfer_ownership) {
257 LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
258 (FILE *, bool), fh, transfer_ownership);
261 m_opaque_up->SetImmediateErrorFile(fh, transfer_ownership);
264 void SBCommandReturnObject::PutCString(const char *string, int len) {
265 LLDB_RECORD_METHOD(void, SBCommandReturnObject, PutCString,
266 (const char *, int), string, len);
269 if (len == 0 || string == nullptr || *string == 0) {
271 } else if (len > 0) {
272 std::string buffer(string, len);
273 m_opaque_up->AppendMessage(buffer.c_str());
275 m_opaque_up->AppendMessage(string);
279 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
280 LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetOutput, (bool),
281 only_if_no_immediate);
285 if (!only_if_no_immediate ||
286 m_opaque_up->GetImmediateOutputStream().get() == nullptr)
291 const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
292 LLDB_RECORD_METHOD(const char *, SBCommandReturnObject, GetError, (bool),
293 only_if_no_immediate);
297 if (!only_if_no_immediate ||
298 m_opaque_up->GetImmediateErrorStream().get() == nullptr)
303 size_t SBCommandReturnObject::Printf(const char *format, ...) {
306 va_start(args, format);
307 size_t result = m_opaque_up->GetOutputStream().PrintfVarArg(format, args);
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);
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);
328 void SBCommandReturnObject::SetError(const char *error_cstr) {
329 LLDB_RECORD_METHOD(void, SBCommandReturnObject, SetError, (const char *),
332 if (m_opaque_up && error_cstr)
333 m_opaque_up->SetError(error_cstr);
336 namespace lldb_private {
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,
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,
368 LLDB_REGISTER_METHOD(void, SBCommandReturnObject, AppendWarning,
370 LLDB_REGISTER_METHOD(bool, SBCommandReturnObject, GetDescription,
372 LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
374 LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
376 LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateOutputFile,
378 LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetImmediateErrorFile,
380 LLDB_REGISTER_METHOD(void, SBCommandReturnObject, PutCString,
381 (const char *, int));
382 LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput,
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 *));