Format all dart: library files

sdk/lib/convert/base64.dart

 // 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.
 
 part of dart.convert;
 
 /**
  * A [base64](https://tools.ietf.org/html/rfc4648) encoder and decoder.
  *
  * It encodes using the default base64 alphabet,
@@ skipping 17 matching lines @@
  *
  * Examples:
  *
  *     var encoded = BASE64URL.encode([0x62, 0x6c, 0xc3, 0xa5, 0x62, 0xc3, 0xa6,
  *                                     0x72, 0x67, 0x72, 0xc3, 0xb8, 0x64]);
  *     var decoded = BASE64URL.decode("YmzDpWLDpnJncsO4ZAo=");
  */
 const Base64Codec BASE64URL = const Base64Codec.urlSafe();
 
 // Constants used in more than one class.
-const int _paddingChar = 0x3d;  // '='.
+const int _paddingChar = 0x3d; // '='.
 
 /**
  * A [base64](https://tools.ietf.org/html/rfc4648) encoder and decoder.
  *
  * A [Base64Codec] allows base64 encoding bytes into ASCII strings and
  * decoding valid encodings back to bytes.
  *
  * This implementation only handles the simplest RFC 4648 base64 and base64url
  * encodings.
  * It does not allow invalid characters when decoding and it requires,
@@ skipping 34 matching lines @@
     int firstPadding = -1;
     int firstPaddingSourceIndex = -1;
     int paddingCount = 0;
     for (int i = start; i < end;) {
       int sliceEnd = i;
       int char = source.codeUnitAt(i++);
       int originalChar = char;
       // Normalize char, keep originalChar to see if it matches the source.
       if (char == percent) {
         if (i + 2 <= end) {
-          char = parseHexByte(source, i);  // May be negative.
+          char = parseHexByte(source, i); // May be negative.
           i += 2;
           // We know that %25 isn't valid, but our table considers it
           // a potential padding start, so skip the checks.
           if (char == percent) char = -1;
         } else {
           // An invalid HEX escape (too short).
           // Just skip past the handling and reach the throw below.
           char = -1;
         }
       }
@@ skipping 23 matching lines @@
         }
       }
       throw new FormatException("Invalid base64 data", source, sliceEnd);
     }
     if (buffer != null) {
       buffer.write(source.substring(sliceStart, end));
       if (firstPadding >= 0) {
         // There was padding in the source. Check that it is valid:
         // * result length a multiple of four
         // * one or two padding characters at the end.
-        _checkPadding(source, firstPaddingSourceIndex, end,
-                      firstPadding, paddingCount, buffer.length);
+        _checkPadding(source, firstPaddingSourceIndex, end, firstPadding,
+            paddingCount, buffer.length);
       } else {
         // Length of last chunk (1-4 chars) in the encoding.
         int endLength = ((buffer.length - 1) % 4) + 1;
         if (endLength == 1) {
           // The data must have length 0, 2 or 3 modulo 4.
-          throw new FormatException("Invalid base64 encoding length ",
-              source, end);
+          throw new FormatException(
+              "Invalid base64 encoding length ", source, end);
         }
         while (endLength < 4) {
           buffer.write("=");
           endLength++;
         }
       }
       return source.replaceRange(start, end, buffer.toString());
     }
     // Original was already normalized, only check padding.
     int length = end - start;
     if (firstPadding >= 0) {
-      _checkPadding(source, firstPaddingSourceIndex, end,
-          firstPadding, paddingCount, length);
+      _checkPadding(source, firstPaddingSourceIndex, end, firstPadding,
+          paddingCount, length);
     } else {
       // No padding given, so add some if needed it.
       int endLength = length % 4;
       if (endLength == 1) {
-          // The data must have length 0, 2 or 3 modulo 4.
-          throw new FormatException("Invalid base64 encoding length ",
-              source, end);
+        // The data must have length 0, 2 or 3 modulo 4.
+        throw new FormatException(
+            "Invalid base64 encoding length ", source, end);
       }
       if (endLength > 1) {
         // There is no "insertAt" on String, but this works as well.
         source = source.replaceRange(end, end, (endLength == 2) ? "==" : "=");
       }
     }
     return source;
   }
 
   static int _checkPadding(String source, int sourceIndex, int sourceEnd,
-          int firstPadding, int paddingCount, int length) {
+      int firstPadding, int paddingCount, int length) {
     if (length % 4 != 0) {
       throw new FormatException(
           "Invalid base64 padding, padded length must be multiple of four, "
           "is $length",
-          source, sourceEnd);
+          source,
+          sourceEnd);
     }
     if (firstPadding + paddingCount != length) {
       throw new FormatException(
-          "Invalid base64 padding, '=' not at the end",
-          source, sourceIndex);
+          "Invalid base64 padding, '=' not at the end", source, sourceIndex);
     }
     if (paddingCount > 2) {
       throw new FormatException(
           "Invalid base64 padding, more than two '=' characters",
-          source, sourceIndex);
+          source,
+          sourceIndex);
     }
   }
 }
 
 // ------------------------------------------------------------------------
 // Encoder
 // ------------------------------------------------------------------------
 
 /**
  * Base64 and base64url encoding converter.
  *
  * Encodes lists of bytes using base64 or base64url encoding.
  *
  * The results are ASCII strings using a restricted alphabet.
  */
 class Base64Encoder extends Converter<List<int>, String>
     implements ChunkedConverter<List<int>, String, List<int>, String> {
-
   final bool _urlSafe;
 
   const Base64Encoder() : _urlSafe = false;
   const Base64Encoder.urlSafe() : _urlSafe = true;
 
   String convert(List<int> input) {
     if (input.isEmpty) return "";
     var encoder = new _Base64Encoder(_urlSafe);
     Uint8List buffer = encoder.encode(input, 0, input.length, true);
     return new String.fromCharCodes(buffer);
@@ skipping 77 matching lines @@
     assert(start <= end);
     assert(bytes == null || end <= bytes.length);
     int length = end - start;
 
     int count = _stateCount(_state);
     int byteCount = (count + length);
     int fullChunks = byteCount ~/ 3;
     int partialChunkLength = byteCount - fullChunks * 3;
     int bufferLength = fullChunks * 4;
     if (isLast && partialChunkLength > 0) {
-      bufferLength += 4;  // Room for padding.
+      bufferLength += 4; // Room for padding.
     }
     var output = createBuffer(bufferLength);
-    _state = encodeChunk(_alphabet, bytes, start, end, isLast,
-                         output, 0, _state);
+    _state =
+        encodeChunk(_alphabet, bytes, start, end, isLast, output, 0, _state);
     if (bufferLength > 0) return output;
     // If the input plus the data in state is still less than three bytes,
     // there may not be any output.
     return null;
   }
 
-  static int encodeChunk(String alphabet,
-                         List<int> bytes, int start, int end, bool isLast,
-                         Uint8List output, int outputIndex, int state) {
+  static int encodeChunk(String alphabet, List<int> bytes, int start, int end,
+      bool isLast, Uint8List output, int outputIndex, int state) {
     int bits = _stateBits(state);
     // Count number of missing bytes in three-byte chunk.
     int expectedChars = 3 - _stateCount(state);
 
     // The input must be a list of bytes (integers in the range 0..255).
     // The value of `byteOr` will be the bitwise or of all the values in
     // `bytes` and a later check will validate that they were all valid bytes.
     int byteOr = 0;
     for (int i = start; i < end; i++) {
       int byte = bytes[i];
       byteOr |= byte;
-      bits = ((bits << 8) | byte) & 0xFFFFFF;  // Never store more than 24 bits.
+      bits = ((bits << 8) | byte) & 0xFFFFFF; // Never store more than 24 bits.
       expectedChars--;
       if (expectedChars == 0) {
-        output[outputIndex++] =
-            alphabet.codeUnitAt((bits >> 18) & _sixBitMask);
-        output[outputIndex++] =
-            alphabet.codeUnitAt((bits >> 12) & _sixBitMask);
-        output[outputIndex++] =
-            alphabet.codeUnitAt((bits >> 6) & _sixBitMask);
-        output[outputIndex++] =
-            alphabet.codeUnitAt(bits & _sixBitMask);
+        output[outputIndex++] = alphabet.codeUnitAt((bits >> 18) & _sixBitMask);
+        output[outputIndex++] = alphabet.codeUnitAt((bits >> 12) & _sixBitMask);
+        output[outputIndex++] = alphabet.codeUnitAt((bits >> 6) & _sixBitMask);
+        output[outputIndex++] = alphabet.codeUnitAt(bits & _sixBitMask);
         expectedChars = 3;
         bits = 0;
       }
     }
     if (byteOr >= 0 && byteOr <= 255) {
       if (isLast && expectedChars < 3) {
         writeFinalChunk(alphabet, output, outputIndex, 3 - expectedChars, bits);
         return 0;
       }
       return _encodeState(3 - expectedChars, bits);
     }
 
     // There was an invalid byte value somewhere in the input - find it!
     int i = start;
     while (i < end) {
       int byte = bytes[i];
       if (byte < 0 || byte > 255) break;
       i++;
     }
-    throw new ArgumentError.value(bytes,
-        "Not a byte value at index $i: 0x${bytes[i].toRadixString(16)}");
+    throw new ArgumentError.value(
+        bytes, "Not a byte value at index $i: 0x${bytes[i].toRadixString(16)}");
   }
 
   /**
    * Writes a final encoded four-character chunk.
    *
    * Only used when the [_state] contains a partial (1 or 2 byte)
    * input.
    */
-  static void writeFinalChunk(String alphabet,
-                              Uint8List output, int outputIndex,
-                              int count, int bits) {
+  static void writeFinalChunk(
+      String alphabet, Uint8List output, int outputIndex, int count, int bits) {
     assert(count > 0);
     if (count == 1) {
-      output[outputIndex++] =
-          alphabet.codeUnitAt((bits >> 2) & _sixBitMask);
-      output[outputIndex++] =
-          alphabet.codeUnitAt((bits << 4) & _sixBitMask);
+      output[outputIndex++] = alphabet.codeUnitAt((bits >> 2) & _sixBitMask);
+      output[outputIndex++] = alphabet.codeUnitAt((bits << 4) & _sixBitMask);
       output[outputIndex++] = _paddingChar;
       output[outputIndex++] = _paddingChar;
     } else {
       assert(count == 2);
-      output[outputIndex++] =
-          alphabet.codeUnitAt((bits >> 10) & _sixBitMask);
-      output[outputIndex++] =
-          alphabet.codeUnitAt((bits >> 4) & _sixBitMask);
-      output[outputIndex++] =
-          alphabet.codeUnitAt((bits << 2) & _sixBitMask);
+      output[outputIndex++] = alphabet.codeUnitAt((bits >> 10) & _sixBitMask);
+      output[outputIndex++] = alphabet.codeUnitAt((bits >> 4) & _sixBitMask);
+      output[outputIndex++] = alphabet.codeUnitAt((bits << 2) & _sixBitMask);
       output[outputIndex++] = _paddingChar;
     }
   }
 }
 
 class _BufferCachingBase64Encoder extends _Base64Encoder {
   /**
    * Reused buffer.
    *
    * When the buffer isn't released to the sink, only used to create another
@@ skipping 70 matching lines @@
 
 /**
  * Decoder for base64 encoded data.
  *
  * This decoder accepts both base64 and base64url ("url-safe") encodings.
  *
  * The encoding is required to be properly padded.
  */
 class Base64Decoder extends Converter<String, List<int>>
     implements ChunkedConverter<String, List<int>, String, List<int>> {
-
   const Base64Decoder();
 
   List<int> convert(String input, [int start = 0, int end]) {
     end = RangeError.checkValidRange(start, end, input.length);
     if (start == end) return new Uint8List(0);
     var decoder = new _Base64Decoder();
     Uint8List buffer = decoder.decode(input, start, end);
     decoder.close(input, end);
     return buffer;
   }
@@ skipping 28 matching lines @@
    *
    * Uses [_invalid] for invalid indices and [_padding] for the padding
    * character.
    *
    * Accepts the "URL-safe" alphabet as well (`-` and `_` are the
    * 62nd and 63rd alphabet characters), and considers `%` a padding
    * character, which must then be followed by `3D`, the percent-escape
    * for `=`.
    */
   static final List<int> _inverseAlphabet = new Int8List.fromList([
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
-    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
-    __, __, __, __, __, _p, __, __, __, __, __, 62, __, 62, __, 63,
-    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, __, __, __, _p, __, __,
-    __,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, __, __, __, __, 63,
-    __, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, __, __, __, __, __,
+    __,

[floitsch, 2017/03/16 10:37:54]

There is a reason these were aligned in blocks of 16.

+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    __,
+    _p,
+    __,
+    __,
+    __,
+    __,
+    __,
+    62,
+    __,
+    62,
+    __,
+    63,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57,
+    58,
+    59,
+    60,
+    61,
+    __,
+    __,
+    __,
+    _p,
+    __,
+    __,
+    __,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    __,
+    __,
+    __,
+    __,
+    63,
+    __,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    50,
+    51,
+    __,
+    __,
+    __,
+    __,
+    __,
   ]);
 
   // Character constants.
-  static const int _char_percent = 0x25;  // '%'.
-  static const int _char_3       = 0x33;  // '3'.
-  static const int _char_d       = 0x64;  // 'd'.
+  static const int _char_percent = 0x25; // '%'.
+  static const int _char_3 = 0x33; // '3'.
+  static const int _char_d = 0x64; // 'd'.
 
   /**
    * Maintains the intermediate state of a partly-decoded input.
    *
    * Base64 is decoded in chunks of four characters. If a chunk does not
    * contain a full block, the decoded bits (six per character) of the
    * available characters are stored in [_state] until the next call to
    * [_decode] or [_close].
    *
    * If no padding has been seen, the value is
@@ skipping 32 matching lines @@
     assert(state >= 0);
     return state >> _valueShift;
   }
 
   /**
    * Encodes a number of expected padding characters to be stored in [_state].
    */
   static int _encodePaddingState(int expectedPadding) {
     assert(expectedPadding >= 0);
     assert(expectedPadding <= 5);
-    return -expectedPadding - 1;  // ~expectedPadding adapted to dart2js.
+    return -expectedPadding - 1; // ~expectedPadding adapted to dart2js.
   }
 
   /**
    * Extracts expected padding character count from a [_state] value.
    */
   static int _statePadding(int state) {
     assert(state < 0);
-    return -state - 1;  // ~state adapted to dart2js.
+    return -state - 1; // ~state adapted to dart2js.
   }
 
   static bool _hasSeenPadding(int state) => state < 0;
 
   /**
    * Decodes [input] from [start] to [end].
    *
    * Returns a [Uint8List] with the decoded bytes.
    * If a previous call had an incomplete four-character block, the bits from
    * those are included in decoding
@@ skipping 11 matching lines @@
     _state = decodeChunk(input, start, end, buffer, 0, _state);
     return buffer;
   }
 
   /** Checks that [_state] represents a valid decoding. */
   void close(String input, int end) {
     if (_state < _encodePaddingState(0)) {
       throw new FormatException("Missing padding character", input, end);
     }
     if (_state > 0) {
-      throw new FormatException("Invalid length, must be multiple of four",
-                                input, end);
+      throw new FormatException(
+          "Invalid length, must be multiple of four", input, end);
     }
     _state = _encodePaddingState(0);
   }
 
   /**
    * Decodes [input] from [start] to [end].
    *
    * Includes the state returned by a previous call in the decoding.
    * Writes the decoding to [output] at [outIndex], and there must
    * be room in the output.
    */
-  static int decodeChunk(String input, int start, int end,
-                          Uint8List output, int outIndex,
-                          int state) {
+  static int decodeChunk(String input, int start, int end, Uint8List output,
+      int outIndex, int state) {
     assert(!_hasSeenPadding(state));
     const int asciiMask = 127;
     const int asciiMax = 127;
     const int eightBitMask = 0xFF;
     const int bitsPerCharacter = 6;
 
     int bits = _stateBits(state);
     int count = _stateCount(state);
     // String contents should be all ASCII.
     // Instead of checking for each character, we collect the bitwise-or of
@@ skipping 53 matching lines @@
       if (char < 0 || char > asciiMax) break;
     }
     throw new FormatException("Invalid character", input, i);
   }
 
   /**
    * Allocates a buffer with room for the decoding of a substring of [input].
    *
    * Includes room for the characters in [state], and handles padding correctly.
    */
-  static Uint8List _allocateBuffer(String input, int start, int end,
-                                   int state) {
+  static Uint8List _allocateBuffer(
+      String input, int start, int end, int state) {
     assert(state >= 0);
     int paddingStart = _trimPaddingChars(input, start, end);
     int length = _stateCount(state) + (paddingStart - start);
     // Three bytes per full four bytes in the input.
     int bufferLength = (length >> 2) * 3;
     // If padding was seen, then this is the last chunk, and the final partial
     // chunk should be decoded too.
     int remainderLength = length & 3;
     if (remainderLength != 0 && paddingStart < end) {
       bufferLength += remainderLength - 1;
@@ skipping 105 matching lines @@
         if (start == end) break;
         char = input.codeUnitAt(start);
       }
       // Expects 'D' or 'd'.
       if ((char | 0x20) != _char_d) break;
       start++;
       expectedPadding--;
       if (start == end) break;
     }
     if (start != end) {
-      throw new FormatException("Invalid padding character",
-                                input, start);
+      throw new FormatException("Invalid padding character", input, start);
     }
     return _encodePaddingState(expectedPadding);
   }
 }
 
 class _Base64DecoderSink extends StringConversionSinkBase {
   /** Output sink */
   final Sink<List<int>> _sink;
   final _Base64Decoder _decoder = new _Base64Decoder();
 
@@ skipping 14 matching lines @@
     end = RangeError.checkValidRange(start, end, string.length);
     if (start == end) return;
     Uint8List buffer = _decoder.decode(string, start, end);
     if (buffer != null) _sink.add(buffer);
     if (isLast) {
       _decoder.close(string, end);
       _sink.close();
     }
   }
 }