Keep two empty lines between declarations for cpp files

src/unicode.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 34 matching lines @@
 typedef signed short int16_t;  // NOLINT
 typedef unsigned short uint16_t;  // NOLINT
 typedef int int32_t;  // NOLINT
 
 // All access to the character table should go through this function.
 template <int D>
 static inline uchar TableGet(const int32_t* table, int index) {
   return table[D * index];
 }
 
+
 static inline uchar 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 <int kW>
 struct MultiCharacterSpecialCase {
   static const uchar kEndOfEncoding = kSentinel;
   uchar 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 330 matching lines @@
     case 5: return LookupPredicate(kUppercaseTable5,
                                        kUppercaseTable5Size,
                                        c);
     case 7: return LookupPredicate(kUppercaseTable7,
                                        kUppercaseTable7Size,
                                        c);
     default: return false;
   }
 }
 
+
 // Lowercase:            point.category == 'Ll'
 
 static const uint16_t kLowercaseTable0Size = 463;
 static const int32_t kLowercaseTable0[463] = {
   1073741921, 122, 181, 1073742047, 246, 1073742072, 255, 257,  // NOLINT
   259, 261, 263, 265, 267, 269, 271, 273,  // NOLINT
   275, 277, 279, 281, 283, 285, 287, 289,  // NOLINT
   291, 293, 295, 297, 299, 301, 303, 305,  // NOLINT
   307, 309, 1073742135, 312, 314, 316, 318, 320,  // NOLINT
   322, 324, 326, 1073742152, 329, 331, 333, 335,  // NOLINT
@@ skipping 91 matching lines @@
     case 5: return LookupPredicate(kLowercaseTable5,
                                        kLowercaseTable5Size,
                                        c);
     case 7: return LookupPredicate(kLowercaseTable7,
                                        kLowercaseTable7Size,
                                        c);
     default: return false;
   }
 }
 
+
 // Letter:               point.category in ['Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' ]
 
 static const uint16_t kLetterTable0Size = 435;
 static const int32_t kLetterTable0[435] = {
   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
   893, 902, 1073742728, 906, 908, 1073742734, 929, 1073742755,  // NOLINT
   1013, 1073742839, 1153, 1073742986, 1319, 1073743153, 1366, 1369,  // NOLINT
   1073743201, 1415, 1073743312, 1514, 1073743344, 1522, 1073743392, 1610,  // NOLINT
@@ skipping 116 matching lines @@
     case 6: return LookupPredicate(kLetterTable6,
                                        kLetterTable6Size,
                                        c);
     case 7: return LookupPredicate(kLetterTable7,
                                        kLetterTable7Size,
                                        c);
     default: return false;
   }
 }
 
+
 // Space:                point.category == 'Zs'
 
 static const uint16_t kSpaceTable0Size = 4;
 static const int32_t kSpaceTable0[4] = {
   32, 160, 5760, 6158 };  // NOLINT
 static const uint16_t kSpaceTable1Size = 5;
 static const int32_t kSpaceTable1[5] = {
   1073741824, 10, 47, 95, 4096 };  // NOLINT
 bool Space::Is(uchar c) {
   int chunk_index = c >> 13;
   switch (chunk_index) {
     case 0: return LookupPredicate(kSpaceTable0,
                                        kSpaceTable0Size,
                                        c);
     case 1: return LookupPredicate(kSpaceTable1,
                                        kSpaceTable1Size,
                                        c);
     default: return false;
   }
 }
 
+
 // Number:               point.category == 'Nd'
 
 static const uint16_t kNumberTable0Size = 56;
 static const int32_t kNumberTable0[56] = {
   1073741872, 57, 1073743456, 1641, 1073743600, 1785, 1073743808, 1993,  // NOLINT
   1073744230, 2415, 1073744358, 2543, 1073744486, 2671, 1073744614, 2799,  // NOLINT
   1073744742, 2927, 1073744870, 3055, 1073744998, 3183, 1073745126, 3311,  // NOLINT
   1073745254, 3439, 1073745488, 3673, 1073745616, 3801, 1073745696, 3881,  // NOLINT
   1073745984, 4169, 1073746064, 4249, 1073747936, 6121, 1073747984, 6169,  // NOLINT
   1073748294, 6479, 1073748432, 6617, 1073748608, 6793, 1073748624, 6809,  // NOLINT
@@ skipping 14 matching lines @@
     case 5: return LookupPredicate(kNumberTable5,
                                        kNumberTable5Size,
                                        c);
     case 7: return LookupPredicate(kNumberTable7,
                                        kNumberTable7Size,
                                        c);
     default: return false;
   }
 }
 
