Add 1-element caches to RegExp.exec and String.replace. We...

src/regexp-delay.js

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 122 matching lines @@
     DoConstructRegExp(this, pattern, flags, false);
   }
 }
 
 
 function DoRegExpExec(regexp, string, index) {
   return %_RegExpExec(regexp, string, index, lastMatchInfo);
 }
 
 
+var cachedRegexp;
+var cachedSubject;
+var cachedLastIndex;
+var cachedAnswer;
+
+
+function CloneRegexpAnswer(array) {
+  var len = array.length;
+  var answer = new $Array(len);
+  for (var i = 0; i < len; i++) {
+    answer[i] = array[i];
+  }
+  answer.index = array.index;
+  answer.input = array.input;
+  return answer;
+}
+
+
 function RegExpExec(string) {
+  if (cachedLastIndex === this.lastIndex &&

[Lasse Reichstein, 2010/03/10 08:53:24]

lastIndex is only relevant if the regexp is global.

+      cachedRegexp === this &&

[Lasse Reichstein, 2010/03/10 08:53:24]

Checking the regexp itself is unsafe. Its behavior can be overwritten by
RegExp.prototype.compile.
You should check the underlying FixedArray instead (which is good, because
that's what the RegExp compile cache reuses too).

+      cachedSubject === string) {

[Mads Ager (chromium), 2010/03/10 08:12:22]

I would use %_ObjectEquals for the string and regexp comparisons here.

+    var last = cachedAnswer;
+    if (last == null) {

[Lasse Reichstein, 2010/03/10 08:53:24]

Use ===?

+      return last;
+    } else {
+      return CloneRegexpAnswer(last);
+    }
+  }
+
   if (!IS_REGEXP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
                         ['RegExp.prototype.exec', this]);
   }
   if (%_ArgumentsLength() == 0) {
     var regExpInput = LAST_INPUT(lastMatchInfo);
     if (IS_UNDEFINED(regExpInput)) {
       throw MakeError('no_input_to_regexp', [this]);
     }
     string = regExpInput;
   }
   var s;
   if (IS_STRING(string)) {
     s = string;
   } else {
     s = ToString(string);
   }
   var lastIndex = this.lastIndex;
+
   var i = this.global ? TO_INTEGER(lastIndex) : 0;
 
   if (i < 0 || i > s.length) {
     this.lastIndex = 0;
     return null;
   }
 
   %_Log('regexp', 'regexp-exec,%0r,%1S,%2i', [this, s, lastIndex]);
   // matchIndices is either null or the lastMatchInfo array.
   var matchIndices = %_RegExpExec(this, s, i, lastMatchInfo);
 
   if (matchIndices == null) {
     if (this.global) this.lastIndex = 0;
-    return matchIndices; // no match
+    cachedLastIndex = lastIndex;
+    cachedRegexp = this;
+    cachedSubject = s;
+    cachedAnswer = matchIndices;  // Null.
+    return matchIndices;        // No match.
   }
 
   var numResults = NUMBER_OF_CAPTURES(lastMatchInfo) >> 1;
   var result;
   if (numResults === 1) {
     var matchStart = lastMatchInfo[CAPTURE(0)];
     var matchEnd = lastMatchInfo[CAPTURE(1)];
     result = [SubString(s, matchStart, matchEnd)];
   } else {
     result = new $Array(numResults);
     for (var i = 0; i < numResults; i++) {
       var matchStart = lastMatchInfo[CAPTURE(i << 1)];
       var matchEnd = lastMatchInfo[CAPTURE((i << 1) + 1)];
       if (matchStart != -1 && matchEnd != -1) {
         result[i] = SubString(s, matchStart, matchEnd);
       } else {
         // Make sure the element is present. Avoid reading the undefined
         // property from the global object since this may change.
         result[i] = void 0;
       }
     }
   }
 
-  if (this.global)
-    this.lastIndex = lastMatchInfo[CAPTURE1];
   result.index = lastMatchInfo[CAPTURE0];
   result.input = s;
-  return result;
+  if (this.global) {
+    this.lastIndex = lastMatchInfo[CAPTURE1];
+    return result;
+  } else {
+    cachedRegexp = this;
+    cachedSubject = s;
+    cachedLastIndex = lastIndex;
+    cachedAnswer = result;
+    return CloneRegexpAnswer(result);
+  }
 }
 
 
 // Section 15.10.6.3 doesn't actually make sense, but the intention seems to be
 // that test is defined in terms of String.prototype.exec. However, it probably
 // means the original value of String.prototype.exec, which is what everybody
 // else implements.
 function RegExpTest(string) {
   if (!IS_REGEXP(this)) {
     throw MakeTypeError('incompatible_method_receiver',
@@ skipping 194 matching lines @@
   %DefineAccessor($RegExp, "$'", SETTER, NoOpSetter, DONT_ENUM | DONT_DELETE);
 
   for (var i = 1; i < 10; ++i) {
     %DefineAccessor($RegExp, '$' + i, GETTER, RegExpMakeCaptureGetter(i), DONT_DELETE);
     %DefineAccessor($RegExp, '$' + i, SETTER, NoOpSetter, DONT_DELETE);
   }
 }
 
 
 SetupRegExp();