Clean up JSON parsing code.

runtime/lib/convert_patch.dart

 // 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.
 
 import "dart:_internal" show POWERS_OF_TEN;
 
 // JSON conversion.
 
 patch _parseJson(String json, reviver(var key, var value)) {
   _BuildJsonListener listener;
@@ skipping 13 matching lines @@
 patch class Utf8Decoder {
   /* patch */
   Converter<List<int>, dynamic> fuse(Converter<String, dynamic> next) {
     if (next is JsonDecoder) {
       return new _JsonUtf8Decoder(next._reviver, this._allowMalformed);
     }
     // TODO(lrn): Recognize a fused decoder where the next step is JsonDecoder.
     return super.fuse(next);
   }
 
-  // Allow intercepting of UTF8 decoding when builtin lists are passed.
+  // Allow intercepting of UTF-8 decoding when built-in lists are passed.
   /* patch */
   static String _convertIntercepted(
       bool allowMalformed, List<int> codeUnits, int start, int end) {
     return null;  // This call was not intercepted.
   }
 }
 
 class _JsonUtf8Decoder extends Converter<List<int>, Object> {
   final _Reviver _reviver;
   final bool _allowMalformed;
@@ skipping 25 matching lines @@
   void handleNumber(num value) {}
   void handleBool(bool value) {}
   void handleNull() {}
   void beginObject() {}
   void propertyName() {}
   void propertyValue() {}
   void endObject() {}
   void beginArray() {}
   void arrayElement() {}
   void endArray() {}
+
+  /**
+   * Read out the final result of parsing a JSON string.
+   *
+   * Must only be called when the entire input has been parsed.
+   */
+  get result;
 }
 
 /**
  * A [_JsonListener] that builds data objects from the parser events.
  *
  * This is a simple stack-based object builder. It keeps the most recently
  * seen value in a variable, and uses it depending on the following event.
  */
 class _BuildJsonListener extends _JsonListener {
   /**
@@ skipping 171 matching lines @@
   // Starting a new array or object will push the current state. The "pop"
   // above means restoring this state and then marking it as an ended value.
   // X means generic handling, @ means special handling for just that
   // state - that is, values are handled generically, only punctuation
   // cares about the current state.
   // Values for states are chosen so bits 0 and 1 tell whether
   // a string/value is allowed, and setting bits 0 through 2 after a value
   // gets to the next state (not empty, doesn't allow a value).
 
   // State building-block constants.
-  static const int INSIDE_ARRAY = 1;
-  static const int INSIDE_OBJECT = 2;
-  static const int AFTER_COLON = 3;  // Always inside object.
+  static const int TOP_LEVEL         = 0;
+  static const int INSIDE_ARRAY      = 1;
+  static const int INSIDE_OBJECT     = 2;
+  static const int AFTER_COLON       = 3;  // Always inside object.
 
   static const int ALLOW_STRING_MASK = 8;  // Allowed if zero.
-  static const int ALLOW_VALUE_MASK = 4;  // Allowed if zero.
-  static const int ALLOW_VALUE = 0;
-  static const int STRING_ONLY = 4;
-  static const int NO_VALUES = 12;
+  static const int ALLOW_VALUE_MASK  = 4;  // Allowed if zero.
+  static const int ALLOW_VALUE       = 0;
+  static const int STRING_ONLY       = 4;
+  static const int NO_VALUES         = 12;
 
   // Objects and arrays are "empty" until their first property/element.
   // At this position, they may either have an entry or a close-bracket.
-  static const int EMPTY = 0;
-  static const int NON_EMPTY = 16;
-  static const int EMPTY_MASK = 16;  // Empty if zero.
+  static const int EMPTY             =  0;
+  static const int NON_EMPTY         = 16;
+  static const int EMPTY_MASK        = 16;  // Empty if zero.
 
-  static const int VALUE_READ_BITS = NO_VALUES | NON_EMPTY;
+  // Actual states                    : Context       | Is empty? | Next?
+  static const int STATE_INITIAL      = TOP_LEVEL     | EMPTY     | ALLOW_VALUE;
+  static const int STATE_END          = TOP_LEVEL     | NON_EMPTY | NO_VALUES;
 
-  // Actual states.
-  static const int STATE_INITIAL      = EMPTY | ALLOW_VALUE;
-  static const int STATE_END          = NON_EMPTY | NO_VALUES;
+  static const int STATE_ARRAY_EMPTY  = INSIDE_ARRAY  | EMPTY     | ALLOW_VALUE;
+  static const int STATE_ARRAY_VALUE  = INSIDE_ARRAY  | NON_EMPTY | NO_VALUES;
+  static const int STATE_ARRAY_COMMA  = INSIDE_ARRAY  | NON_EMPTY | ALLOW_VALUE;
 
-  static const int STATE_ARRAY_EMPTY  = INSIDE_ARRAY | EMPTY | ALLOW_VALUE;
-  static const int STATE_ARRAY_VALUE  = INSIDE_ARRAY | NON_EMPTY | NO_VALUES;
-  static const int STATE_ARRAY_COMMA  = INSIDE_ARRAY | NON_EMPTY | ALLOW_VALUE;
+  static const int STATE_OBJECT_EMPTY = INSIDE_OBJECT | EMPTY     | STRING_ONLY;
+  static const int STATE_OBJECT_KEY   = INSIDE_OBJECT | NON_EMPTY | NO_VALUES;
+  static const int STATE_OBJECT_COLON = AFTER_COLON   | NON_EMPTY | ALLOW_VALUE;
+  static const int STATE_OBJECT_VALUE = AFTER_COLON   | NON_EMPTY | NO_VALUES;
+  static const int STATE_OBJECT_COMMA = INSIDE_OBJECT | NON_EMPTY | STRING_ONLY;
 
-  static const int STATE_OBJECT_EMPTY = INSIDE_OBJECT | EMPTY | STRING_ONLY;
-  static const int STATE_OBJECT_KEY   = INSIDE_OBJECT | NON_EMPTY | NO_VALUES;
-  static const int STATE_OBJECT_COLON = AFTER_COLON | NON_EMPTY | ALLOW_VALUE;
-  static const int STATE_OBJECT_VALUE = AFTER_COLON | NON_EMPTY | NO_VALUES;
-  static const int STATE_OBJECT_COMMA = INSIDE_OBJECT | NON_EMPTY | STRING_ONLY;
+  // Bits set in state after successfully reading a value.
+  // This transitions the state to expect the next punctuation.
+  static const int VALUE_READ_BITS    = NON_EMPTY | NO_VALUES;
 
   // Character code constants.
   static const int BACKSPACE       = 0x08;
   static const int TAB             = 0x09;
   static const int NEWLINE         = 0x0a;
   static const int CARRIAGE_RETURN = 0x0d;
   static const int FORM_FEED       = 0x0c;
   static const int SPACE           = 0x20;
   static const int QUOTE           = 0x22;
   static const int PLUS            = 0x2b;
@@ skipping 15 matching lines @@
   static const int CHAR_l          = 0x6c;
   static const int CHAR_n          = 0x6e;
   static const int CHAR_r          = 0x72;
   static const int CHAR_s          = 0x73;
   static const int CHAR_t          = 0x74;
   static const int CHAR_u          = 0x75;
   static const int LBRACE          = 0x7b;
   static const int RBRACE          = 0x7d;
 
   // State of partial value at chunk split.
-  static const int NO_PARTIAL      = 0;
-  static const int PARTIAL_STRING  = 1;
-  static const int PARTIAL_NUMERAL = 2;
-  static const int PARTIAL_KEYWORD = 3;
-  static const int MASK_PARTIAL    = 3;
+  static const int NO_PARTIAL        =  0;
+  static const int PARTIAL_STRING    =  1;
+  static const int PARTIAL_NUMERAL   =  2;
+  static const int PARTIAL_KEYWORD   =  3;
+  static const int MASK_PARTIAL      =  3;
 
   // Partial states for numerals. Values can be |'ed with PARTIAL_NUMERAL.
-  static const int NUM_SIGN        =  0;  // After initial '-'.
-  static const int NUM_ZERO        =  4;  // After '0' as first digit.
-  static const int NUM_DIGIT       =  8;  // After digit, no '.' or 'e' seen.
-  static const int NUM_DOT         = 12;  // After '.'.
-  static const int NUM_DOT_DIGIT   = 16;  // After a decimal digit (after '.').
-  static const int NUM_E           = 20;  // After 'e' or 'E'.
-  static const int NUM_E_SIGN      = 24;  // After '-' or '+' after 'e' or 'E'.
-  static const int NUM_E_DIGIT     = 28;  // After exponent digit.
-  static const int NUM_SUCCESS     = 32;  // Never stored as partial state.
+  static const int NUM_SIGN          =  0;  // After initial '-'.
+  static const int NUM_ZERO          =  4;  // After '0' as first digit.
+  static const int NUM_DIGIT         =  8;  // After digit, no '.' or 'e' seen.
+  static const int NUM_DOT           = 12;  // After '.'.
+  static const int NUM_DOT_DIGIT     = 16;  // After a decimal digit (after '.').
+  static const int NUM_E             = 20;  // After 'e' or 'E'.
+  static const int NUM_E_SIGN        = 24;  // After '-' or '+' after 'e' or 'E'.
+  static const int NUM_E_DIGIT       = 28;  // After exponent digit.
+  static const int NUM_SUCCESS       = 32;  // Never stored as partial state.
 
   // Partial states for strings.
   static const int STR_PLAIN         =  0;   // Inside string, but not escape.
   static const int STR_ESCAPE        =  4;   // After '\'.
-  static const int STR_U             =  16;  // After '\u' and 0-3 hex digits.
+  static const int STR_U             = 16;   // After '\u' and 0-3 hex digits.
   static const int STR_U_COUNT_SHIFT =  2;   // Hex digit count in bits 2-3.
   static const int STR_U_VALUE_SHIFT =  5;   // Hex digit value in bits 5+.
 
   // Partial states for keywords.
   static const int KWD_TYPE_MASK     = 12;
-  static const int KWD_TYPE_SHIFT    = 2;
-  static const int KWD_NULL          = 0;  // Prefix of "null" seen.
-  static const int KWD_TRUE          = 4;  // Prefix of "true" seen.
-  static const int KWD_FALSE         = 8;  // Prefix of "false" seen.
-  static const int KWD_COUNT_SHIFT   = 4;  // Prefix length in bits 4+.
+  static const int KWD_TYPE_SHIFT    =  2;
+  static const int KWD_NULL          =  0;  // Prefix of "null" seen.
+  static const int KWD_TRUE          =  4;  // Prefix of "true" seen.
+  static const int KWD_FALSE         =  8;  // Prefix of "false" seen.
+  static const int KWD_COUNT_SHIFT   =  4;  // Prefix length in bits 4+.
 
   // Mask used to mask off two lower bits.
-  static const int TWO_BIT_MASK = 3;
+  static const int TWO_BIT_MASK      = 3;
 
   final _JsonListener listener;
 
   // The current parsing state.
   int state = STATE_INITIAL;
   List<int> states = <int>[];
 
   /**
    * Stores tokenizer state between chunks.
    *
@@ skipping 126 matching lines @@
    * In practive, [index] will be no smaller than the `start` argument passed
    * to [parse].
    */
   int getChar(int index);
 
   /**
    * Copy ASCII characters from start to end of chunk into a list.
    *
    * Used for number buffer (always copies ASCII, so encoding is not important).
    */
-  void copyCharsToList(int start, int end, List<int> target);
+  void copyCharsToList(int start, int end, List<int> target, int offset);
 
   /**
    * Build a string using input code units.
    *
    * Creates a string buffer and enables adding characters and slices
    * to that buffer.
    * The buffer is stored in the [buffer] field. If the string is unterminated,
    * the same buffer is used to continue parsing in the next chunk.
    */
   void beginString();
@@ skipping 57 matching lines @@
    * Create a _NumberBuffer containing the digits from [start] to [chunkEnd].
    *
    * This creates a number buffer and initializes it with the part of the
    * number literal ending the current chunk
    */
   void createNumberBuffer(int start) {
     assert(start >= 0);
     assert(start < chunkEnd);
     int length = chunkEnd - start;
     var buffer = new _NumberBuffer(length);
-    copyCharsToList(start, chunkEnd, buffer.list);
+    copyCharsToList(start, chunkEnd, buffer.list, 0);
     buffer.length = length;
     return buffer;
   }
 
   /**
    * Continues parsing a partial value.
    */
   int parsePartial(int position) {
     if (position == chunkEnd) return position;
     int partialState = this.partialState;
@@ skipping 187 matching lines @@
    */
   void parse(int position) {
     int length = chunkEnd;
     if (partialState != NO_PARTIAL) {
       position = parsePartial(position);
       if (position == length) return;
     }
     int state = this.state;
     while (position < length) {
       int char = getChar(position);
-      if (char == null) {
-        print("[[[$chunk]]] - $position - ${chunk.runtimeType}");
-      }
       switch (char) {
         case SPACE:
         case CARRIAGE_RETURN:
         case NEWLINE:
         case TAB:
           position++;
           break;
         case QUOTE:
           if ((state & ALLOW_STRING_MASK) != 0) return fail(position);
           state |= VALUE_READ_BITS;
@@ skipping 78 matching lines @@
           position = parseNumber(char, position);
           break;
       }
     }
     this.state = state;
   }
 
   /**
    * Parses a "true" literal starting at [position].
    *
-   * [:source[position]:] must be "t".
+   * The character `source[position]` must be "t".
    */
   int parseTrue(int position) {
     assert(getChar(position) == CHAR_t);
     if (chunkEnd < position + 4) {
       return parseKeywordPrefix(position, "true", KWD_TRUE);
     }
     if (getChar(position + 1) != CHAR_r ||
         getChar(position + 2) != CHAR_u ||
         getChar(position + 3) != CHAR_e) {
       return fail(position);
     }
     listener.handleBool(true);
     return position + 4;
   }
 
   /**
    * Parses a "false" literal starting at [position].
    *
-   * [:source[position]:] must be "f".
+   * The character `source[position]` must be "f".
    */
   int parseFalse(int position) {
     assert(getChar(position) == CHAR_f);
     if (chunkEnd < position + 5) {
       return parseKeywordPrefix(position, "false", KWD_FALSE);
     }
     if (getChar(position + 1) != CHAR_a ||
         getChar(position + 2) != CHAR_l ||
         getChar(position + 3) != CHAR_s ||
         getChar(position + 4) != CHAR_e) {
       return fail(position);
     }
     listener.handleBool(false);
     return position + 5;
   }
 
   /**
    * Parses a "null" literal starting at [position].
    *
-   * [:source[position]:] must be "n".
+   * The character `source[position]` must be "n".
    */
   int parseNull(int position) {
     assert(getChar(position) == CHAR_n);
     if (chunkEnd < position + 4) {
       return parseKeywordPrefix(position, "null", KWD_NULL);
     }
     if (getChar(position + 1) != CHAR_u ||
         getChar(position + 2) != CHAR_l ||
         getChar(position + 3) != CHAR_l) {
       return fail(position);
@@ skipping 39 matching lines @@
         beginString();
         int sliceEnd = position - 1;
         if (start < sliceEnd) addSliceToString(start, sliceEnd);
         return parseStringToBuffer(sliceEnd);
       }
       if (char == QUOTE) {
         listener.handleString(getString(start, position - 1, bits));
         return position;
       }
       if (char < SPACE) {
-        fail(position - 1, "Control character in string");
+        return fail(position - 1, "Control character in string");
       }
     }
     beginString();
     if (start < end) addSliceToString(start, end);
     return chunkString(STR_PLAIN);
   }
 
   /**
    * Sets up a partial string state.
    *
@@ skipping 38 matching lines @@
     while (true) {
       if (position == end) {
         if (position > start) {
           addSliceToString(start, position);
         }
         return chunkString(STR_PLAIN);
       }
       int char = getChar(position++);
       if (char > BACKSLASH) continue;
       if (char < SPACE) {
-        fail(position - 1);  // Control character in string.
-        return;
+        return fail(position - 1);  // Control character in string.
       }
       if (char == QUOTE) {
         int quotePosition = position - 1;
         if (quotePosition > start) {
           addSliceToString(start, quotePosition);
         }
         listener.handleString(endString());
         return position;
       }
       if (char != BACKSLASH) {
@@ skipping 90 matching lines @@
     int end = chunkEnd;
     addNumberChunk(buffer, start, end, _NumberBuffer.kDefaultOverhead);
     this.buffer = buffer;
     this.partialState = PARTIAL_NUMERAL | state;
     return end;
   }
 
   int finishChunkNumber(int state, int start, int end, _NumberBuffer buffer) {
     if (state == NUM_ZERO) {
       listener.handleNumber(0);
-      return;
+      return end;
     }
     if (end > start) {
       addNumberChunk(buffer, start, end, 0);
     }
     if (state == NUM_DIGIT) {
       listener.handleNumber(buffer.parseInt());
     } else if (state == NUM_DOT_DIGIT || state == NUM_E_DIGIT) {
       listener.handleNumber(buffer.parseDouble());
     } else {
       fail(chunkEnd, "Unterminated number literal");
     }
     return end;
   }
 
   int parseNumber(int char, int position) {
     // Also called on any unexpected character.
     // Format:
     //  '-'?('0'|[1-9][0-9]*)('.'[0-9]+)?([eE][+-]?[0-9]+)?
     int start = position;
     int length = chunkEnd;
     // Collects an int value while parsing. Used for both an integer literal,
     // an the exponent part of a double literal.
     int intValue = 0;
     double doubleValue = 0.0; // Collect double value while parsing.
     int sign = 1;
     bool isDouble = false;
     // Break this block when the end of the number literal is reached.
     // At that time, position points to the next character, and isDouble
     // is set if the literal contains a decimal point or an exponential.
-    parsing: {
-      if (char == MINUS) {
-        sign = -1;
+    if (char == MINUS) {
+      sign = -1;
+      position++;
+      if (position == length) return beginChunkNumber(NUM_SIGN, start);
+      char = getChar(position);
+    }
+    int digit = char ^ CHAR_0;
+    if (digit > 9) {
+      if (sign < 0) {
+        fail(position, "Missing expected digit");
+      } else {
+        // If it doesn't even start out as a numeral.
+        fail(position, "Unexpected character");
+      }
+    }
+    if (digit == 0) {
+      position++;
+      if (position == length) return beginChunkNumber(NUM_ZERO, start);
+      char = getChar(position);
+      digit = char ^ CHAR_0;
+      // If starting with zero, next character must not be digit.
+      if (digit <= 9) fail(position);
+    } else {
+      do {
+        intValue = 10 * intValue + digit;
         position++;
-        if (position == length) return beginChunkNumber(NUM_SIGN, start);
+        if (position == length) return beginChunkNumber(NUM_DIGIT, start);
+        char = getChar(position);
+        digit = char ^ CHAR_0;
+      } while (digit <= 9);
+    }
+    if (char == DECIMALPOINT) {
+      isDouble = true;
+      doubleValue = intValue.toDouble();
+      intValue = 0;
+      position++;
+      if (position == length) return beginChunkNumber(NUM_DOT, start);
+      char = getChar(position);
+      digit = char ^ CHAR_0;
+      if (digit > 9) fail(position);
+      do {
+        doubleValue = 10.0 * doubleValue + digit;
+        intValue -= 1;
+        position++;
+        if (position == length) return beginChunkNumber(NUM_DOT_DIGIT, start);
+        char = getChar(position);
+        digit = char ^ CHAR_0;
+      } while (digit <= 9);
+    }
+    if ((char | 0x20) == CHAR_e) {
+      if (!isDouble) {
+        doubleValue = intValue.toDouble();
+        intValue = 0;
+        isDouble = true;
+      }
+      position++;
+      if (position == length) return beginChunkNumber(NUM_E, start);
+      char = getChar(position);
+      int expSign = 1;
+      int exponent = 0;
+      if (char == PLUS || char == MINUS) {
+        expSign = 0x2C - char;  // -1 for MINUS, +1 for PLUS
+        position++;
+        if (position == length) return beginChunkNumber(NUM_E_SIGN, start);
         char = getChar(position);
       }
-      int digit = char ^ CHAR_0;
+      digit = char ^ CHAR_0;
       if (digit > 9) {
-        if (sign < 0) {
-          fail(position, "Missing expected digit");
-        } else {
-          // If it doesn't even start out as a numeral.
-          fail(position, "Unexpected character");
-        }
+        fail(position, "Missing expected digit");
       }
-      if (digit == 0) {
+      do {
+        exponent = 10 * exponent + digit;
         position++;
-        if (position == length) return beginChunkNumber(NUM_ZERO, start);
+        if (position == length) return beginChunkNumber(NUM_E_DIGIT, start);
         char = getChar(position);
         digit = char ^ CHAR_0;
-        // If starting with zero, next character must not be digit.
-        if (digit <= 9) fail(position);
-      } else {
-        do {
-          intValue = 10 * intValue + digit;
-          position++;
-          if (position == length) return beginChunkNumber(NUM_DIGIT, start);
-          char = getChar(position);
-          digit = char ^ CHAR_0;
-        } while (digit <= 9);
-      }
-      if (char == DECIMALPOINT) {
-        isDouble = true;
-        doubleValue = intValue.toDouble();
-        intValue = 0;
-        position++;
-        if (position == length) return beginChunkNumber(NUM_DOT, start);
-        char = getChar(position);
-        digit = char ^ CHAR_0;
-        if (digit > 9) fail(position);
-        do {
-          doubleValue = 10.0 * doubleValue + digit;
-          intValue -= 1;
-          position++;
-          if (position == length) return beginChunkNumber(NUM_DOT_DIGIT, start);
-          char = getChar(position);
-          digit = char ^ CHAR_0;
-        } while (digit <= 9);
-      }
-      if ((char | 0x20) == CHAR_e) {
-        if (!isDouble) {
-          doubleValue = intValue.toDouble();
-          intValue = 0;
-          isDouble = true;
-        }
-        position++;
-        if (position == length) return beginChunkNumber(NUM_E, start);
-        char = getChar(position);
-        int expSign = 1;
-        int exponent = 0;
-        if (char == PLUS || char == MINUS) {
-          expSign = 0x2C - char;  // -1 for MINUS, +1 for PLUS
-          position++;
-          if (position == length) return beginChunkNumber(NUM_E_SIGN, start);
-          char = getChar(position);
-        }
-        digit = char ^ CHAR_0;
-        if (digit > 9) {
-          fail(position, "Missing expected digit");
-        }
-        do {
-          exponent = 10 * exponent + digit;
-          position++;
-          if (position == length) return beginChunkNumber(NUM_E_DIGIT, start);
-          char = getChar(position);
-          digit = char ^ CHAR_0;
-        } while (digit <= 9);
-        intValue += expSign * exponent;
-      }
+      } while (digit <= 9);
+      intValue += expSign * exponent;
     }
     if (!isDouble) {
       listener.handleNumber(sign * intValue);
       return position;
     }
     // Double values at or above this value (2 ** 53) may have lost precission.
     // Only trust results that are below this value.
     const double maxExactDouble = 9007199254740992.0;
     if (doubleValue < maxExactDouble) {
       int exponent = intValue;
@@ skipping 13 matching lines @@
         }
       }
     }
     // If the value is outside the range +/-maxExactDouble or
     // exponent is outside the range +/-22, then we can't trust simple double
     // arithmetic to get the exact result, so we use the system double parsing.
     listener.handleNumber(parseDouble(start, position));
     return position;
   }
 
-  int fail(int position, [String message]) {
+  fail(int position, [String message]) {
     if (message == null) {
       message = "Unexpected character";
       if (position == chunkEnd) message = "Unexpected end of input";
     }
     throw new FormatException(message, chunk, position);
   }
 }
 
 /**
  * Chunked JSON parser that parses [String] chunks.
@@ skipping 433 matching lines @@
     _parser.parse(start);
   }
 
   void close() {
     _parser.close();
     var decoded = _parser.result;
     _sink.add(decoded);
     _sink.close();
   }
 }