Support replaceAll for regexps.

frog/lib/corelib_impl.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("dart:coreimpl");
 
 #source("../../corelib/src/implementation/dual_pivot_quicksort.dart");
 #source("../../corelib/src/implementation/duration_implementation.dart");
 #source("../../corelib/src/implementation/exceptions.dart");
 #source("../../corelib/src/implementation/future_implementation.dart");
@@ skipping 261 matching lines @@
   int get _lastIndex() native "return this.re.lastIndex;";
 
   bool hasMatch(String str) native "return this.re.test(str);";
 
   String stringMatch(String str) {
     var match = firstMatch(str);
     return match === null ? null : match.group(0);
   }
 
   Iterable<Match> allMatches(String str) => new _AllMatchesIterable(this, str);
+
+  /**
+   * Returns a new RegExp with the same pattern as this one and with the
+   * "global" flag set. This allows us to match this RegExp against a string
+   * multiple times, to support things like [allMatches] and
+   * [String.replaceAll].
+   *
+   * Note that the returned RegExp disobeys the normal API in that it maintains

[Jennifer Messerly, 2011/12/14 20:36:56]

nice refactoring :)

out of curiosity--what does it mean that the returned RegExp disobeys the normal
api? Is it a bug we should fix, or an implementation note?

[nweiz, 2011/12/14 21:39:21]

It's an implementation note. When a JS regexp has the "g" flag set and it's run
against the same string multiple times, it searches further into the string each
time. This is intended, and it's how we implement AllMatchesIterator.

+   * state about the location of the last match.
+   */
+  JSSyntaxRegExp get _global() => new JSSyntaxRegExp._create(pattern,
+      'g' + (multiLine ? 'm' : '') + (ignoreCase ? 'i' : ''));
 }
 
 class MatchImplementation implements Match {
   const MatchImplementation(
       String this.pattern,
       String this.str,
       int this._start,
       int this._end,
       List<String> this._groups);
 
@@ skipping 24 matching lines @@
 
   Iterator<Match> iterator() => new _AllMatchesIterator(_re, _str);
 }
 
 class _AllMatchesIterator implements Iterator<Match> {
   final RegExp _re;
   final String _str;
   Match _next;
   bool _done;
 
-  _AllMatchesIterator(RegExp re, String this._str)
-    : _done = false,
-      _re = new JSSyntaxRegExp._create(re.pattern,
-        // Create a new RegExp with the "global" flag set so we can use it to
-        // iterate over multiple matches. Note that this will make the RegExp
-        // disobey the normal API.
-        'g' + (re.multiLine ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
+  _AllMatchesIterator(JSSyntaxRegExp re, String this._str)
+    : _done = false, _re = re._global;
 
   Match next() {
     if (!hasNext()) {
       throw const NoMoreElementsException();
     }
 
     // _next is set by #hasNext
     var next = _next;
     _next = null;
     return next;
@@ skipping 84 matching lines @@
     } else if (isNaN()) {
       if (other.isNaN()) {
         return 0;
       }
       return 1;
     } else {
       return -1;
     }
   }
 }