*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 234 insertions, 287 deletions

diff --git a/lldb/source/API/SBBreakpointLocation.cpp b/lldb/source/API/SBBreakpointLocation.cpp
index 631a32bc9dd..c7fac7688f8 100644
--- a/lldb/source/API/SBBreakpointLocation.cpp
+++ b/lldb/source/API/SBBreakpointLocation.cpp
@@ -8,13 +8,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBBreakpointLocation.h"
-#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 
-#include "lldb/lldb-types.h"
-#include "lldb/lldb-defines.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
@@ -23,347 +21,296 @@
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
-#include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Target/ThreadSpec.h"
+#include "lldb/lldb-defines.h"
+#include "lldb/lldb-types.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-
-SBBreakpointLocation::SBBreakpointLocation () :
-    m_opaque_sp ()
-{
+SBBreakpointLocation::SBBreakpointLocation() : m_opaque_sp() {}
+
+SBBreakpointLocation::SBBreakpointLocation(
+    const lldb::BreakpointLocationSP &break_loc_sp)
+    : m_opaque_sp(break_loc_sp) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  if (log) {
+    SBStream sstr;
+    GetDescription(sstr, lldb::eDescriptionLevelBrief);
+    log->Printf("SBBreakpointLocation::SBBreakpointLocaiton (const "
+                "lldb::BreakpointLocationsSP &break_loc_sp"
+                "=%p)  => this.sp = %p (%s)",
+                static_cast<void *>(break_loc_sp.get()),
+                static_cast<void *>(m_opaque_sp.get()), sstr.GetData());
+  }
 }
 
-SBBreakpointLocation::SBBreakpointLocation (const lldb::BreakpointLocationSP &break_loc_sp) :
-    m_opaque_sp (break_loc_sp)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    if (log)
-    {
-        SBStream sstr;
-        GetDescription (sstr, lldb::eDescriptionLevelBrief);
-        log->Printf ("SBBreakpointLocation::SBBreakpointLocaiton (const lldb::BreakpointLocationsSP &break_loc_sp"
-                     "=%p)  => this.sp = %p (%s)",
-                     static_cast<void*>(break_loc_sp.get()),
-                     static_cast<void*>(m_opaque_sp.get()), sstr.GetData());
-    }
-}
+SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
+    : m_opaque_sp(rhs.m_opaque_sp) {}
 
-SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs) :
-    m_opaque_sp (rhs.m_opaque_sp)
-{
+const SBBreakpointLocation &SBBreakpointLocation::
+operator=(const SBBreakpointLocation &rhs) {
+  if (this != &rhs)
+    m_opaque_sp = rhs.m_opaque_sp;
+  return *this;
 }
 
-const SBBreakpointLocation &
-SBBreakpointLocation::operator = (const SBBreakpointLocation &rhs)
-{
-    if (this != &rhs)
-        m_opaque_sp = rhs.m_opaque_sp;
-    return *this;
-}
+SBBreakpointLocation::~SBBreakpointLocation() {}
 
+bool SBBreakpointLocation::IsValid() const { return m_opaque_sp.get() != NULL; }
 
-SBBreakpointLocation::~SBBreakpointLocation ()
-{
+SBAddress SBBreakpointLocation::GetAddress() {
+  if (m_opaque_sp)
+    return SBAddress(&m_opaque_sp->GetAddress());
+  else
+    return SBAddress();
 }
 
-bool
-SBBreakpointLocation::IsValid() const
-{
-    return m_opaque_sp.get() != NULL;
-}
-
-SBAddress
-SBBreakpointLocation::GetAddress ()
-{
-    if (m_opaque_sp)
-        return SBAddress(&m_opaque_sp->GetAddress());
-    else
-        return SBAddress();
-}
+addr_t SBBreakpointLocation::GetLoadAddress() {
+  addr_t ret_addr = LLDB_INVALID_ADDRESS;
 
-addr_t
-SBBreakpointLocation::GetLoadAddress ()
-{
-    addr_t ret_addr = LLDB_INVALID_ADDRESS;
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    ret_addr = m_opaque_sp->GetLoadAddress();
+  }
 
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        ret_addr = m_opaque_sp->GetLoadAddress();
-    }
-
-    return ret_addr;
+  return ret_addr;
 }
 
-void
-SBBreakpointLocation::SetEnabled (bool enabled)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetEnabled (enabled);
-    }
+void SBBreakpointLocation::SetEnabled(bool enabled) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetEnabled(enabled);
+  }
 }
 
