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