VM: Re-format to use at most one newline between functions

runtime/vm/stack_frame.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_STACK_FRAME_H_
 #define RUNTIME_VM_STACK_FRAME_H_
 
 #include "vm/allocation.h"
 #include "vm/object.h"
 #include "vm/stub_code.h"
@@ skipping 11 matching lines @@
 #else
 #error Unknown architecture.
 #endif
 
 namespace dart {
 
 // Forward declarations.
 class ObjectPointerVisitor;
 class RawContext;
 
-
 // Generic stack frame.
 class StackFrame : public ValueObject {
  public:
   virtual ~StackFrame() {}
 
   // Accessors to get the pc, sp and fp of a frame.
   uword sp() const { return sp_; }
   uword fp() const { return fp_; }
   uword pc() const { return pc_; }
 
@@ skipping 100 matching lines @@
   Thread* thread_;
 
   // The iterators FrameSetIterator and StackFrameIterator set the private
   // fields fp_ and sp_ when they return the respective frame objects.
   friend class FrameSetIterator;
   friend class StackFrameIterator;
   friend class ProfilerDartStackWalker;
   DISALLOW_COPY_AND_ASSIGN(StackFrame);
 };
 
-
 // Exit frame is used to mark the transition from dart code into dart VM
 // runtime code.
 class ExitFrame : public StackFrame {
  public:
   bool IsValid() const { return sp() == 0; }
   bool IsDartFrame(bool validate = true) const { return false; }
   bool IsStubFrame() const { return false; }
   bool IsExitFrame() const { return true; }
 
   // Visit objects in the frame.
   virtual void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  protected:
   virtual const char* GetName() const { return "exit"; }
 
  private:
   explicit ExitFrame(Thread* thread) : StackFrame(thread) {}
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(ExitFrame);
 };
 
-
 // Entry Frame is used to mark the transition from dart VM runtime code into
 // dart code.
 class EntryFrame : public StackFrame {
  public:
   bool IsValid() const { return StubCode::InInvocationStub(pc()); }
   bool IsDartFrame(bool validate = true) const { return false; }
   bool IsStubFrame() const { return false; }
   bool IsEntryFrame() const { return true; }
 
   // Visit objects in the frame.
   virtual void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
  protected:
   virtual const char* GetName() const { return "entry"; }
 
  private:
   explicit EntryFrame(Thread* thread) : StackFrame(thread) {}
 
   friend class StackFrameIterator;
   DISALLOW_COPY_AND_ASSIGN(EntryFrame);
 };
 
-
 // A StackFrameIterator can be initialized with a thread other than the
 // current thread. Because this is generally a bad idea, it is only allowed on
 // Windows- where it is needed for the profiler. It is the responsibility of
 // users of StackFrameIterator to ensure that the thread given is not running
 // concurrently.
 class StackFrameIterator : public ValueObject {
  public:
   enum ValidationPolicy {
     kValidateFrames = 0,
     kDontValidateFrames = 1,
@@ skipping 82 matching lines @@
   EntryFrame entry_;  // Singleton entry frame returned by NextEntryFrame().
   ExitFrame exit_;    // Singleton exit frame returned by NextExitFrame().
   FrameSetIterator frames_;
   StackFrame* current_frame_;  // Points to the current frame in the iterator.
   Thread* thread_;
 
   friend class ProfilerDartStackWalker;
   DISALLOW_COPY_AND_ASSIGN(StackFrameIterator);
 };
 
-
 // Iterator for iterating over all dart frames (skips over exit frames,
 // entry frames and stub frames).
 // A DartFrameIterator can be initialized with an isolate other than the
 // current thread's isolate. Because this is generally a bad idea,
 // it is only allowed on Windows- where it is needed for the profiler.
 // It is the responsibility of users of DartFrameIterator to ensure that the
 // isolate given is not running concurrently on another thread.
 class DartFrameIterator : public ValueObject {
  public:
   explicit DartFrameIterator(
@@ skipping 33 matching lines @@
     }
     return frame;
   }
 
  private:
   StackFrameIterator frames_;
 
   DISALLOW_COPY_AND_ASSIGN(DartFrameIterator);
 };
 
-
 // Iterator for iterating over all inlined dart functions in an optimized
 // dart frame (the iteration includes the function that is inlining the
 // other functions).
 class InlinedFunctionsIterator : public ValueObject {
  public:
   InlinedFunctionsIterator(const Code& code, uword pc);
   bool Done() const { return index_ == -1; }
   void Advance();
 
   RawFunction* function() const {
@@ skipping 22 matching lines @@
   Code& code_;
   TypedData& deopt_info_;
   Function& function_;
   uword pc_;
   GrowableArray<DeoptInstr*> deopt_instructions_;
   ObjectPool& object_table_;
 
   DISALLOW_COPY_AND_ASSIGN(InlinedFunctionsIterator);
 };
 
-
 #if defined(DEBUG)
 void ValidateFrames();
 #endif
 
-
 #if !defined(TARGET_ARCH_DBC)
 DART_FORCE_INLINE static intptr_t LocalVarIndex(intptr_t fp_offset,
                                                 intptr_t var_index) {
   return fp_offset + var_index;
 }
 
-
 DART_FORCE_INLINE static uword ParamAddress(uword fp, intptr_t reverse_index) {
   return fp + (kParamEndSlotFromFp * kWordSize) + (reverse_index * kWordSize);
 }
 
-
 DART_FORCE_INLINE static bool IsCalleeFrameOf(uword fp, uword other_fp) {
   return other_fp < fp;
 }
 
 // Value for stack limit that is used to cause an interrupt.
 // Note that on DBC stack is growing upwards so interrupt limit is 0 unlike
 // on all other architectures.
 static const uword kInterruptStackLimit = ~static_cast<uword>(0);
 #endif
 
-
 DART_FORCE_INLINE static uword LocalVarAddress(uword fp, intptr_t index) {
   return fp + LocalVarIndex(0, index) * kWordSize;
 }
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_STACK_FRAME_H_