1 //===-- SBCommandReturnObject.cpp -------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 // Other libraries and framework includes
14 #include "lldb/API/SBCommandReturnObject.h"
15 #include "lldb/API/SBError.h"
16 #include "lldb/API/SBStream.h"
18 #include "lldb/Interpreter/CommandReturnObject.h"
19 #include "lldb/Utility/ConstString.h"
20 #include "lldb/Utility/Log.h"
21 #include "lldb/Utility/Status.h"
24 using namespace lldb_private;
26 SBCommandReturnObject::SBCommandReturnObject()
27 : m_opaque_ap(new CommandReturnObject()) {}
29 SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
32 m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap));
35 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
38 SBCommandReturnObject::~SBCommandReturnObject() = default;
40 CommandReturnObject *SBCommandReturnObject::Release() {
41 return m_opaque_ap.release();
44 const SBCommandReturnObject &SBCommandReturnObject::
45 operator=(const SBCommandReturnObject &rhs) {
48 m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap));
55 bool SBCommandReturnObject::IsValid() const {
56 return m_opaque_ap.get() != nullptr;
59 const char *SBCommandReturnObject::GetOutput() {
60 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
63 llvm::StringRef output = m_opaque_ap->GetOutputData();
64 ConstString result(output.empty() ? llvm::StringRef("") : output);
67 log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"",
68 static_cast<void *>(m_opaque_ap.get()), result.AsCString());
70 return result.AsCString();
74 log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr",
75 static_cast<void *>(m_opaque_ap.get()));
80 const char *SBCommandReturnObject::GetError() {
81 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
84 llvm::StringRef output = m_opaque_ap->GetErrorData();
85 ConstString result(output.empty() ? llvm::StringRef("") : output);
87 log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"",
88 static_cast<void *>(m_opaque_ap.get()), result.AsCString());
90 return result.AsCString();
94 log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr",
95 static_cast<void *>(m_opaque_ap.get()));
100 size_t SBCommandReturnObject::GetOutputSize() {
101 return (m_opaque_ap ? m_opaque_ap->GetOutputData().size() : 0);
104 size_t SBCommandReturnObject::GetErrorSize() {
105 return (m_opaque_ap ? m_opaque_ap->GetErrorData().size() : 0);
108 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
110 size_t num_bytes = GetOutputSize();
112 return ::fprintf(fh, "%s", GetOutput());
117 size_t SBCommandReturnObject::PutError(FILE *fh) {
119 size_t num_bytes = GetErrorSize();
121 return ::fprintf(fh, "%s", GetError());
126 void SBCommandReturnObject::Clear() {
128 m_opaque_ap->Clear();
131 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
132 return (m_opaque_ap ? m_opaque_ap->GetStatus() : lldb::eReturnStatusInvalid);
135 void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
137 m_opaque_ap->SetStatus(status);
140 bool SBCommandReturnObject::Succeeded() {
141 return (m_opaque_ap ? m_opaque_ap->Succeeded() : false);
144 bool SBCommandReturnObject::HasResult() {
145 return (m_opaque_ap ? m_opaque_ap->HasResult() : false);
148 void SBCommandReturnObject::AppendMessage(const char *message) {
150 m_opaque_ap->AppendMessage(message);
153 void SBCommandReturnObject::AppendWarning(const char *message) {
155 m_opaque_ap->AppendWarning(message);
158 CommandReturnObject *SBCommandReturnObject::operator->() const {
159 return m_opaque_ap.get();
162 CommandReturnObject *SBCommandReturnObject::get() const {
163 return m_opaque_ap.get();
166 CommandReturnObject &SBCommandReturnObject::operator*() const {
167 assert(m_opaque_ap.get());
168 return *(m_opaque_ap.get());
171 CommandReturnObject &SBCommandReturnObject::ref() const {
172 assert(m_opaque_ap.get());
173 return *(m_opaque_ap.get());
176 void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) {
178 m_opaque_ap.reset(ptr);
181 bool SBCommandReturnObject::GetDescription(SBStream &description) {
182 Stream &strm = description.ref();
185 description.Printf("Error: ");
186 lldb::ReturnStatus status = m_opaque_ap->GetStatus();
187 if (status == lldb::eReturnStatusStarted)
188 strm.PutCString("Started");
189 else if (status == lldb::eReturnStatusInvalid)
190 strm.PutCString("Invalid");
191 else if (m_opaque_ap->Succeeded())
192 strm.PutCString("Success");
194 strm.PutCString("Fail");
196 if (GetOutputSize() > 0)
197 strm.Printf("\nOutput Message:\n%s", GetOutput());
199 if (GetErrorSize() > 0)
200 strm.Printf("\nError Message:\n%s", GetError());
202 strm.PutCString("No value");
207 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
208 SetImmediateOutputFile(fh, false);
211 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
212 SetImmediateErrorFile(fh, false);
215 void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
216 bool transfer_ownership) {
218 m_opaque_ap->SetImmediateOutputFile(fh, transfer_ownership);
221 void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
222 bool transfer_ownership) {
224 m_opaque_ap->SetImmediateErrorFile(fh, transfer_ownership);
227 void SBCommandReturnObject::PutCString(const char *string, int len) {
229 if (len == 0 || string == nullptr || *string == 0) {
231 } else if (len > 0) {
232 std::string buffer(string, len);
233 m_opaque_ap->AppendMessage(buffer.c_str());
235 m_opaque_ap->AppendMessage(string);
239 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
242 if (!only_if_no_immediate ||
243 m_opaque_ap->GetImmediateOutputStream().get() == nullptr)
248 const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
251 if (!only_if_no_immediate ||
252 m_opaque_ap->GetImmediateErrorStream().get() == nullptr)
257 size_t SBCommandReturnObject::Printf(const char *format, ...) {
260 va_start(args, format);
261 size_t result = m_opaque_ap->GetOutputStream().PrintfVarArg(format, args);
268 void SBCommandReturnObject::SetError(lldb::SBError &error,
269 const char *fallback_error_cstr) {
272 m_opaque_ap->SetError(error.ref(), fallback_error_cstr);
273 else if (fallback_error_cstr)
274 m_opaque_ap->SetError(Status(), fallback_error_cstr);
278 void SBCommandReturnObject::SetError(const char *error_cstr) {
279 if (m_opaque_ap && error_cstr)
280 m_opaque_ap->SetError(error_cstr);