Fix a bug in the regexp caching. Also add a few more places to...

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 77 matching lines @@
                  DONT_DELETE | READ_ONLY | DONT_ENUM);
 
     // ECMA-262, section 15.10.7.5.
     %SetProperty(object, 'lastIndex', 0, DONT_DELETE | DONT_ENUM);
   } else { // RegExp is being recompiled via RegExp.prototype.compile.
     %IgnoreAttributesAndSetProperty(object, 'source', pattern);
     %IgnoreAttributesAndSetProperty(object, 'global', global);
     %IgnoreAttributesAndSetProperty(object, 'ignoreCase', ignoreCase);
     %IgnoreAttributesAndSetProperty(object, 'multiline', multiline);
     %IgnoreAttributesAndSetProperty(object, 'lastIndex', 0);
-    // Clear the regexp result cache.
-    cachedRegexp = 0;
-    cachedSubject = 0;
-    cachedLastIndex = 0;
-    cachedAnswer = 0;
-    // These are from string.js.
-    cachedReplaceSubject = 0;
-    cachedReplaceRegexp = 0;
-    cachedReplaceReplacement = 0;
-    cachedReplaceAnswer = 0;
+    regExpCache.type = 'none';
   }
 
   // Call internal function to compile the pattern.
   %RegExpCompile(object, pattern, flags);
 }
 
 
 function RegExpConstructor(pattern, flags) {
   if (%_IsConstructCall()) {
     DoConstructRegExp(this, pattern, flags, true);
@@ skipping 25 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 RegExpCache() {
+  this.type = 'none';
+  this.regExp = 0;
+  this.subject = 0;
+  this.replaceString = 0;
+  this.lastIndex = 0;
+  this.answer = 0;
+}
+
+
+var regExpCache = new RegExpCache();
 
 
 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 (%_ObjectEquals(cachedLastIndex, this.lastIndex) &&
-      %_ObjectEquals(cachedRegexp, this) &&
-      %_ObjectEquals(cachedSubject, string)) {
-    var last = cachedAnswer;
+  if (!IS_REGEXP(this)) {
+    throw MakeTypeError('incompatible_method_receiver',
+                        ['RegExp.prototype.exec', this]);
+  }
+
+  var cache = regExpCache;
+
+  if (%_ObjectEquals(cache.type, 'exec') &&
+      %_ObjectEquals(cache.lastIndex, this.lastIndex) &&
+      %_ObjectEquals(cache.regExp, this) &&
+      %_ObjectEquals(cache.subject, string)) {
+    var last = cache.answer;
     if (last == null) {
       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;
-    cachedLastIndex = lastIndex;
-    cachedRegexp = this;
-    cachedSubject = s;
-    cachedAnswer = matchIndices;  // Null.
+    cache.lastIndex = lastIndex;
+    cache.regExp = this;
+    cache.subject = s;
+    cache.answer = matchIndices;  // Null.
+    cache.type = 'exec';
     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 {
@@ skipping 10 matching lines @@
       }
     }
   }
 
   result.index = lastMatchInfo[CAPTURE0];
   result.input = s;
   if (this.global) {
     this.lastIndex = lastMatchInfo[CAPTURE1];
     return result;
   } else {
-    cachedRegexp = this;
-    cachedSubject = s;
-    cachedLastIndex = lastIndex;
-    cachedAnswer = result;
+    cache.regExp = this;
+    cache.subject = s;
+    cache.lastIndex = lastIndex;
+    cache.answer = result;
+    cache.type = 'exec';
     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',
                         ['RegExp.prototype.test', this]);
   }
   if (%_ArgumentsLength() == 0) {
     var regExpInput = LAST_INPUT(lastMatchInfo);
     if (IS_UNDEFINED(regExpInput)) {
       throw MakeError('no_input_to_regexp', [this]);
     }
     string = regExpInput;
   }
-  var s = ToString(string);
+  var s;
+  if (IS_STRING(string)) {
+    s = string;
+  } else {
+    s = ToString(string);
+  }
+
+  var lastIndex = this.lastIndex;
+
+  var cache = regExpCache;
+
+  if (%_ObjectEquals(cache.type, 'test') &&
+      %_ObjectEquals(cache.regExp, this) &&
+      %_ObjectEquals(cache.subject, string) &&
+      %_ObjectEquals(cache.lastIndex, lastIndex)) {
+    return cache.answer;
+  }
+
   var length = s.length;
-  var lastIndex = this.lastIndex;
   var i = this.global ? TO_INTEGER(lastIndex) : 0;
 
+  cache.type = 'test';
+  cache.regExp = this;
+  cache.subject = s;
+  cache.lastIndex = i;
+
   if (i < 0 || i > s.length) {
     this.lastIndex = 0;
+    cache.answer = false;
     return false;
   }
 
   %_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;
+    cache.answer = false;
     return false;
   }
 
   if (this.global) this.lastIndex = lastMatchInfo[CAPTURE1];
+  cache.answer = true;
   return true;
 }
 
 
 function RegExpToString() {
   // If this.source is an empty string, output /(?:)/.
   // http://bugzilla.mozilla.org/show_bug.cgi?id=225550
   // ecma_2/RegExp/properties-001.js.
   var src = this.source ? this.source : '(?:)';
   var result = '/' + src + '/';
@@ skipping 98 matching lines @@
   %FunctionSetLength($RegExp.prototype.compile, 1);
 
   // The properties input, $input, and $_ are aliases for each other.  When this
   // value is set the value it is set to is coerced to a string. 
   // Getter and setter for the input.
   function RegExpGetInput() {
     var regExpInput = LAST_INPUT(lastMatchInfo);
     return IS_UNDEFINED(regExpInput) ? "" : regExpInput;
   }
   function RegExpSetInput(string) {
+    regExpCache.type = 'none';
     LAST_INPUT(lastMatchInfo) = ToString(string);
   };
 
   %DefineAccessor($RegExp, 'input', GETTER, RegExpGetInput, DONT_DELETE);
   %DefineAccessor($RegExp, 'input', SETTER, RegExpSetInput, DONT_DELETE);
   %DefineAccessor($RegExp, '$_', GETTER, RegExpGetInput, DONT_ENUM | DONT_DELETE);
   %DefineAccessor($RegExp, '$_', SETTER, RegExpSetInput, DONT_ENUM | DONT_DELETE);
   %DefineAccessor($RegExp, '$input', GETTER, RegExpGetInput, DONT_ENUM | DONT_DELETE);
   %DefineAccessor($RegExp, '$input', SETTER, RegExpSetInput, DONT_ENUM | DONT_DELETE);
 
@@ skipping 37 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();