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\"", 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 () => NULL", m_opaque_ap.get()); 86 87 return NULL; 88 } 89 90 const char * 91 SBCommandReturnObject::GetError () 92 { 93 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 94 95 if (m_opaque_ap.get()) 96 { 97 if (log) 98 log->Printf ("SBCommandReturnObject(%p)::GetError () => \"%s\"", m_opaque_ap.get(), 99 m_opaque_ap->GetErrorData()); 100 101 return m_opaque_ap->GetErrorData(); 102 } 103 104 if (log) 105 log->Printf ("SBCommandReturnObject(%p)::GetError () => NULL", m_opaque_ap.get()); 106 107 return NULL; 108 } 109 110 size_t 111 SBCommandReturnObject::GetOutputSize () 112 { 113 if (m_opaque_ap.get()) 114 return strlen (m_opaque_ap->GetOutputData()); 115 return 0; 116 } 117 118 size_t 119 SBCommandReturnObject::GetErrorSize () 120 { 121 if (m_opaque_ap.get()) 122 return strlen(m_opaque_ap->GetErrorData()); 123 return 0; 124 } 125 126 size_t 127 SBCommandReturnObject::PutOutput (FILE *fh) 128 { 129 if (fh) 130 { 131 size_t num_bytes = GetOutputSize (); 132 if (num_bytes) 133 return ::fprintf (fh, "%s", GetOutput()); 134 } 135 return 0; 136 } 137 138 size_t 139 SBCommandReturnObject::PutError (FILE *fh) 140 { 141 if (fh) 142 { 143 size_t num_bytes = GetErrorSize (); 144 if (num_bytes) 145 return ::fprintf (fh, "%s", GetError()); 146 } 147 return 0; 148 } 149 150 void 151 SBCommandReturnObject::Clear() 152 { 153 if (m_opaque_ap.get()) 154 m_opaque_ap->Clear(); 155 } 156 157 lldb::ReturnStatus 158 SBCommandReturnObject::GetStatus() 159 { 160 if (m_opaque_ap.get()) 161 return m_opaque_ap->GetStatus(); 162 return lldb::eReturnStatusInvalid; 163 } 164 165 void 166 SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) 167 { 168 if (m_opaque_ap.get()) 169 m_opaque_ap->SetStatus(status); 170 } 171 172 bool 173 SBCommandReturnObject::Succeeded () 174 { 175 if (m_opaque_ap.get()) 176 return m_opaque_ap->Succeeded(); 177 return false; 178 } 179 180 bool 181 SBCommandReturnObject::HasResult () 182 { 183 if (m_opaque_ap.get()) 184 return m_opaque_ap->HasResult(); 185 return false; 186 } 187 188 void 189 SBCommandReturnObject::AppendMessage (const char *message) 190 { 191 if (m_opaque_ap.get()) 192 m_opaque_ap->AppendMessage (message); 193 } 194 195 void 196 SBCommandReturnObject::AppendWarning (const char *message) 197 { 198 if (m_opaque_ap.get()) 199 m_opaque_ap->AppendWarning (message); 200 } 201 202 CommandReturnObject * 203 SBCommandReturnObject::operator ->() const 204 { 205 return m_opaque_ap.get(); 206 } 207 208 CommandReturnObject * 209 SBCommandReturnObject::get() const 210 { 211 return m_opaque_ap.get(); 212 } 213 214 CommandReturnObject & 215 SBCommandReturnObject::operator *() const 216 { 217 assert(m_opaque_ap.get()); 218 return *(m_opaque_ap.get()); 219 } 220 221 222 CommandReturnObject & 223 SBCommandReturnObject::ref() const 224 { 225 assert(m_opaque_ap.get()); 226 return *(m_opaque_ap.get()); 227 } 228 229 230 void 231 SBCommandReturnObject::SetLLDBObjectPtr (CommandReturnObject *ptr) 232 { 233 if (m_opaque_ap.get()) 234 m_opaque_ap.reset (ptr); 235 } 236 237 bool 238 SBCommandReturnObject::GetDescription (SBStream &description) 239 { 240 Stream &strm = description.ref(); 241 242 if (m_opaque_ap.get()) 243 { 244 description.Printf ("Status: "); 245 lldb::ReturnStatus status = m_opaque_ap->GetStatus(); 246 if (status == lldb::eReturnStatusStarted) 247 strm.PutCString ("Started"); 248 else if (status == lldb::eReturnStatusInvalid) 249 strm.PutCString ("Invalid"); 250 else if (m_opaque_ap->Succeeded()) 251 strm.PutCString ("Success"); 252 else 253 strm.PutCString ("Fail"); 254 255 if (GetOutputSize() > 0) 256 strm.Printf ("\nOutput Message:\n%s", GetOutput()); 257 258 if (GetErrorSize() > 0) 259 strm.Printf ("\nError Message:\n%s", GetError()); 260 } 261 else 262 strm.PutCString ("No value"); 263 264 return true; 265 } 266 267 void 268 SBCommandReturnObject::SetImmediateOutputFile (FILE *fh) 269 { 270 if (m_opaque_ap.get()) 271 m_opaque_ap->SetImmediateOutputFile (fh); 272 } 273 274 void 275 SBCommandReturnObject::SetImmediateErrorFile (FILE *fh) 276 { 277 if (m_opaque_ap.get()) 278 m_opaque_ap->SetImmediateErrorFile (fh); 279 } 280 281 void 282 SBCommandReturnObject::PutCString(const char* string, int len) 283 { 284 if (m_opaque_ap.get()) 285 { 286 if (len == 0 || string == NULL || *string == 0) 287 { 288 return; 289 } 290 else if (len > 0) 291 { 292 std::string buffer(string, len); 293 m_opaque_ap->AppendMessage(buffer.c_str()); 294 } 295 else 296 m_opaque_ap->AppendMessage(string); 297 } 298 } 299 300 const char * 301 SBCommandReturnObject::GetOutput (bool only_if_no_immediate) 302 { 303 if (!m_opaque_ap.get()) 304 return NULL; 305 if (only_if_no_immediate == false || m_opaque_ap->GetImmediateOutputStream().get() == NULL) 306 return GetOutput(); 307 return NULL; 308 } 309 310 const char * 311 SBCommandReturnObject::GetError (bool only_if_no_immediate) 312 { 313 if (!m_opaque_ap.get()) 314 return NULL; 315 if (only_if_no_immediate == false || m_opaque_ap->GetImmediateErrorStream().get() == NULL) 316 return GetError(); 317 return NULL; 318 } 319 320 size_t 321 SBCommandReturnObject::Printf(const char* format, ...) 322 { 323 if (m_opaque_ap.get()) 324 { 325 va_list args; 326 va_start (args, format); 327 size_t result = m_opaque_ap->GetOutputStream().PrintfVarArg(format, args); 328 va_end (args); 329 return result; 330 } 331 return 0; 332 } 333 334 void 335 SBCommandReturnObject::SetError (lldb::SBError &error, const char *fallback_error_cstr) 336 { 337 if (m_opaque_ap.get()) 338 { 339 if (error.IsValid()) 340 m_opaque_ap->SetError(error.ref(), fallback_error_cstr); 341 else if (fallback_error_cstr) 342 m_opaque_ap->SetError(Error(), fallback_error_cstr); 343 } 344 } 345 346 void 347 SBCommandReturnObject::SetError (const char *error_cstr) 348 { 349 if (m_opaque_ap.get() && error_cstr) 350 m_opaque_ap->SetError(error_cstr); 351 } 352 353
