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)
+      : 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");
+    if (!_isToken(NUMBER_LITERAL)) _error('Expected number literal');
 
     final int startPos = position;
-    if (_isChar(MINUS)) position++;
-    if (_isChar(CHAR_0)) {
-      position++;
+    int char = _char();
+    if (char === MINUS) char = _nextChar();
+    if (char === CHAR_0) {
+      char = _nextChar();
     } else if (_isDigit()) {
-      position++;
-      while (_isDigit()) position++;
+      char = _nextChar();
+      while (_isDigit()) char = _nextChar();
     } else {
-      _error("Expected digit when parsing number");
+      _error('Expected digit when parsing number');
     }
 
     bool isInt = true;
-    if (_isChar(DOT)) {
-      position++;
+    if (char === DOT) {
+      char = _nextChar();
       if (_isDigit()) {
+        char = _nextChar();
         isInt = false;
-        while (_isDigit()) position++;
+        while (_isDigit()) char = _nextChar();
       } else {
-        position--;  // No digit, backtrack.
+        _error('Expected digit following comma');
       }
     }
 
-    if (_isChar(CHAR_E) || _isChar(CHAR_CAPITAL_E)) {
-      int backtrackTo = position;
-      position++;
-      if (_isChar(MINUS) || _isChar(PLUS)) position++;
+    if (char === CHAR_E || char === CHAR_CAPITAL_E) {
+      char = _nextChar();
+      if (char === MINUS || char === PLUS) position++;
       if (_isDigit()) {
-        position++;
+        char = _nextChar();

[Anton Muhin, 2012/04/28 09:30:35]

char might be either the code or false, is this intended?  And both _isDigit and
_nextChar fetch the char, do we want to do that?

[Anders Johnsen, 2012/04/28 09:35:56]

Nope, nice catch! :)

         isInt = false;
-        while (_isDigit()) position++;
+        while (_isDigit()) char = _nextChar();
       } else {
-        position = backtrackTo;  // No digit, backtrack.
+        _error('Expected digit following \'e\' or \'E\'');
       }
     }
 
     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) {
-      _error("Unexpected end of JSON stream");
+    if (position >= length) {
+      _error('Unexpected end of JSON stream');
     }
     return json.charCodeAt(position);
   }
 
+  int _nextChar() {
+    position++;
+    if (position >= length) return false;
+    return json.charCodeAt(position);
+  }
+
+
+  int _charNoError() {
+    if (position >= length) return 0;
+    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();
     }
   }
 }