dartfmt pkg/compiler

pkg/compiler/lib/src/hash/sha1.dart

 // Copyright (c) 2012, 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.
 
 /**
  * SHA-1.
  * Ripped from package:crypto.
  */
 library sha1;
 
@@ skipping 36 matching lines @@
    *
    * If [addLineSeparator] is true, the resulting string will  be
    * broken into lines of 76 characters, separated by "\r\n".
    *
    * If [urlSafe] is true, the result is URL and filename safe.
    *
    * Based on [RFC 4648](http://tools.ietf.org/html/rfc4648)
    *
    */
   String _bytesToBase64(List<int> bytes,
-                              {bool urlSafe : false,
-                               bool addLineSeparator : false}) {
-    return _CryptoUtils.bytesToBase64(bytes,
-                                      urlSafe,
-                                      addLineSeparator);
+      {bool urlSafe: false, bool addLineSeparator: false}) {
+    return _CryptoUtils.bytesToBase64(bytes, urlSafe, addLineSeparator);
   }
 }
 
-
 // Constants.
 const _MASK_8 = 0xff;
 const _MASK_32 = 0xffffffff;
 const _BITS_PER_BYTE = 8;
 const _BYTES_PER_WORD = 4;
 
 // Helper functions used by more than one hasher.
 
 // Rotate left limiting to unsigned 32-bit values.
 int _rotl32(int val, int shift) {
-var mod_shift = shift & 31;
-return ((val << mod_shift) & _MASK_32) |
-   ((val & _MASK_32) >> (32 - mod_shift));
+  var mod_shift = shift & 31;
+  return ((val << mod_shift) & _MASK_32) |
+      ((val & _MASK_32) >> (32 - mod_shift));
 }
 
 // Base class encapsulating common behavior for cryptographic hash
 // functions.
 abstract class _HashBase implements Hash {
   final int _chunkSizeInWords;
   final int _digestSizeInWords;
   final bool _bigEndianWords;
   final List<int> _currentChunk;
   final List<int> _h;
   int _lengthInBytes = 0;
   List<int> _pendingData;
   bool _digestCalled = false;
 
-  _HashBase(int chunkSizeInWords,
-            int digestSizeInWords,
-            bool this._bigEndianWords)
+  _HashBase(
+      int chunkSizeInWords, int digestSizeInWords, bool this._bigEndianWords)
       : _pendingData = [],
         _currentChunk = new List(chunkSizeInWords),
         _h = new List(digestSizeInWords),
         _chunkSizeInWords = chunkSizeInWords,
         _digestSizeInWords = digestSizeInWords;
 
   // Update the hasher with more data.
   void add(List<int> data) {
-     if (_digestCalled) {
-       throw new StateError(
-           'Hash update method called after digest was retrieved');
-     }
-     _lengthInBytes += data.length;
-     _pendingData.addAll(data);
-     _iterate();
+    if (_digestCalled) {
+      throw new StateError(
+          'Hash update method called after digest was retrieved');
+    }
+    _lengthInBytes += data.length;
+    _pendingData.addAll(data);
+    _iterate();
   }
 
   // Finish the hash computation and return the digest string.
   List<int> close() {
     if (_digestCalled) {
       return _resultAsBytes();
     }
     _digestCalled = true;
     _finalizeData();
     _iterate();
     assert(_pendingData.length == 0);
     return _resultAsBytes();
   }
 
   // Returns the block size of the hash in bytes.
   int get blockSize {
-   return _chunkSizeInWords * _BYTES_PER_WORD;
+    return _chunkSizeInWords * _BYTES_PER_WORD;
   }
 
   // One round of the hash computation.
   void _updateHash(List<int> m);
 
   // Helper methods.
   int _add32(x, y) => (x + y) & _MASK_32;
   int _roundUp(val, n) => (val + n - 1) & -n;
 
   // Compute the final result as a list of bytes from the hash words.
@@ skipping 64 matching lines @@
     if (_bigEndianWords) {
       _pendingData.addAll(_wordToBytes(0));
       _pendingData.addAll(_wordToBytes(lengthInBits & _MASK_32));
     } else {
       _pendingData.addAll(_wordToBytes(lengthInBits & _MASK_32));
       _pendingData.addAll(_wordToBytes(0));
     }
   }
 }
 