-bool
-SBBreakpointLocation::IsEnabled ()
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->IsEnabled();
-    }
-    else
-        return false;
+bool SBBreakpointLocation::IsEnabled() {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->IsEnabled();
+  } else
+    return false;
 }
 
-uint32_t
-SBBreakpointLocation::GetIgnoreCount ()
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->GetIgnoreCount();
-    }
-    else
-        return 0;
+uint32_t SBBreakpointLocation::GetIgnoreCount() {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->GetIgnoreCount();
+  } else
+    return 0;
 }
 
-void
-SBBreakpointLocation::SetIgnoreCount (uint32_t n)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetIgnoreCount (n);
-    }
+void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetIgnoreCount(n);
+  }
 }
 
-void
-SBBreakpointLocation::SetCondition (const char *condition)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetCondition (condition);
-    }
+void SBBreakpointLocation::SetCondition(const char *condition) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetCondition(condition);
+  }
 }
 
-const char *
-SBBreakpointLocation::GetCondition ()
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->GetConditionText ();
-    }
-    return NULL;
+const char *SBBreakpointLocation::GetCondition() {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->GetConditionText();
+  }
+  return NULL;
 }
 
-void
-SBBreakpointLocation::SetScriptCallbackFunction (const char *callback_function_name)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    if (log)
-        log->Printf ("SBBreakpointLocation(%p)::SetScriptCallbackFunction (callback=%s)",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     callback_function_name);
-
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
-        m_opaque_sp->GetBreakpoint().GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallbackFunction (bp_options,
-                                                                                                                                     callback_function_name);
-    }
+void SBBreakpointLocation::SetScriptCallbackFunction(
+    const char *callback_function_name) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  if (log)
+    log->Printf(
+        "SBBreakpointLocation(%p)::SetScriptCallbackFunction (callback=%s)",
+        static_cast<void *>(m_opaque_sp.get()), callback_function_name);
+
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
+    m_opaque_sp->GetBreakpoint()
+        .GetTarget()
+        .GetDebugger()
+        .GetCommandInterpreter()
+        .GetScriptInterpreter()
+        ->SetBreakpointCommandCallbackFunction(bp_options,
+                                               callback_function_name);
+  }
 }
 
 SBError
-SBBreakpointLocation::SetScriptCallbackBody (const char *callback_body_text)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    if (log)
-        log->Printf ("SBBreakpoint(%p)::SetScriptCallbackBody: callback body:\n%s)",
-                     static_cast<void*>(m_opaque_sp.get()), callback_body_text);
-
-    SBError sb_error;
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
-        Error error = m_opaque_sp->GetBreakpoint().GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
-                                                                                                                                                           callback_body_text);
-        sb_error.SetError(error);
-    }
-    else
-        sb_error.SetErrorString("invalid breakpoint");
-
-    return sb_error;
+SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  if (log)
+    log->Printf("SBBreakpoint(%p)::SetScriptCallbackBody: callback body:\n%s)",
+                static_cast<void *>(m_opaque_sp.get()), callback_body_text);
+
+  SBError sb_error;
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
+    Error error =
+        m_opaque_sp->GetBreakpoint()
+            .GetTarget()
+            .GetDebugger()
+            .GetCommandInterpreter()
+            .GetScriptInterpreter()
+            ->SetBreakpointCommandCallback(bp_options, callback_body_text);
+    sb_error.SetError(error);
+  } else
+    sb_error.SetErrorString("invalid breakpoint");
+
+  return sb_error;
 }
 
-void
-SBBreakpointLocation::SetThreadID (tid_t thread_id)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetThreadID (thread_id);
-    }
+void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetThreadID(thread_id);
+  }
 }
 
-tid_t
-SBBreakpointLocation::GetThreadID ()
-{
-    tid_t tid = LLDB_INVALID_THREAD_ID;
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->GetThreadID();
-    }
-    return tid;
+tid_t SBBreakpointLocation::GetThreadID() {
+  tid_t tid = LLDB_INVALID_THREAD_ID;
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->GetThreadID();
+  }
+  return tid;
 }
 
-void
-SBBreakpointLocation::SetThreadIndex (uint32_t index)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetThreadIndex (index);
-    }
+void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetThreadIndex(index);
+  }
 }
 
