1 files changed, 188 insertions, 265 deletions

diff --git a/lldb/source/API/SBCommandReturnObject.cpp b/lldb/source/API/SBCommandReturnObject.cpp
index a7bc31da8a8..51e6781ffb5 100644
--- a/lldb/source/API/SBCommandReturnObject.cpp
+++ b/lldb/source/API/SBCommandReturnObject.cpp
@@ -22,333 +22,256 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBCommandReturnObject::SBCommandReturnObject () :
-    m_opaque_ap (new CommandReturnObject ())
-{
-}
+SBCommandReturnObject::SBCommandReturnObject()
+    : m_opaque_ap(new CommandReturnObject()) {}
 
-SBCommandReturnObject::SBCommandReturnObject (const SBCommandReturnObject &rhs):
-    m_opaque_ap ()
-{
-    if (rhs.m_opaque_ap)
-        m_opaque_ap.reset (new CommandReturnObject (*rhs.m_opaque_ap));
+SBCommandReturnObject::SBCommandReturnObject(const SBCommandReturnObject &rhs)
+    : m_opaque_ap() {
+  if (rhs.m_opaque_ap)
+    m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap));
 }
 
-SBCommandReturnObject::SBCommandReturnObject (CommandReturnObject *ptr) :
-    m_opaque_ap (ptr)
-{
-}
+SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject *ptr)
+    : m_opaque_ap(ptr) {}
 
 SBCommandReturnObject::~SBCommandReturnObject() = default;
 
