pkg/csslib: formatting

lib/src/tokenizer_base.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.
 // Generated by scripts/tokenizer_gen.py.
 
 part of csslib.parser;
 
 /** Tokenizer state to support look ahead for Less' nested selectors. */
 class TokenizerState {
   final int index;
   final int startIndex;
   final bool inSelectorExpression;
   final bool inSelector;
 
-  TokenizerState(TokenizerBase base) :
-      index = base._index,
-      startIndex = base._startIndex,
-      inSelectorExpression = base.inSelectorExpression,
-      inSelector = base.inSelector;
+  TokenizerState(TokenizerBase base)
+      : index = base._index,
+        startIndex = base._startIndex,
+        inSelectorExpression = base.inSelectorExpression,
+        inSelector = base.inSelector;
 }
 
 /**
  * The base class for our tokenizer. The hand coded parts are in this file, with
  * the generated parts in the subclass Tokenizer.
  */
 abstract class TokenizerBase {
   final SourceFile _file;
   final String _text;
 
@@ skipping 104 matching lines @@
           return _finishToken(TokenKind.WHITESPACE); // note the newline?
         }
       } else {
         _index--;
         if (_skipWhitespace) {
           return next();
         } else {
           return _finishToken(TokenKind.WHITESPACE);
         }
       }
-
     }
     return _finishToken(TokenKind.END_OF_FILE);
   }
 
   Token finishMultiLineComment() {
     int nesting = 1;
     do {
       int ch = _nextChar();
       if (ch == 0) {
         return _errorToken();
@@ skipping 19 matching lines @@
     while (_index < _text.length) {
       if (TokenizerHelpers.isDigit(_text.codeUnitAt(_index))) {
         _index++;
       } else {
         return;
       }
     }
   }
 
   static int _hexDigit(int c) {
-    if(c >= 48/*0*/ && c <= 57/*9*/) {
+    if (c >= 48 /*0*/ && c <= 57 /*9*/) {
       return c - 48;
-    } else if (c >= 97/*a*/ && c <= 102/*f*/) {
+    } else if (c >= 97 /*a*/ && c <= 102 /*f*/) {
       return c - 87;
-    } else if (c >= 65/*A*/ && c <= 70/*F*/) {
+    } else if (c >= 65 /*A*/ && c <= 70 /*F*/) {
       return c - 55;
     } else {
       return -1;
     }
   }
 
   int readHex([int hexLength]) {
     int maxIndex;
     if (hexLength == null) {
       maxIndex = _text.length - 1;
@@ skipping 35 matching lines @@
         return finishNumberExtra(TokenKind.DOUBLE);
       } else {
         _index--;
       }
     }
 
     return finishNumberExtra(TokenKind.INTEGER);
   }
 
   Token finishNumberExtra(int kind) {
-    if (_maybeEatChar(101/*e*/) || _maybeEatChar(69/*E*/)) {
+    if (_maybeEatChar(101 /*e*/) || _maybeEatChar(69 /*E*/)) {
       kind = TokenKind.DOUBLE;
       _maybeEatChar(TokenKind.MINUS);
       _maybeEatChar(TokenKind.PLUS);
       eatDigits();
     }
     if (_peekChar() != 0 && TokenizerHelpers.isIdentifierStart(_peekChar())) {
       _nextChar();
       return _errorToken("illegal character in number");
     }
 
@@ skipping 14 matching lines @@
   Token _makeRawStringToken(bool isMultiline) {
     var s;
     if (isMultiline) {
       // Skip initial newline in multiline strings
       int start = _startIndex + 4;
       if (_text[start] == '\n') start++;
       s = _text.substring(start, _index - 3);
     } else {
       s = _text.substring(_startIndex + 2, _index - 1);
     }
-    return new LiteralToken(TokenKind.STRING,
-        _file.span(_startIndex, _index), s);
+    return new LiteralToken(
+        TokenKind.STRING, _file.span(_startIndex, _index), s);
   }
 
   Token finishMultilineString(int quote) {
     var buf = <int>[];
     while (true) {
       int ch = _nextChar();
       if (ch == 0) {
         return _errorToken();
       } else if (ch == quote) {
         if (_maybeEatChar(quote)) {
@@ skipping 84 matching lines @@
       } else {
         buf.add(ch);
       }
     }
   }
 
   int readEscapeSequence() {
     final ch = _nextChar();
     int hexValue;
     switch (ch) {
-      case 110/*n*/:
+      case 110 /*n*/ :
         return TokenChar.NEWLINE;
-      case 114/*r*/:
+      case 114 /*r*/ :
         return TokenChar.RETURN;
-      case 102/*f*/:
+      case 102 /*f*/ :
         return TokenChar.FF;
-      case 98/*b*/:
+      case 98 /*b*/ :
         return TokenChar.BACKSPACE;
-      case 116/*t*/:
+      case 116 /*t*/ :
         return TokenChar.TAB;
-      case 118/*v*/:
+      case 118 /*v*/ :
         return TokenChar.FF;
-      case 120/*x*/:
+      case 120 /*x*/ :
         hexValue = readHex(2);
         break;
-      case 117/*u*/:
+      case 117 /*u*/ :
         if (_maybeEatChar(TokenChar.LBRACE)) {
           hexValue = readHex();
           if (!_maybeEatChar(TokenChar.RBRACE)) {
             return -1;
           }
         } else {
           hexValue = readHex(4);
         }
         break;
-      default: return ch;
+      default:
+        return ch;
     }
 
     if (hexValue == -1) return -1;
 
     // According to the Unicode standard the high and low surrogate halves
     // used by UTF-16 (U+D800 through U+DFFF) and values above U+10FFFF
     // are not legal Unicode values.
     if (hexValue < 0xD800 || hexValue > 0xDFFF && hexValue <= 0xFFFF) {
       return hexValue;
-    } else if (hexValue <= 0x10FFFF){
+    } else if (hexValue <= 0x10FFFF) {
       messages.error('unicode values greater than 2 bytes not implemented yet',
           _file.span(_startIndex, _startIndex + 1));
       return -1;
     } else {
       return -1;
     }
   }
 
   Token finishDot() {
     if (TokenizerHelpers.isDigit(_peekChar())) {
       eatDigits();
       return finishNumberExtra(TokenKind.DOUBLE);
     } else {
       return _finishToken(TokenKind.DOT);
     }
   }
 }