-uint32_t
-SBBreakpointLocation::GetThreadIndex() const
-{
-    uint32_t thread_idx = UINT32_MAX;
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->GetThreadIndex();
-    }
-    return thread_idx;
-}
-    
-
-void
-SBBreakpointLocation::SetThreadName (const char *thread_name)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetThreadName (thread_name);
-    }
+uint32_t SBBreakpointLocation::GetThreadIndex() const {
+  uint32_t thread_idx = UINT32_MAX;
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->GetThreadIndex();
+  }
+  return thread_idx;
 }
 
-const char *
-SBBreakpointLocation::GetThreadName () const
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->GetThreadName();
-    }
-    return NULL;
+void SBBreakpointLocation::SetThreadName(const char *thread_name) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetThreadName(thread_name);
+  }
 }
 
-void
-SBBreakpointLocation::SetQueueName (const char *queue_name)
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->SetQueueName (queue_name);
-    }
+const char *SBBreakpointLocation::GetThreadName() const {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->GetThreadName();
+  }
+  return NULL;
 }
 
-const char *
-SBBreakpointLocation::GetQueueName () const
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->GetQueueName ();
-    }
-    return NULL;
+void SBBreakpointLocation::SetQueueName(const char *queue_name) {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->SetQueueName(queue_name);
+  }
 }
 
-bool
-SBBreakpointLocation::IsResolved ()
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->IsResolved();
-    }
-    return false;
+const char *SBBreakpointLocation::GetQueueName() const {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->GetQueueName();
+  }
+  return NULL;
 }
 
-void
-SBBreakpointLocation::SetLocation (const lldb::BreakpointLocationSP &break_loc_sp)
-{
-    // Uninstall the callbacks?
-    m_opaque_sp = break_loc_sp;
+bool SBBreakpointLocation::IsResolved() {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->IsResolved();
+  }
+  return false;
 }
 
-bool
-SBBreakpointLocation::GetDescription (SBStream &description, DescriptionLevel level)
-{
-    Stream &strm = description.ref();
-
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        m_opaque_sp->GetDescription (&strm, level);
-        strm.EOL();
-    }
-    else
-        strm.PutCString ("No value");
-
-    return true;
+void SBBreakpointLocation::SetLocation(
+    const lldb::BreakpointLocationSP &break_loc_sp) {
+  // Uninstall the callbacks?
+  m_opaque_sp = break_loc_sp;
 }
 
-break_id_t
-SBBreakpointLocation::GetID ()
-{
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        return m_opaque_sp->GetID ();
-    }
-    else
-        return LLDB_INVALID_BREAK_ID;
+bool SBBreakpointLocation::GetDescription(SBStream &description,
+                                          DescriptionLevel level) {
+  Stream &strm = description.ref();
+
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    m_opaque_sp->GetDescription(&strm, level);
+    strm.EOL();
+  } else
+    strm.PutCString("No value");
+
+  return true;
 }
 
-SBBreakpoint
-SBBreakpointLocation::GetBreakpoint ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    //if (log)
-    //    log->Printf ("SBBreakpointLocation::GetBreakpoint ()");
-
-    SBBreakpoint sb_bp;
-    if (m_opaque_sp)
-    {
-        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
-        *sb_bp = m_opaque_sp->GetBreakpoint ().shared_from_this();
-    }
-
-    if (log)
-    {
-        SBStream sstr;
-        sb_bp.GetDescription (sstr);
-        log->Printf ("SBBreakpointLocation(%p)::GetBreakpoint () => SBBreakpoint(%p) %s",
-                     static_cast<void*>(m_opaque_sp.get()),
-                     static_cast<void*>(sb_bp.get()), sstr.GetData());
-    }
-    return sb_bp;
+break_id_t SBBreakpointLocation::GetID() {
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    return m_opaque_sp->GetID();
+  } else
+    return LLDB_INVALID_BREAK_ID;
 }
 
+SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  // if (log)
+  //    log->Printf ("SBBreakpointLocation::GetBreakpoint ()");
+
+  SBBreakpoint sb_bp;
+  if (m_opaque_sp) {
+    std::lock_guard<std::recursive_mutex> guard(
+        m_opaque_sp->GetTarget().GetAPIMutex());
+    *sb_bp = m_opaque_sp->GetBreakpoint().shared_from_this();
+  }
+
+  if (log) {
+    SBStream sstr;
+    sb_bp.GetDescription(sstr);
+    log->Printf(
+        "SBBreakpointLocation(%p)::GetBreakpoint () => SBBreakpoint(%p) %s",
+        static_cast<void *>(m_opaque_sp.get()),
+        static_cast<void *>(sb_bp.get()), sstr.GetData());
+  }
+  return sb_bp;
+}