+
 // WhiteSpace:           'Ws' in point.properties
 
 static const uint16_t kWhiteSpaceTable0Size = 7;
 static const int32_t kWhiteSpaceTable0[7] = {
   1073741833, 13, 32, 133, 160, 5760, 6158 };  // NOLINT
 static const uint16_t kWhiteSpaceTable1Size = 7;
 static const int32_t kWhiteSpaceTable1[7] = {
   1073741824, 10, 1073741864, 41, 47, 95, 4096 };  // NOLINT
 bool WhiteSpace::Is(uchar c) {
   int chunk_index = c >> 13;
   switch (chunk_index) {
     case 0: return LookupPredicate(kWhiteSpaceTable0,
                                        kWhiteSpaceTable0Size,
                                        c);
     case 1: return LookupPredicate(kWhiteSpaceTable1,
                                        kWhiteSpaceTable1Size,
                                        c);
     default: return false;
   }
 }
 
+
 // LineTerminator:       'Lt' in point.properties
 
 static const uint16_t kLineTerminatorTable0Size = 2;
 static const int32_t kLineTerminatorTable0[2] = {
   10, 13 };  // NOLINT
 static const uint16_t kLineTerminatorTable1Size = 2;
 static const int32_t kLineTerminatorTable1[2] = {
   1073741864, 41 };  // NOLINT
 bool LineTerminator::Is(uchar c) {
   int chunk_index = c >> 13;
   switch (chunk_index) {
     case 0: return LookupPredicate(kLineTerminatorTable0,
                                        kLineTerminatorTable0Size,
                                        c);
     case 1: return LookupPredicate(kLineTerminatorTable1,
                                        kLineTerminatorTable1Size,
                                        c);
     default: return false;
   }
 }
 
+
 // CombiningMark:        point.category in ['Mn', 'Mc']
 
 static const uint16_t kCombiningMarkTable0Size = 258;
 static const int32_t kCombiningMarkTable0[258] = {
   1073742592, 879, 1073742979, 1159, 1073743249, 1469, 1471, 1073743297,  // NOLINT
   1474, 1073743300, 1477, 1479, 1073743376, 1562, 1073743435, 1631,  // NOLINT
   1648, 1073743574, 1756, 1073743583, 1764, 1073743591, 1768, 1073743594,  // NOLINT
   1773, 1809, 1073743664, 1866, 1073743782, 1968, 1073743851, 2035,  // NOLINT
   1073743894, 2073, 1073743899, 2083, 1073743909, 2087, 1073743913, 2093,  // NOLINT
   1073743961, 2139, 1073744100, 2302, 1073744128, 2307, 1073744186, 2364,  // NOLINT
@@ skipping 51 matching lines @@
     case 5: return LookupPredicate(kCombiningMarkTable5,
                                        kCombiningMarkTable5Size,
                                        c);
     case 7: return LookupPredicate(kCombiningMarkTable7,
                                        kCombiningMarkTable7Size,
                                        c);
     default: return false;
   }
 }
 
+
 // ConnectorPunctuation: point.category == 'Pc'
 
 static const uint16_t kConnectorPunctuationTable0Size = 1;
 static const int32_t kConnectorPunctuationTable0[1] = {
   95 };  // NOLINT
 static const uint16_t kConnectorPunctuationTable1Size = 3;
 static const int32_t kConnectorPunctuationTable1[3] = {
   1073741887, 64, 84 };  // NOLINT
 static const uint16_t kConnectorPunctuationTable7Size = 5;
 static const int32_t kConnectorPunctuationTable7[5] = {
@@ skipping 968 matching lines @@
       + kEcma262UnCanonicalizeMultiStrings0Size * sizeof(MultiCharacterSpecialCase<4>)  // NOLINT
       + kEcma262UnCanonicalizeMultiStrings1Size * sizeof(MultiCharacterSpecialCase<2>)  // NOLINT
       + kEcma262UnCanonicalizeMultiStrings5Size * sizeof(MultiCharacterSpecialCase<2>)  // NOLINT
       + kEcma262UnCanonicalizeMultiStrings7Size * sizeof(MultiCharacterSpecialCase<2>)  // NOLINT
       + kCanonicalizationRangeMultiStrings0Size * sizeof(MultiCharacterSpecialCase<1>)  // NOLINT
       + kCanonicalizationRangeMultiStrings1Size * sizeof(MultiCharacterSpecialCase<1>)  // NOLINT
       + kCanonicalizationRangeMultiStrings7Size * sizeof(MultiCharacterSpecialCase<1>); // NOLINT
 }
 
 }  // namespace unicode