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

runtime/vm/unibrow.cc

 // Copyright (c) 2014, 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.
 //
 // This file was generated at 2014-10-08 15:25:47.940335 (in v8, copied to dart)
 
+#include "vm/unibrow.h"
 #include "vm/unibrow-inl.h"
-#include "vm/unibrow.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 namespace unibrow {
 
 static const intptr_t kStartBit = (1 << 30);
 static const intptr_t kChunkBits = (1 << 13);
 static const int32_t kSentinel = static_cast<int32_t>(-1);
 
 /**
  * \file
  * Implementations of functions for working with unicode.
  */
 
 // All access to the character table should go through this function.
 template <intptr_t D>
 static inline int32_t TableGet(const int32_t* table, intptr_t index) {
   return table[D * index];
 }
 
-
 static inline int32_t GetEntry(int32_t entry) {
   return entry & (kStartBit - 1);
 }
 
-
 static inline bool IsStart(int32_t entry) {
   return (entry & kStartBit) != 0;
 }
 
-
 /**
  * Look up a character in the unicode table using a mix of binary and
  * interpolation search.  For a uniformly distributed array
  * interpolation search beats binary search by a wide margin.  However,
  * in this case interpolation search degenerates because of some very
  * high values in the lower end of the table so this function uses a
  * combination.  The average number of steps to look up the information
  * about a character is around 10, slightly higher if there is no
  * information available about the character.
  */
@@ skipping 26 matching lines @@
   bool is_start = IsStart(field);
   return (entry == value) || (entry < value && is_start);
 }
 
 template <intptr_t kW>
 struct MultiCharacterSpecialCase {
   static const int32_t kEndOfEncoding = kSentinel;
   int32_t chars[kW];
 };
 
-
 // Look up the mapping for the given character in the specified table,
 // which is of the specified length and uses the specified special case
 // mapping for multi-char mappings.  The next parameter is the character
 // following the one to map.  The result will be written in to the result
 // buffer and the number of characters written will be returned.  Finally,
 // if the allow_caching_ptr is non-null then false will be stored in
 // it if the result contains multiple characters or depends on the
 // context.
 // If ranges are linear, a match between a start and end point is
 // offset by the distance between the match and the start. Otherwise
@@ skipping 81 matching lines @@
         default:
           return 0;
       }
       return -1;
     }
   } else {
     return 0;
   }
 }
 
-
 // Letter:               point.category in ['Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl']
 // clang-format off
 static const uint16_t kLetterTable0Size = 431;
 static const int32_t kLetterTable0[431] = {
     1073741889, 90,         1073741921, 122,
     170,        181,        186,        1073742016,  // NOLINT
     214,        1073742040, 246,        1073742072,
     705,        1073742534, 721,        1073742560,  // NOLINT
     740,        748,        750,        1073742704,
     884,        1073742710, 887,        1073742714,  // NOLINT
@@ skipping 1643 matching lines @@
     case 7:
       return LookupMapping<false>(
           kCanonicalizationRangeTable7, kCanonicalizationRangeTable7Size,
           kCanonicalizationRangeMultiStrings7, c, n, result, allow_caching_ptr);
     default:
       return 0;
   }
 }
 
 }  // namespace unibrow