Optimize VM parsing of JSON String and number literals.

runtime/lib/convert_patch.dart

 // Copyright (c) 2013, 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:typed_data";
 
 // JSON conversion.
 
 patch _parseJson(String json, reviver(var key, var value)) {
   _BuildJsonListener listener;
@@ skipping 353 matching lines @@
     if (source.codeUnitAt(position + 1) != CHAR_a ||
         source.codeUnitAt(position + 2) != CHAR_l ||
         source.codeUnitAt(position + 3) != CHAR_s ||
         source.codeUnitAt(position + 4) != CHAR_e) {
       fail(position);
     }
     listener.handleBool(false);
     return position + 5;
   }
 
-  /** Parses a "null" literal starting at [position].
+  /**
+   * Parses a "null" literal starting at [position].
    *
    * [:source[position]:] must be "n".
    */
   int parseNull(int position) {
     assert(source.codeUnitAt(position) == CHAR_n);
     if (source.length < position + 4) fail(position, "Unexpected identifier");
     if (source.codeUnitAt(position + 1) != CHAR_u ||
         source.codeUnitAt(position + 2) != CHAR_l ||
         source.codeUnitAt(position + 3) != CHAR_l) {
       fail(position);
     }
     listener.handleNull();
     return position + 4;
   }
 