-
 /**
  * Interface for cryptographic hash functions.
  *
  * The [add] method is used to add data to the hash. The [close] method
  * is used to extract the message digest.
  *
  * Once the [close] method has been called no more data can be added using the
  * [add] method. If [add] is called after the first call to [close] a
  * HashException is thrown.
  *
@@ skipping 22 matching lines @@
   int get blockSize;
 }
 
 /**
  * SHA1 hash function implementation.
  */
 class SHA1 extends _HashBase {
   final List<int> _w;
 
   // Construct a SHA1 hasher object.
-  SHA1() : _w = new List(80), super(16, 5, true) {
+  SHA1()
+      : _w = new List(80),
+        super(16, 5, true) {
     _h[0] = 0x67452301;
     _h[1] = 0xEFCDAB89;
     _h[2] = 0x98BADCFE;
     _h[3] = 0x10325476;
     _h[4] = 0xC3D2E1F0;
   }
 
   // Compute one iteration of the SHA1 algorithm with a chunk of
   // 16 32-bit pieces.
   void _updateHash(List<int> m) {
@@ skipping 32 matching lines @@
 
     _h[0] = _add32(a, _h[0]);
     _h[1] = _add32(b, _h[1]);
     _h[2] = _add32(c, _h[2]);
     _h[3] = _add32(d, _h[3]);
     _h[4] = _add32(e, _h[4]);
   }
 }
 
 abstract class _CryptoUtils {
-
   static const int PAD = 61; // '='
-  static const int CR = 13;  // '\r'
-  static const int LF = 10;  // '\n'
+  static const int CR = 13; // '\r'
+  static const int LF = 10; // '\n'
   static const int LINE_LENGTH = 76;
 
   static const String _encodeTable =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
   static const String _encodeTableUrlSafe =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
   static String bytesToBase64(List<int> bytes,
-                              [bool urlSafe = false,
-                               bool addLineSeparator = false]) {
+      [bool urlSafe = false, bool addLineSeparator = false]) {
     int len = bytes.length;
     if (len == 0) {
       return "";
     }
     final String lookup = urlSafe ? _encodeTableUrlSafe : _encodeTable;
     // Size of 24 bit chunks.
     final int remainderLength = len.remainder(3);
     final int chunkLength = len - remainderLength;
     // Size of base output.
     int outputLen = ((len ~/ 3) * 4) + ((remainderLength > 0) ? 4 : 0);
     // Add extra for line separators.
     if (addLineSeparator) {
       outputLen += ((outputLen - 1) ~/ LINE_LENGTH) << 1;
     }
     List<int> out = new List<int>(outputLen);
 
     // Encode 24 bit chunks.
     int j = 0, i = 0, c = 0;
     while (i < chunkLength) {
       int x = ((bytes[i++] << 16) & 0xFFFFFF) |
-              ((bytes[i++] << 8) & 0xFFFFFF) |
-                bytes[i++];
+          ((bytes[i++] << 8) & 0xFFFFFF) |
+          bytes[i++];
       out[j++] = lookup.codeUnitAt(x >> 18);
       out[j++] = lookup.codeUnitAt((x >> 12) & 0x3F);
-      out[j++] = lookup.codeUnitAt((x >> 6)  & 0x3F);
+      out[j++] = lookup.codeUnitAt((x >> 6) & 0x3F);
       out[j++] = lookup.codeUnitAt(x & 0x3f);
       // Add optional line separator for each 76 char output.
       if (addLineSeparator && ++c == 19 && j < outputLen - 2) {
         out[j++] = CR;
         out[j++] = LF;
         c = 0;
       }
     }
 
     // If input length if not a multiple of 3, encode remaining bytes and
     // add padding.
     if (remainderLength == 1) {
       int x = bytes[i];
       out[j++] = lookup.codeUnitAt(x >> 2);
       out[j++] = lookup.codeUnitAt((x << 4) & 0x3F);
       out[j++] = PAD;
       out[j++] = PAD;
     } else if (remainderLength == 2) {
       int x = bytes[i];
       int y = bytes[i + 1];
       out[j++] = lookup.codeUnitAt(x >> 2);
       out[j++] = lookup.codeUnitAt(((x << 4) | (y >> 4)) & 0x3F);
       out[j++] = lookup.codeUnitAt((y << 2) & 0x3F);
       out[j++] = PAD;
     }
 
     return new String.fromCharCodes(out);
   }
 }