-CommandReturnObject *
-SBCommandReturnObject::Release ()
-{
-    return m_opaque_ap.release();
+CommandReturnObject *SBCommandReturnObject::Release() {
+  return m_opaque_ap.release();
 }
 
-const SBCommandReturnObject &
-SBCommandReturnObject::operator = (const SBCommandReturnObject &rhs)
-{
-    if (this != &rhs)
-    {
-        if (rhs.m_opaque_ap)
-            m_opaque_ap.reset (new CommandReturnObject (*rhs.m_opaque_ap));
-        else
-            m_opaque_ap.reset();
-    }
-    return *this;
+const SBCommandReturnObject &SBCommandReturnObject::
+operator=(const SBCommandReturnObject &rhs) {
+  if (this != &rhs) {
+    if (rhs.m_opaque_ap)
+      m_opaque_ap.reset(new CommandReturnObject(*rhs.m_opaque_ap));
+    else
+      m_opaque_ap.reset();
+  }
+  return *this;
 }
 
-bool
-SBCommandReturnObject::IsValid() const
-{
-    return m_opaque_ap.get() != nullptr;
+bool SBCommandReturnObject::IsValid() const {
+  return m_opaque_ap.get() != nullptr;
 }
 
-const char *
-SBCommandReturnObject::GetOutput ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+const char *SBCommandReturnObject::GetOutput() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (m_opaque_ap)
-    {
-        if (log)
-            log->Printf ("SBCommandReturnObject(%p)::GetOutput () => \"%s\"",
-                         static_cast<void*>(m_opaque_ap.get()),
-                         m_opaque_ap->GetOutputData());
+  if (m_opaque_ap) {
+    if (log)
+      log->Printf("SBCommandReturnObject(%p)::GetOutput () => \"%s\"",
+                  static_cast<void *>(m_opaque_ap.get()),
+                  m_opaque_ap->GetOutputData());
 
-        return m_opaque_ap->GetOutputData();
-    }
+    return m_opaque_ap->GetOutputData();
+  }
 
-    if (log)
-        log->Printf ("SBCommandReturnObject(%p)::GetOutput () => nullptr",
-                     static_cast<void*>(m_opaque_ap.get()));
+  if (log)
+    log->Printf("SBCommandReturnObject(%p)::GetOutput () => nullptr",
+                static_cast<void *>(m_opaque_ap.get()));
 
-    return nullptr;
+  return nullptr;
 }
 
-const char *
-SBCommandReturnObject::GetError ()
-{
-    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+const char *SBCommandReturnObject::GetError() {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    if (m_opaque_ap)
-    {
-        if (log)
-            log->Printf ("SBCommandReturnObject(%p)::GetError () => \"%s\"",
-                         static_cast<void*>(m_opaque_ap.get()),
-                         m_opaque_ap->GetErrorData());
+  if (m_opaque_ap) {
+    if (log)
+      log->Printf("SBCommandReturnObject(%p)::GetError () => \"%s\"",
+                  static_cast<void *>(m_opaque_ap.get()),
+                  m_opaque_ap->GetErrorData());
 
-        return m_opaque_ap->GetErrorData();
-    }
+    return m_opaque_ap->GetErrorData();
+  }
 
-    if (log)
-        log->Printf ("SBCommandReturnObject(%p)::GetError () => nullptr",
-                     static_cast<void*>(m_opaque_ap.get()));
+  if (log)
+    log->Printf("SBCommandReturnObject(%p)::GetError () => nullptr",
+                static_cast<void *>(m_opaque_ap.get()));
 
-    return nullptr;
+  return nullptr;
 }
 
-size_t
-SBCommandReturnObject::GetOutputSize()
-{
-    return (m_opaque_ap ? strlen(m_opaque_ap->GetOutputData()) : 0);
+size_t SBCommandReturnObject::GetOutputSize() {
+  return (m_opaque_ap ? strlen(m_opaque_ap->GetOutputData()) : 0);
 }
 
-size_t
-SBCommandReturnObject::GetErrorSize()
-{
-    return (m_opaque_ap ? strlen(m_opaque_ap->GetErrorData()) : 0);
+size_t SBCommandReturnObject::GetErrorSize() {
+  return (m_opaque_ap ? strlen(m_opaque_ap->GetErrorData()) : 0);
 }
 
-size_t
-SBCommandReturnObject::PutOutput (FILE *fh)
-{
-    if (fh)
-    {
-        size_t num_bytes = GetOutputSize ();
-        if (num_bytes)
-            return ::fprintf (fh, "%s", GetOutput());
-    }
-    return 0;
+size_t SBCommandReturnObject::PutOutput(FILE *fh) {
+  if (fh) {
+    size_t num_bytes = GetOutputSize();
+    if (num_bytes)
+      return ::fprintf(fh, "%s", GetOutput());
+  }
+  return 0;
 }
 
-size_t
-SBCommandReturnObject::PutError (FILE *fh)
-{
-    if (fh)
-    {
-        size_t num_bytes = GetErrorSize ();
-        if (num_bytes)
-            return ::fprintf (fh, "%s", GetError());
-    }
-    return 0;
+size_t SBCommandReturnObject::PutError(FILE *fh) {
+  if (fh) {
+    size_t num_bytes = GetErrorSize();
+    if (num_bytes)
+      return ::fprintf(fh, "%s", GetError());
+  }
+  return 0;
 }
 
-void
-SBCommandReturnObject::Clear()
-{
-    if (m_opaque_ap)
-        m_opaque_ap->Clear();
+void SBCommandReturnObject::Clear() {
+  if (m_opaque_ap)
+    m_opaque_ap->Clear();
 }
 
-lldb::ReturnStatus
-SBCommandReturnObject::GetStatus()
-{
-    return (m_opaque_ap ? m_opaque_ap->GetStatus() : lldb::eReturnStatusInvalid);
+lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
+  return (m_opaque_ap ? m_opaque_ap->GetStatus() : lldb::eReturnStatusInvalid);
 }
 
-void
-SBCommandReturnObject::SetStatus(lldb::ReturnStatus status)
-{
-    if (m_opaque_ap)
-         m_opaque_ap->SetStatus(status);
+void SBCommandReturnObject::SetStatus(lldb::ReturnStatus status) {
+  if (m_opaque_ap)
+    m_opaque_ap->SetStatus(status);
 }
 
-bool
-SBCommandReturnObject::Succeeded()
-{
-    return (m_opaque_ap ? m_opaque_ap->Succeeded() : false);
+bool SBCommandReturnObject::Succeeded() {
+  return (m_opaque_ap ? m_opaque_ap->Succeeded() : false);
 }
 
-bool
-SBCommandReturnObject::HasResult()
-{
-    return (m_opaque_ap ? m_opaque_ap->HasResult() : false);
+bool SBCommandReturnObject::HasResult() {
+  return (m_opaque_ap ? m_opaque_ap->HasResult() : false);
 }
 
-void
-SBCommandReturnObject::AppendMessage (const char *message)
-{
-    if (m_opaque_ap)
-        m_opaque_ap->AppendMessage (message);
+void SBCommandReturnObject::AppendMessage(const char *message) {
+  if (m_opaque_ap)
+    m_opaque_ap->AppendMessage(message);
 }
 
-void
-SBCommandReturnObject::AppendWarning (const char *message)
-{
-    if (m_opaque_ap)
-        m_opaque_ap->AppendWarning (message);
+void SBCommandReturnObject::AppendWarning(const char *message) {
+  if (m_opaque_ap)
+    m_opaque_ap->AppendWarning(message);
 }
 
-CommandReturnObject *
-SBCommandReturnObject::operator ->() const
-{
-    return m_opaque_ap.get();
+CommandReturnObject *SBCommandReturnObject::operator->() const {
+  return m_opaque_ap.get();
 }
 
-CommandReturnObject *
-SBCommandReturnObject::get() const
-{
-    return m_opaque_ap.get();
+CommandReturnObject *SBCommandReturnObject::get() const {
+  return m_opaque_ap.get();
 }
 
-CommandReturnObject &
-SBCommandReturnObject::operator *() const
-{
-    assert(m_opaque_ap.get());
-    return *(m_opaque_ap.get());
+CommandReturnObject &SBCommandReturnObject::operator*() const {
+  assert(m_opaque_ap.get());
+  return *(m_opaque_ap.get());
 }
 
-CommandReturnObject &
-SBCommandReturnObject::ref() const
-{
-    assert(m_opaque_ap.get());
-    return *(m_opaque_ap.get());
+CommandReturnObject &SBCommandReturnObject::ref() const {
+  assert(m_opaque_ap.get());
+  return *(m_opaque_ap.get());
 }
 
-void
-SBCommandReturnObject::SetLLDBObjectPtr (CommandReturnObject *ptr)
-{
-    if (m_opaque_ap)
-        m_opaque_ap.reset (ptr);
+void SBCommandReturnObject::SetLLDBObjectPtr(CommandReturnObject *ptr) {
+  if (m_opaque_ap)
+    m_opaque_ap.reset(ptr);
 }
 
-bool
-SBCommandReturnObject::GetDescription (SBStream &description)
-{
-    Stream &strm = description.ref();
+bool SBCommandReturnObject::GetDescription(SBStream &description) {
+  Stream &strm = description.ref();
 
-    if (m_opaque_ap)
-    {
-        description.Printf ("Status:  ");
-        lldb::ReturnStatus status = m_opaque_ap->GetStatus();
-        if (status == lldb::eReturnStatusStarted)
-            strm.PutCString ("Started");
-        else if (status == lldb::eReturnStatusInvalid)
-            strm.PutCString ("Invalid");
-        else if (m_opaque_ap->Succeeded())
-            strm.PutCString ("Success");
-        else
-            strm.PutCString ("Fail");
+  if (m_opaque_ap) {
+    description.Printf("Status:  ");
+    lldb::ReturnStatus status = m_opaque_ap->GetStatus();
+    if (status == lldb::eReturnStatusStarted)
+      strm.PutCString("Started");
+    else if (status == lldb::eReturnStatusInvalid)
+      strm.PutCString("Invalid");
+    else if (m_opaque_ap->Succeeded())
+      strm.PutCString("Success");
+    else
+      strm.PutCString("Fail");
 
-        if (GetOutputSize() > 0)
-            strm.Printf ("\nOutput Message:\n%s", GetOutput());
+    if (GetOutputSize() > 0)
+      strm.Printf("\nOutput Message:\n%s", GetOutput());
 
-        if (GetErrorSize() > 0)
-            strm.Printf ("\nError Message:\n%s", GetError());
-    }
-    else
-        strm.PutCString ("No value");
-
-    return true;
-}
-
-void
-SBCommandReturnObject::SetImmediateOutputFile(FILE *fh)
-{
-    SetImmediateOutputFile(fh, false);
-}
-
-void
-SBCommandReturnObject::SetImmediateErrorFile(FILE *fh)
-{
-    SetImmediateErrorFile(fh, false);
-}
-
-void
-SBCommandReturnObject::SetImmediateOutputFile(FILE *fh, bool transfer_ownership)
-{
-    if (m_opaque_ap)
-        m_opaque_ap->SetImmediateOutputFile(fh, transfer_ownership);
-}
-
-void
-SBCommandReturnObject::SetImmediateErrorFile(FILE *fh, bool transfer_ownership)
-{
-    if (m_opaque_ap)
-        m_opaque_ap->SetImmediateErrorFile(fh, transfer_ownership);
-}
-
-void
-SBCommandReturnObject::PutCString(const char* string, int len)
-{
-    if (m_opaque_ap)
-    {
-        if (len == 0 || string == nullptr || *string == 0)
-        {
-            return;
-        }
-        else if (len > 0)
-        {
-            std::string buffer(string, len);
-            m_opaque_ap->AppendMessage(buffer.c_str());
-        }
-        else
-            m_opaque_ap->AppendMessage(string);
-    }
-}
-
-const char *
-SBCommandReturnObject::GetOutput (bool only_if_no_immediate)
-{
-    if (!m_opaque_ap)
-        return nullptr;
-    if (!only_if_no_immediate || m_opaque_ap->GetImmediateOutputStream().get() == nullptr)
-        return GetOutput();
-    return nullptr;
+    if (GetErrorSize() > 0)
+      strm.Printf("\nError Message:\n%s", GetError());
+  } else
+    strm.PutCString("No value");
+
+  return true;
+}
+
+void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh) {
+  SetImmediateOutputFile(fh, false);
 }
 
-const char *
-SBCommandReturnObject::GetError (bool only_if_no_immediate)
-{
-    if (!m_opaque_ap)
-        return nullptr;
-    if (!only_if_no_immediate || m_opaque_ap->GetImmediateErrorStream().get() == nullptr)
-        return GetError();
+void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh) {
+  SetImmediateErrorFile(fh, false);
+}
+
+void SBCommandReturnObject::SetImmediateOutputFile(FILE *fh,
+                                                   bool transfer_ownership) {
+  if (m_opaque_ap)
+    m_opaque_ap->SetImmediateOutputFile(fh, transfer_ownership);
+}
+
+void SBCommandReturnObject::SetImmediateErrorFile(FILE *fh,
+                                                  bool transfer_ownership) {
+  if (m_opaque_ap)
+    m_opaque_ap->SetImmediateErrorFile(fh, transfer_ownership);
+}
+
+void SBCommandReturnObject::PutCString(const char *string, int len) {
+  if (m_opaque_ap) {
+    if (len == 0 || string == nullptr || *string == 0) {
+      return;
+    } else if (len > 0) {
+      std::string buffer(string, len);
+      m_opaque_ap->AppendMessage(buffer.c_str());
+    } else
+      m_opaque_ap->AppendMessage(string);
+  }
+}
+
+const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
+  if (!m_opaque_ap)
     return nullptr;
+  if (!only_if_no_immediate ||
+      m_opaque_ap->GetImmediateOutputStream().get() == nullptr)
+    return GetOutput();
+  return nullptr;
 }
 
-size_t
-SBCommandReturnObject::Printf(const char* format, ...)
-{
-    if (m_opaque_ap)
-    {
-        va_list args;
-        va_start (args, format);
-        size_t result = m_opaque_ap->GetOutputStream().PrintfVarArg(format, args);
-        va_end (args);
-        return result;
-    }
-    return 0;
-}
-
-void
-SBCommandReturnObject::SetError (lldb::SBError &error, const char *fallback_error_cstr)
-{
-    if (m_opaque_ap)
-    {
-        if (error.IsValid())
-            m_opaque_ap->SetError(error.ref(), fallback_error_cstr);
-        else if (fallback_error_cstr)
-            m_opaque_ap->SetError(Error(), fallback_error_cstr);
-    }
-}
-
-void
-SBCommandReturnObject::SetError (const char *error_cstr)
-{
-    if (m_opaque_ap && error_cstr)
-        m_opaque_ap->SetError(error_cstr);
+const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {
+  if (!m_opaque_ap)
+    return nullptr;
+  if (!only_if_no_immediate ||
+      m_opaque_ap->GetImmediateErrorStream().get() == nullptr)
+    return GetError();
+  return nullptr;
+}
+
+size_t SBCommandReturnObject::Printf(const char *format, ...) {
+  if (m_opaque_ap) {
+    va_list args;
+    va_start(args, format);
+    size_t result = m_opaque_ap->GetOutputStream().PrintfVarArg(format, args);
+    va_end(args);
+    return result;
+  }
+  return 0;
+}
+
+void SBCommandReturnObject::SetError(lldb::SBError &error,
+                                     const char *fallback_error_cstr) {
+  if (m_opaque_ap) {
+    if (error.IsValid())
+      m_opaque_ap->SetError(error.ref(), fallback_error_cstr);
+    else if (fallback_error_cstr)
+      m_opaque_ap->SetError(Error(), fallback_error_cstr);
+  }
+}
+
+void SBCommandReturnObject::SetError(const char *error_cstr) {
+  if (m_opaque_ap && error_cstr)
+    m_opaque_ap->SetError(error_cstr);
 }