*** 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, 79 insertions, 92 deletions

diff --git a/lldb/include/lldb/Target/ThreadPlanStepInRange.h b/lldb/include/lldb/Target/ThreadPlanStepInRange.h
index b31d3550827..c3116eac81b 100644
--- a/lldb/include/lldb/Target/ThreadPlanStepInRange.h
+++ b/lldb/include/lldb/Target/ThreadPlanStepInRange.h
@@ -17,107 +17,94 @@
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Target/StackID.h"
 #include "lldb/Target/Thread.h"
-#include "lldb/Target/ThreadPlanStepRange.h"
 #include "lldb/Target/ThreadPlanShouldStopHere.h"
+#include "lldb/Target/ThreadPlanStepRange.h"
 
 namespace lldb_private {
 
-class ThreadPlanStepInRange :
-    public ThreadPlanStepRange,
-    public ThreadPlanShouldStopHere
-{
+class ThreadPlanStepInRange : public ThreadPlanStepRange,
+                              public ThreadPlanShouldStopHere {
 public:
-    ThreadPlanStepInRange (Thread &thread,
-                           const AddressRange &range,
-                           const SymbolContext &addr_context,
-                           lldb::RunMode stop_others,
-                            LazyBool step_in_avoids_code_without_debug_info,
-                            LazyBool step_out_avoids_code_without_debug_info);
-    
-    ThreadPlanStepInRange (Thread &thread,
-                           const AddressRange &range,
-                           const SymbolContext &addr_context,
-                           const char *step_into_function_name,
-                           lldb::RunMode stop_others,
-                            LazyBool step_in_avoids_code_without_debug_info,
-                            LazyBool step_out_avoids_code_without_debug_info);
-
-    ~ThreadPlanStepInRange() override;
-
-    void
-    GetDescription(Stream *s, lldb::DescriptionLevel level) override;
-
-    bool
-    ShouldStop(Event *event_ptr) override;
-
-    void SetAvoidRegexp(const char *name);
-    
-    void SetStepInTarget (const char *target)
-    {
-        m_step_into_target.SetCString(target);
-    }
-    
-    static void
-    SetDefaultFlagValue (uint32_t new_value);
-    
-    bool
-    IsVirtualStep() override;
+  ThreadPlanStepInRange(Thread &thread, const AddressRange &range,
+                        const SymbolContext &addr_context,
+                        lldb::RunMode stop_others,
+                        LazyBool step_in_avoids_code_without_debug_info,
+                        LazyBool step_out_avoids_code_without_debug_info);
+
+  ThreadPlanStepInRange(Thread &thread, const AddressRange &range,
+                        const SymbolContext &addr_context,
+                        const char *step_into_function_name,
+                        lldb::RunMode stop_others,
+                        LazyBool step_in_avoids_code_without_debug_info,
+                        LazyBool step_out_avoids_code_without_debug_info);
+
+  ~ThreadPlanStepInRange() override;
+
+  void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
+
+  bool ShouldStop(Event *event_ptr) override;
+
+  void SetAvoidRegexp(const char *name);
+
+  void SetStepInTarget(const char *target) {
+    m_step_into_target.SetCString(target);
+  }
+
+  static void SetDefaultFlagValue(uint32_t new_value);
+
+  bool IsVirtualStep() override;
 
 protected:
-    static bool
-    DefaultShouldStopHereCallback (ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation, void *baton);
-
-    bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
-
-    bool
-    DoPlanExplainsStop(Event *event_ptr) override;
-
-    void
-    SetFlagsToDefault() override
-    {
-        GetFlags().Set(ThreadPlanStepInRange::s_default_flag_values);
-    }
-    
-    void
-    SetCallbacks()
-    {
-        ThreadPlanShouldStopHere::ThreadPlanShouldStopHereCallbacks callbacks(ThreadPlanStepInRange::DefaultShouldStopHereCallback, nullptr);
-        SetShouldStopHereCallbacks (&callbacks, nullptr);
-    }
-    
-    bool
-    FrameMatchesAvoidCriteria ();
+  static bool DefaultShouldStopHereCallback(ThreadPlan *current_plan,
+                                            Flags &flags,
+                                            lldb::FrameComparison operation,
+                                            void *baton);
 
-private:
+  bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
+
+  bool DoPlanExplainsStop(Event *event_ptr) override;
 
-    friend lldb::ThreadPlanSP
-    Thread::QueueThreadPlanForStepOverRange (bool abort_other_plans,
-                                         const AddressRange &range,
-                                         const SymbolContext &addr_context,
-                                         lldb::RunMode stop_others,
-                                         LazyBool avoid_code_without_debug_info);
-    friend lldb::ThreadPlanSP
-    Thread::QueueThreadPlanForStepInRange (bool abort_other_plans,
-                                         const AddressRange &range,
-                                         const SymbolContext &addr_context,
-                                         const char *step_in_target,
-                                         lldb::RunMode stop_others,
-                                         LazyBool step_in_avoids_code_without_debug_info,
-                                         LazyBool step_out_avoids_code_without_debug_info);
-
-    void SetupAvoidNoDebug(LazyBool step_in_avoids_code_without_debug_info,
-                           LazyBool step_out_avoids_code_without_debug_info);
-    // Need an appropriate marker for the current stack so we can tell step out
-    // from step in.
-
-    static uint32_t s_default_flag_values;  // These are the default flag values for the ThreadPlanStepThrough.
-    lldb::ThreadPlanSP m_sub_plan_sp;  // Keep track of the last plan we were running.  If it fails, we should stop.
-    std::unique_ptr<RegularExpression> m_avoid_regexp_ap;
-    bool m_step_past_prologue;  // FIXME: For now hard-coded to true, we could put a switch in for this if there's
-                                // demand for that.
-    bool m_virtual_step;        // true if we've just done a "virtual step", i.e. just moved the inline stack depth.
-    ConstString m_step_into_target;
-    DISALLOW_COPY_AND_ASSIGN (ThreadPlanStepInRange);
+  void SetFlagsToDefault() override {
+    GetFlags().Set(ThreadPlanStepInRange::s_default_flag_values);
+  }
+
+  void SetCallbacks() {
+    ThreadPlanShouldStopHere::ThreadPlanShouldStopHereCallbacks callbacks(
+        ThreadPlanStepInRange::DefaultShouldStopHereCallback, nullptr);
+    SetShouldStopHereCallbacks(&callbacks, nullptr);
+  }
+
+  bool FrameMatchesAvoidCriteria();
+
+private:
+  friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
+      bool abort_other_plans, const AddressRange &range,
+      const SymbolContext &addr_context, lldb::RunMode stop_others,
+      LazyBool avoid_code_without_debug_info);
+  friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
+      bool abort_other_plans, const AddressRange &range,
+      const SymbolContext &addr_context, const char *step_in_target,
+      lldb::RunMode stop_others,
+      LazyBool step_in_avoids_code_without_debug_info,
+      LazyBool step_out_avoids_code_without_debug_info);
+
+  void SetupAvoidNoDebug(LazyBool step_in_avoids_code_without_debug_info,
+                         LazyBool step_out_avoids_code_without_debug_info);
+  // Need an appropriate marker for the current stack so we can tell step out
+  // from step in.
+
+  static uint32_t s_default_flag_values; // These are the default flag values
+                                         // for the ThreadPlanStepThrough.
+  lldb::ThreadPlanSP m_sub_plan_sp;      // Keep track of the last plan we were
+                                    // running.  If it fails, we should stop.
+  std::unique_ptr<RegularExpression> m_avoid_regexp_ap;
+  bool m_step_past_prologue; // FIXME: For now hard-coded to true, we could put
+                             // a switch in for this if there's
+                             // demand for that.
+  bool m_virtual_step; // true if we've just done a "virtual step", i.e. just
+                       // moved the inline stack depth.
+  ConstString m_step_into_target;
+  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepInRange);
 };
 
 } // namespace lldb_private