Integrate the Irregexp Regular Expression Engine.

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,
                                            [int start = 0, int end]) {
     return _StringBase.createFromCharCodes(charCodes, start, end);
   }
 
@@ skipping 721 matching lines @@
       native "OneByteString_splitWithCharCode";
 
   List<String> split(Pattern pattern) {
     if ((ClassID.getID(pattern) == ClassID.cidOneByteString) &&
         (pattern.length == 1)) {
       return _splitWithCharCode(pattern.codeUnitAt(0));
     }
     return super.split(pattern);
   }
 
+  // The codeUnitsAt family of functions is inlined to an unchecked
+  // LoadCodeUnitsInstr, therefore `this` must be a valid string, and `index`
+  // must be in bounds.
+  int _oneCodeUnitAt(int index) => _codeUnitsAt(index, 1);
+  int _twoCodeUnitsAt(int index) => _codeUnitsAt(index, 2);
+  int _fourCodeUnitsAt(int index) => _codeUnitsAt(index, 4);
+
+  // Loads up to 4 code units into a single integer.
+  int _codeUnitsAt(int index, int count) {
+    assert(index >= 0);
+    assert(index + count - 1 < this.length);
+    assert(0 < count && count <= 4);
+
+    int codeUnits = 0;
+    for (int i = 0; i < count; i++) {
+      codeUnits |= this.codeUnitAt(index + i) << (i * 8);

[Ivan Posva, 2014/10/31 07:32:37]

This looks pretty endian specific to me. No?

[zerny-google, 2014/10/31 11:54:26]

Well spotted. The irregexp code works despite this because we have no big-endian
systems that use this code-unit packing (mips does not support unaligned reads).

After some discussion with Florian, we have decided to avoid this dart code and
instead make it native and generate IR instructions instead. The endian issue
remains however between the current C++ code and the assembly code. I'll either
fix that or assert that packing is not used on big-endian systems.

+    }
+
+    return codeUnits;
+  }
+
   // All element of 'strings' must be OneByteStrings.
   static _concatAll(List<String> strings, int totalLength) {
     // TODO(srdjan): Improve code below and raise or eliminate the limit.
     if (totalLength > 128) {
       // Native is quicker.
       return _StringBase._concatRangeNative(strings, 0, strings.length);
     }
     final res = _OneByteString._allocate(totalLength);
     final stringsLength = strings.length;
     int rIx = 0;
@@ skipping 244 matching lines @@
         "_TwoByteString can only be allocated by the VM");
   }
 
   bool _isWhitespace(int codeUnit) {
     return _StringBase._isTwoByteWhitespace(codeUnit);
   }
 
   bool operator ==(Object other) {
     return super == other;
   }
+
+  int _oneCodeUnitAt(int index) => _codeUnitsAt(index, 1);
+  int _twoCodeUnitsAt(int index) => _codeUnitsAt(index, 2);
+
+  // Loads up to 2 code units into a single integer.
+  int _codeUnitsAt(int index, int count) {
+    assert(index >= 0);
+    assert(index + count - 1 < this.length);
+    assert(0 < count && count <= 2);
+
+    int codeUnits = 0;
+    for (int i = 0; i < count; i++) {
+      codeUnits |= this.codeUnitAt(index + i) << (i * 16);

[Ivan Posva, 2014/10/31 07:32:37]

ditto.

+    }
+
+    return codeUnits;
+  }
 }
 
 
 class _ExternalOneByteString extends _StringBase implements String {
   factory _ExternalOneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_ExternalOneByteString can only be allocated by the VM");
   }
 
   bool _isWhitespace(int codeUnit) {
@@ skipping 59 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);
 }