Avoid unnecessary copying when parsing doubles.

runtime/lib/string_patch.dart

 // Copyright (c) 2012, 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.
 
 patch class String {
   /* patch */ factory String.fromCharCodes(Iterable<int> charCodes) {
     return _StringBase.createFromCharCodes(charCodes);
   }
 
   /* patch */ factory String.fromCharCode(int charCode) {
@@ skipping 110 matching lines @@
     }
     final len = this.length;
     for (int i = 0; i < len; i++) {
       if (this.codeUnitAt(i) != other.codeUnitAt(i)) {
         return false;
       }
     }
     return true;
   }
 
-
   int compareTo(String other) {
     int thisLength = this.length;
     int otherLength = other.length;
     int len = (thisLength < otherLength) ? thisLength : otherLength;
     for (int i = 0; i < len; i++) {
       int thisCodePoint = this.codeUnitAt(i);
       int otherCodePoint = other.codeUnitAt(i);
       if (thisCodePoint < otherCodePoint) {
         return -1;
       }
@@ skipping 132 matching lines @@
   // 1680          ; White_Space # Zs       OGHAM SPACE MARK
   // 180E          ; White_Space # Zs       MONGOLIAN VOWEL SEPARATOR
   // 2000..200A    ; White_Space # Zs       EN QUAD..HAIR SPACE
   // 2028          ; White_Space # Zl       LINE SEPARATOR
   // 2029          ; White_Space # Zp       PARAGRAPH SEPARATOR
   // 202F          ; White_Space # Zs       NARROW NO-BREAK SPACE
   // 205F          ; White_Space # Zs       MEDIUM MATHEMATICAL SPACE
   // 3000          ; White_Space # Zs       IDEOGRAPHIC SPACE
   //
   // BOM: 0xFEFF
   static bool _isTwoByteWhitespace(int codePoint) {

[Lasse Reichstein Nielsen, 2014/07/04 06:46:01]

The "codePoint" argument is really a "codeUnit". I'll rename it for clarity.

     if (codePoint < 256) return _isOneByteWhitespace(codePoint);
     return (codePoint == 0x1680) ||
         (codePoint == 0x180E) ||
         ((0x2000 <= codePoint) && (codePoint <= 0x200A)) ||
         (codePoint == 0x2028) ||
         (codePoint == 0x2029) ||
         (codePoint == 0x202F) ||
         (codePoint == 0x205F) ||
         (codePoint == 0x3000) ||
         (codePoint == 0xFEFF);
   }
 
-  String trim() {
+  int _firstNonWhitespace() {
     final len = this.length;
     int first = 0;
     for (; first < len; first++) {
       if (!_isWhitespace(this.codeUnitAt(first))) {
         break;
       }
     }
+    return first;
+  }
+
+  int _lastNonWhitespace() {
+    int last = this.length - 1;
+    for (; last >= 0; last--) {

[Ivan Posva, 2014/07/03 19:44:14]

I know this was used in trim before, but I think it predates the switch away
from 4-byte string encodings. Is it legal to scan backwards for white space with
the current use of surrogate pairs?

[Lasse Reichstein Nielsen, 2014/07/04 06:46:01]

Yes. All Unicode white-space are in the basic multilingual plane, so no
surrogate is part of a white-space character.

+      if (!_isWhitespace(this.codeUnitAt(last))) {
+        break;
+      }
+    }
+    return last;
+  }
+
+  String trim() {
+    final len = this.length;
+    int first = _firstNonWhitespace();
     if (len == first) {
       // String contains only whitespaces.
       return "";
     }
-    int last = len - 1;
-    for (; last >= first; last--) {
-      if (!_isWhitespace(this.codeUnitAt(last))) {
-        break;
-      }
-    }
-    if ((first == 0) && (last == (len - 1))) {
+    int last = _lastNonWhitespace() + 1;
+    if ((first == 0) && (last == len)) {
       // Returns this string since it does not have leading or trailing
       // whitespaces.
       return this;
     }
-    return _substringUnchecked(first, last + 1);
+    return _substringUnchecked(first, last);
   }
 
   String trimLeft() {
     final len = this.length;
     int first = 0;
     for (; first < len; first++) {
       if (!_isWhitespace(this.codeUnitAt(first))) {
         break;
       }
     }
@@ skipping 659 matching lines @@
 class _CodeUnits extends Object with ListMixin<int>,
                                      UnmodifiableListMixin<int> {
   /** The string that this is the code units of. */
   String _string;
 
   _CodeUnits(this._string);
 
   int get length => _string.length;
   int operator[](int i) => _string.codeUnitAt(i);
 }