+  /**
+   * Parses a string value.
+   *
+   * Initial [position] is right after the initial quote.
+   * Returned position right after the final quote.
+   */
   int parseString(int position) {
     // Format: '"'([^\x00-\x1f\\\"]|'\\'[bfnrt/\\"])*'"'
     // Initial position is right after first '"'.
     int start = position;
-    int char;
-    do {
-      if (position == source.length) {
-        fail(start - 1, "Unterminated string");
+    while (position < source.length) {
+      int char = source.codeUnitAt(position++);
+      // BACKSLASH is larger than QUOTE and SPACE.
+      if (char > BACKSLASH) {
+        continue;
       }
-      char = source.codeUnitAt(position);
+      if (char == BACKSLASH) {
+        return parseStringWithEscapes(start, position - 1);
+      }
       if (char == QUOTE) {
-        listener.handleString(source.substring(start, position));
-        return position + 1;
+        listener.handleString(source.substring(start, position - 1));
+        return position;
       }
       if (char < SPACE) {
-        fail(position, "Control character in string");
+        fail(position - 1, "Control character in string");
       }
-      position++;
-    } while (char != BACKSLASH);
+    }
+    fail(start - 1, "Unterminated string");
+  }
+
+  int parseStringWithEscapes(start, position) {
     // Backslash escape detected. Collect character codes for rest of string.
-    int firstEscape = position - 1;
+    int firstEscape = position;
     List<int> chars = <int>[];
+    for (int i = start; i < firstEscape; i++) {
+      chars.add(source.codeUnitAt(i));
+    }
+    position++;
     while (true) {
       if (position == source.length) {
         fail(start - 1, "Unterminated string");
       }
-      char = source.codeUnitAt(position);
+      int char = source.codeUnitAt(position);
       switch (char) {
         case CHAR_b: char = BACKSPACE; break;
         case CHAR_f: char = FORM_FEED; break;
         case CHAR_n: char = NEWLINE; break;
         case CHAR_r: char = CARRIAGE_RETURN; break;
         case CHAR_t: char = TAB; break;
         case SLASH:
         case BACKSLASH:
         case QUOTE:
           break;
@@ skipping 24 matching lines @@
           if (char < SPACE) fail(position, "Control character in string");
           fail(position, "Unrecognized string escape");
       }
       do {
         chars.add(char);
         position++;
         if (position == source.length) fail(start - 1, "Unterminated string");
         char = source.codeUnitAt(position);
         if (char == QUOTE) {
           String result = new String.fromCharCodes(chars);
-          if (start < firstEscape) {
-            result = "${source.substring(start, firstEscape)}$result";
-          }
           listener.handleString(result);
           return position + 1;
         }
         if (char < SPACE) {
           fail(position, "Control character in string");
         }
       } while (char != BACKSLASH);
       position++;
     }
   }
 
-  int _handleLiteral(start, position, isDouble) {
-    String literal = source.substring(start, position);
-    // This correctly creates -0 for doubles.
-    num value = (isDouble ? double.parse(literal) : int.parse(literal));
-    listener.handleNumber(value);
-    return position;
-  }
-
   int parseNumber(int char, int position) {
     // Format:
     //  '-'?('0'|[1-9][0-9]*)('.'[0-9]+)?([eE][+-]?[0-9]+)?
     int start = position;
     int length = source.length;
+    int intValue = 0;  // Collect int value while parsing.
+    int intSign = 1;
     bool isDouble = false;
-    if (char == MINUS) {
-      position++;
-      if (position == length) fail(position, "Missing expected digit");
-      char = source.codeUnitAt(position);
-    }
-    if (char < CHAR_0 || char > CHAR_9) {
-      fail(position, "Missing expected digit");
-    }
-    if (char == CHAR_0) {
-      position++;
-      if (position == length) return _handleLiteral(start, position, false);
-      char = source.codeUnitAt(position);
-      if (CHAR_0 <= char && char <= CHAR_9) {
-        fail(position);
-      }
-    } else {
-      do {
-        position++;
-        if (position == length) return _handleLiteral(start, position, false);
-        char = source.codeUnitAt(position);
-      } while (CHAR_0 <= char && char <= CHAR_9);
-    }
-    if (char == DECIMALPOINT) {
-      isDouble = true;
-      position++;
-      if (position == length) fail(position, "Missing expected digit");
-      char = source.codeUnitAt(position);
-      if (char < CHAR_0 || char > CHAR_9) fail(position);
-      do {
-        position++;
-        if (position == length) return _handleLiteral(start, position, true);
-        char = source.codeUnitAt(position);
-      } while (CHAR_0 <= char && char <= CHAR_9);
-    }
-    if (char == CHAR_e || char == CHAR_E) {
-      isDouble = true;
-      position++;
-      if (position == length) fail(position, "Missing expected digit");
-      char = source.codeUnitAt(position);
-      if (char == PLUS || char == MINUS) {
+    // 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) {
+        intSign = -1;
         position++;
         if (position == length) fail(position, "Missing expected digit");
         char = source.codeUnitAt(position);
       }
       if (char < CHAR_0 || char > CHAR_9) {
         fail(position, "Missing expected digit");
       }
-      do {
+      if (char == CHAR_0) {
         position++;
-        if (position == length) return _handleLiteral(start, position, true);
+        if (position == length) break parsing;
         char = source.codeUnitAt(position);
-      } while (CHAR_0 <= char && char <= CHAR_9);
+        if (CHAR_0 <= char && char <= CHAR_9) {
+          fail(position);
+        }
+      } else {
+        do {
+          intValue = intValue * 10 + (char - CHAR_0);
+          position++;
+          if (position == length) break parsing;
+          char = source.codeUnitAt(position);
+        } while (CHAR_0 <= char && char <= CHAR_9);
+      }
+      if (char == DECIMALPOINT) {
+        isDouble = true;
+        position++;
+        if (position == length) fail(position, "Missing expected digit");
+        char = source.codeUnitAt(position);
+        if (char < CHAR_0 || char > CHAR_9) fail(position);
+        do {
+          position++;
+          if (position == length) break parsing;
+          char = source.codeUnitAt(position);
+        } while (CHAR_0 <= char && char <= CHAR_9);
+      }
+      if (char == CHAR_e || char == CHAR_E) {
+        isDouble = true;
+        position++;
+        if (position == length) fail(position, "Missing expected digit");
+        char = source.codeUnitAt(position);
+        if (char == PLUS || char == MINUS) {
+          position++;
+          if (position == length) fail(position, "Missing expected digit");
+          char = source.codeUnitAt(position);
+        }
+        if (char < CHAR_0 || char > CHAR_9) {
+          fail(position, "Missing expected digit");
+        }
+        do {
+          position++;
+          if (position == length) break parsing;
+          char = source.codeUnitAt(position);
+        } while (CHAR_0 <= char && char <= CHAR_9);
+      }
     }
-    return _handleLiteral(start, position, isDouble);
+    if (!isDouble) {
+      listener.handleNumber(intSign * intValue);
+      return position;
+    }
+    // Consider whether we can have an int/double.parse that works on part of
+    // a string, to avoid creating the substring.
+    String literal = source.substring(start, position);
+    // This correctly creates -0.0 for doubles.
+    listener.handleNumber(double.parse(literal));
+    return position;
   }
 
   void fail(int position, [String message]) {
     if (message == null) message = "Unexpected character";
     listener.fail(source, position, message);
     // If the listener didn't throw, do it here.
     String slice;
     int sliceEnd = position + 20;
     if (sliceEnd > source.length) {
       slice = "'${source.substring(position)}'";
     } else {
       slice = "'${source.substring(position, sliceEnd)}...'";
     }
     throw new FormatException("Unexpected character at $position: $slice");
   }
 }
 
 // UTF-8 conversion.
 
 patch class _Utf8Encoder {
   /* patch */ static List<int> _createBuffer(int size) => new Uint8List(size);
 }