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