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

runtime/vm/regexp_interpreter.cc

 // Copyright (c) 2015, 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.
 
 // A simple interpreter for the Irregexp byte code.
 
 #include "vm/regexp_interpreter.h"
 
+#include "vm/object.h"
+#include "vm/regexp_assembler.h"
 #include "vm/regexp_bytecodes.h"
-#include "vm/regexp_assembler.h"
-#include "vm/object.h"
+#include "vm/unibrow-inl.h"
+#include "vm/unibrow.h"
 #include "vm/unicode.h"
-#include "vm/unibrow.h"
-#include "vm/unibrow-inl.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_regexp_bytecodes, false, "trace_regexp_bytecodes");
 
 typedef unibrow::Mapping<unibrow::Ecma262Canonicalize> Canonicalize;
 
 template <typename Char>
 static bool BackRefMatchesNoCase(Canonicalize* interp_canonicalize,
                                  intptr_t from,
@@ skipping 38 matching lines @@
     if (old_char != new_char) return false;
     // Not letters in the ASCII range and Latin-1 range.
     if (!(old_char - 'a' <= 'z' - 'a') &&
         !(old_char - 224 <= 254 - 224 && old_char != 247)) {
       return false;
     }
   }
   return true;
 }
 
-
 #ifdef DEBUG
 static void TraceInterpreter(const uint8_t* code_base,
                              const uint8_t* pc,
                              int stack_depth,
                              int current_position,
                              uint32_t current_char,
                              int bytecode_length,
                              const char* bytecode_name) {
   if (FLAG_trace_regexp_bytecodes) {
     bool printable = (current_char < 127 && current_char >= 32);
@@ skipping 12 matching lines @@
       if (b < 127 && b >= 32) {
         OS::Print("%c", b);
       } else {
         OS::Print(".");
       }
     }
     OS::Print("\n");
   }
 }
 
-
 #define BYTECODE(name)                                                         \
   case BC_##name:                                                              \
     TraceInterpreter(code_base, pc,                                            \
                      static_cast<int>(backtrack_sp - backtrack_stack_base),    \
                      current, current_char, BC_##name##_LENGTH, #name);
 #else
 #define BYTECODE(name) case BC_##name:
 #endif
 
-
 static int32_t Load32Aligned(const uint8_t* pc) {
   ASSERT((reinterpret_cast<intptr_t>(pc) & 3) == 0);
   return *reinterpret_cast<const int32_t*>(pc);
 }
 
-
 static int32_t Load16Aligned(const uint8_t* pc) {
   ASSERT((reinterpret_cast<intptr_t>(pc) & 1) == 0);
   return *reinterpret_cast<const uint16_t*>(pc);
 }
 
-
 // A simple abstraction over the backtracking stack used by the interpreter.
 // This backtracking stack does not grow automatically, but it ensures that the
 // the memory held by the stack is released or remembered in a cache if the
 // matching terminates.
 class BacktrackStack {
  public:
   explicit BacktrackStack(Zone* zone) {
     data_ = zone->Alloc<intptr_t>(kBacktrackStackSize);
   }
 
   intptr_t* data() const { return data_; }
 
   intptr_t max_size() const { return kBacktrackStackSize; }
 
  private:
   static const intptr_t kBacktrackStackSize = 10000;
 
   intptr_t* data_;
 
   DISALLOW_COPY_AND_ASSIGN(BacktrackStack);
 };
 
-
 template <typename Char>
 static IrregexpInterpreter::IrregexpResult RawMatch(const uint8_t* code_base,
                                                     const String& subject,
                                                     int32_t* registers,
                                                     intptr_t current,
                                                     uint32_t current_char,
                                                     Zone* zone) {
   const uint8_t* pc = code_base;
   // BacktrackStack ensures that the memory allocated for the backtracking stack
   // is returned to the system or cached if there is no stack being cached at
@@ skipping 401 matching lines @@
         pc += BC_SET_CURRENT_POSITION_FROM_END_LENGTH;
         break;
       }
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
-
 IrregexpInterpreter::IrregexpResult IrregexpInterpreter::Match(
     const TypedData& bytecode,
     const String& subject,
     int32_t* registers,
     intptr_t start_position,
     Zone* zone) {
   NoSafepointScope no_safepoint;
   const uint8_t* code_base = reinterpret_cast<uint8_t*>(bytecode.DataAddr(0));
 
   uint16_t previous_char = '\n';
   if (start_position != 0) {
     previous_char = subject.CharAt(start_position - 1);
   }
 
   if (subject.IsOneByteString() || subject.IsExternalOneByteString()) {
     return RawMatch<uint8_t>(code_base, subject, registers, start_position,
                              previous_char, zone);
   } else if (subject.IsTwoByteString() || subject.IsExternalTwoByteString()) {
     return RawMatch<uint16_t>(code_base, subject, registers, start_position,
                               previous_char, zone);
   } else {
     UNREACHABLE();
     return IrregexpInterpreter::RE_FAILURE;
   }
 }
 
 }  // namespace dart