Fix errors in the JSON parser.

lib/json/json.dart

 // Copyright (c) 2011, 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.
 
 #library("json");
 
 // Pure Dart implementation of JSON protocol.
 
 /**
  * Utility class to parse JSON and serialize objects to JSON.
@@ skipping 78 matching lines @@
 
   static final String NULL_STRING = "null";
   static final String TRUE_STRING = "true";
   static final String FALSE_STRING = "false";
 
 
   static parse(String json) {
     return new _JsonParser._internal(json)._parseToplevel();
   }
 
-  _JsonParser._internal(String json) : this.json = '${json} ' {
+  _JsonParser._internal(String json)

[Anton Muhin, 2012/04/28 09:09:24]

nit: ._internal(this.json) ?

[Anders Johnsen, 2012/04/28 09:28:26]

Not possible when extracting length in initializer list. :(

+      : json = json,
+        length = json.length {
     if (tokens !== null) return;
 
     // Use a list as jump-table, faster then switch and if.
     tokens = new List<int>(LAST_ASCII + 1);
     tokens[TAB] = WHITESPACE;
     tokens[NEW_LINE] = WHITESPACE;
     tokens[CARRIAGE_RETURN] = WHITESPACE;
     tokens[SPACE] = WHITESPACE;
     tokens[CHAR_0] = NUMBER_LITERAL;
     tokens[CHAR_1] = NUMBER_LITERAL;
@@ skipping 104 matching lines @@
 
     List<int> charCodes = new List<int>();
     while (true) {
       int c = _char();
       if (c == QUOTE) {
         position++;
         break;
       }
       if (c == BACKSLASH) {
         position++;
-        if (position == json.length) {
+        if (position == length) {
           _error('\\ at the end of input');
         }
 
         switch (_char()) {
           case QUOTE:
             c = QUOTE;
             break;
           case BACKSLASH:
             c = BACKSLASH;
             break;
           case SLASH:
             c = SLASH;
             break;
           case CHAR_B:
             c = BACKSPACE;
             break;
           case CHAR_N:
             c = NEW_LINE;
             break;
           case CHAR_R:
             c = CARRIAGE_RETURN;
             break;
           case CHAR_F:
             c = FORM_FEED;
             break;
           case CHAR_T:
             c = TAB;
             break;
           case CHAR_U:
-            if (position + 5 > json.length) {
+            if (position + 5 > length) {
               _error('Invalid unicode esacape sequence');
             }
             final codeString = json.substring(position + 1, position + 5);
             try {
               c = Math.parseInt('0x${codeString}');
             } catch (var e) {
               _error('Invalid unicode esacape sequence');
             }
             position += 4;
             break;
           default:
             _error('Invalid esacape sequence in string literal');
         }
       }
       charCodes.add(c);
       position++;
     }
 
     return new String.fromCharCodes(charCodes);
   }
 
   num _parseNumber() {
     if (!_isToken(NUMBER_LITERAL)) _error("Expected number literal");
 
     final int startPos = position;
     if (_isChar(MINUS)) position++;

[Anton Muhin, 2012/04/28 09:09:24]

just an idea: maybe fetch char once with _char() and then do a dispatch?

int char = _char();
if (char == MINUS) { /* Rare case */ position++; char = _char9)) }
if (char == CHAR_0)
...

?

[Anders Johnsen, 2012/04/28 09:28:26]

Done.

     if (_isChar(CHAR_0)) {
       position++;
     } else if (_isDigit()) {
       position++;
       while (_isDigit()) position++;
     } else {
       _error("Expected digit when parsing number");
     }
 
     bool isInt = true;
     if (_isChar(DOT)) {
       position++;
       if (_isDigit()) {
+        position++;
         isInt = false;
         while (_isDigit()) position++;
       } else {
-        position--;  // No digit, backtrack.
+        _error("Expected digit following comma");

[Anton Muhin, 2012/04/28 09:09:24]

nit: single quotes

[Anton Muhin, 2012/04/28 09:09:24]

is it a correct thing, may we double check with JS if indeed 1. shouldn't be
parsable.  I just asking.  And if not, please, add a test (if absent)

[Anders Johnsen, 2012/04/28 09:28:26]

Done.

[Anders Johnsen, 2012/04/28 09:28:26]

There is not token in JSON that can follow a number and start with a '.', so I
think saying expected digit after '.' is better then saying invalid token to
'.'.

I test for the case of '3.a'.

       }
     }
 
     if (_isChar(CHAR_E) || _isChar(CHAR_CAPITAL_E)) {

[Anton Muhin, 2012/04/28 09:09:24]

ditto here: fetch char once and then do both checks.

[Anders Johnsen, 2012/04/28 09:28:26]

Done.

-      int backtrackTo = position;
       position++;
       if (_isChar(MINUS) || _isChar(PLUS)) position++;

[Anton Muhin, 2012/04/28 09:09:24]

ditto

[Anders Johnsen, 2012/04/28 09:28:26]

Done.

       if (_isDigit()) {
         position++;
         isInt = false;
         while (_isDigit()) position++;
       } else {
-        position = backtrackTo;  // No digit, backtrack.
+        _error("Expected digit following 'e' or 'E'");

[Anton Muhin, 2012/04/28 09:09:24]

ditto nit for ''

[Anders Johnsen, 2012/04/28 09:28:26]

Done.

       }
     }
 
     String number = json.substring(startPos, position);
     if (isInt) {
       return Math.parseInt(number);
     } else {
       return Math.parseDouble(number);
     }
   }
 
-  bool _isChar(int char) => _char() == char;
+  bool _isChar(int char) {
+    if (position >= length) return false;
+    return json.charCodeAt(position) == char;
+  }
 
   bool _isDigit() {
-    int char = _char();
+    if (position >= length) return false;
+    int char = json.charCodeAt(position);
     return char >= CHAR_0 && char <= CHAR_9;
   }
 
   bool _isToken(int tokenKind) => _token() == tokenKind;
 
   int _char() {
-    if (position >= json.length) {
+    if (position >= length) {
       _error("Unexpected end of JSON stream");
     }
     return json.charCodeAt(position);
   }
 
   int _token() {
     while (true) {
-      if (position >= json.length) return null;
+      if (position >= length) return null;
       int char = json.charCodeAt(position);
       int token = tokens[char];
       if (token === WHITESPACE) {
         position++;
         continue;
       }
-      if (token === null) _error("Invalid JSON token");
+      if (token === null) return 0;
       return token;
     }
   }
 
   void _error(String message) {
     throw message;
   }
 
   final String json;
+  final int length;
   int position = 0;
   static List<int> tokens;
 }
 
 // TODO: proper base class.
 class JsonUnsupportedObjectType {
   const JsonUnsupportedObjectType();
 }
 
 class JsonStringifier {
@@ skipping 141 matching lines @@
         });
         _sb.add('}');
         _seen.removeLast();
         return;
 
       default:
         throw const JsonUnsupportedObjectType();
     }
   }
 }