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 373 matching lines @@
       fail(position);
     }
     listener.handleNull();
     return position + 4;
   }
 
   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");
-      }
-      char = source.codeUnitAt(position);
-      if (char == QUOTE) {
-        listener.handleString(source.substring(start, position));
-        return position + 1;
-      }
-      if (char < SPACE) {
-        fail(position, "Control character in string");
+    while (position < source.length) {
+      int char = source.codeUnitAt(position);
+      if (char <= BACKSLASH) {  // BACKSLASH is larger than QUOTE.

[Søren Gjesse, 2014/03/24 08:33:57]

and SPACE :-)

[Lasse Reichstein Nielsen, 2014/03/24 12:13:49]

SPACE is *obviously* smaller than anything :)
But added to comment.

+        if (char == BACKSLASH) {
+          return parseStringWithEscapes(start, position);
+        }
+        if (char == QUOTE) {
+          listener.handleString(source.substring(start, position));
+          return position + 1;
+        }
+        if (char < SPACE) {
+          fail(position, "Control character in string");
+        }
       }
       position++;
-    } while (char != BACKSLASH);
+    }
+    fail(start - 1, "Unterminated string");
+  }
+
+  int parseStringWithEscapes(string, position) {

[Lasse Reichstein Nielsen, 2014/03/07 10:40:27]

string -> start.

[Lasse Reichstein Nielsen, 2014/03/24 08:30:54]

string -> source even.

     // Backslash escape detected. Collect character codes for rest of string.
     int firstEscape = position - 1;
     List<int> chars = <int>[];
     while (true) {
       if (position == source.length) {
         fail(start - 1, "Unterminated string");
       }
       char = source.codeUnitAt(position);
       switch (char) {
         case CHAR_b: char = BACKSPACE; break;
@@ skipping 46 matching lines @@
           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));

[Søren Gjesse, 2014/03/24 08:33:57]

There is no simpler way to create the double now you have disected all the
elements?

[Lasse Reichstein Nielsen, 2014/03/24 12:13:49]

In simple cases, there probably is.
Parsing a double is ... complex. It's easy to get it wrong.

+    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);
 }