RegExp: remove last match info override.

src/js/regexp.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-var $regexpLastMatchInfoOverride;
-
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var FLAG_harmony_regexps;
 var FLAG_harmony_tolength;
 var FLAG_harmony_unicode_regexps;
@@ skipping 20 matching lines @@
 // that there are at least two capture indeces.  The array also contains
 // the subject string for the last successful match.
 var RegExpLastMatchInfo = new InternalPackedArray(
  2,                 // REGEXP_NUMBER_OF_CAPTURES
  "",                // Last subject.
  UNDEFINED,         // Last input - settable with RegExpSetInput.
  0,                 // REGEXP_FIRST_CAPTURE + 0
  0                  // REGEXP_FIRST_CAPTURE + 1
 );
 
-// Override last match info with an array of actual substrings.
-// Used internally by replace regexp with function.
-// The array has the format of an "apply" argument for a replacement
-// function.
-$regexpLastMatchInfoOverride = null;
-
 // -------------------------------------------------------------------
 
 // A recursive descent parser for Patterns according to the grammar of
 // ECMA-262 15.10.1, with deviations noted below.
 function DoConstructRegExp(object, pattern, flags) {
   // RegExp : Called as constructor; see ECMA-262, section 15.10.4.
   if (IS_REGEXP(pattern)) {
     if (!IS_UNDEFINED(flags)) throw MakeTypeError(kRegExpFlags);
     flags = (pattern.global ? 'g' : '')
         + (pattern.ignoreCase ? 'i' : '')
@@ skipping 44 matching lines @@
   if (IS_UNDEFINED(pattern) && %_ArgumentsLength() != 0) {
     DoConstructRegExp(this, 'undefined', flags);
   } else {
     DoConstructRegExp(this, pattern, flags);
   }
 }
 
 
 function DoRegExpExec(regexp, string, index) {
   var result = %_RegExpExec(regexp, string, index, RegExpLastMatchInfo);
-  if (result !== null) $regexpLastMatchInfoOverride = null;
   return result;
 }
 
 
 // This is kind of performance sensitive, so we want to avoid unnecessary
 // type checks on inputs. But we also don't want to inline it several times
 // manually, so we use a macro :-)
 macro RETURN_NEW_RESULT_FROM_MATCH_INFO(MATCHINFO, STRING)
   var numResults = NUMBER_OF_CAPTURES(MATCHINFO) >> 1;
   var start = MATCHINFO[CAPTURE0];
@@ skipping 14 matching lines @@
     j++;
   }
   return result;
 endmacro
 
 
 function RegExpExecNoTests(regexp, string, start) {
   // Must be called with RegExp, string and positive integer as arguments.
   var matchInfo = %_RegExpExec(regexp, string, start, RegExpLastMatchInfo);
   if (matchInfo !== null) {
-    $regexpLastMatchInfoOverride = null;
     // ES6 21.2.5.2.2 step 18.
     if (FLAG_harmony_regexps && regexp.sticky) {
       regexp.lastIndex = matchInfo[CAPTURE1];
     }
     RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, string);
   }
   regexp.lastIndex = 0;
   return null;
 }
 
@@ skipping 23 matching lines @@
 
   // matchIndices is either null or the RegExpLastMatchInfo array.
   var matchIndices = %_RegExpExec(this, string, i, RegExpLastMatchInfo);
 
   if (IS_NULL(matchIndices)) {
     this.lastIndex = 0;
     return null;
   }
 
   // Successful match.
-  $regexpLastMatchInfoOverride = null;
   if (updateLastIndex) {
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
   }
   RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string);
 }
 
 
 // One-element cache for the simplified test regexp.
 var regexp_key;
 var regexp_val;
@@ skipping 19 matching lines @@
     if (i < 0 || i > string.length) {
       this.lastIndex = 0;
       return false;
     }
     // matchIndices is either null or the RegExpLastMatchInfo array.
     var matchIndices = %_RegExpExec(this, string, i, RegExpLastMatchInfo);
     if (IS_NULL(matchIndices)) {
       this.lastIndex = 0;
       return false;
     }
-    $regexpLastMatchInfoOverride = null;
     this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
     return true;
   } else {
     // Non-global, non-sticky regexp.
     // Remove irrelevant preceeding '.*' in a test regexp.  The expression
     // checks whether this.source starts with '.*' and that the third char is
     // not a '?'.  But see https://code.google.com/p/v8/issues/detail?id=3560
     var regexp = this;
     if (regexp.source.length >= 3 &&
         %_StringCharCodeAt(regexp.source, 0) == 46 &&  // '.'
         %_StringCharCodeAt(regexp.source, 1) == 42 &&  // '*'
         %_StringCharCodeAt(regexp.source, 2) != 63) {  // '?'
       regexp = TrimRegExp(regexp);
     }
     // matchIndices is either null or the RegExpLastMatchInfo array.
     var matchIndices = %_RegExpExec(regexp, string, 0, RegExpLastMatchInfo);
     if (IS_NULL(matchIndices)) {
       this.lastIndex = 0;
       return false;
     }
-    $regexpLastMatchInfoOverride = null;
     return true;
   }
 }
 
 function TrimRegExp(regexp) {
   if (!%_ObjectEquals(regexp_key, regexp)) {
     regexp_key = regexp;
     regexp_val =
       new GlobalRegExp(%_SubString(regexp.source, 2, regexp.source.length),
                        (regexp.ignoreCase ? regexp.multiline ? "im" : "i"
@@ skipping 16 matching lines @@
   if (FLAG_harmony_regexps && this.sticky) result += 'y';
   return result;
 }
 
 
 // Getters for the static properties lastMatch, lastParen, leftContext, and
 // rightContext of the RegExp constructor.  The properties are computed based
 // on the captures array of the last successful match and the subject string
 // of the last successful match.
 function RegExpGetLastMatch() {
-  if ($regexpLastMatchInfoOverride !== null) {
-    return OVERRIDE_MATCH($regexpLastMatchInfoOverride);
-  }
   var regExpSubject = LAST_SUBJECT(RegExpLastMatchInfo);
   return %_SubString(regExpSubject,
                      RegExpLastMatchInfo[CAPTURE0],
                      RegExpLastMatchInfo[CAPTURE1]);
 }
 
 
 function RegExpGetLastParen() {
-  if ($regexpLastMatchInfoOverride) {
-    var override = $regexpLastMatchInfoOverride;
-    if (override.length <= 3) return '';
-    return override[override.length - 3];
-  }
   var length = NUMBER_OF_CAPTURES(RegExpLastMatchInfo);
   if (length <= 2) return '';  // There were no captures.
   // We match the SpiderMonkey behavior: return the substring defined by the
   // last pair (after the first pair) of elements of the capture array even if
   // it is empty.
   var regExpSubject = LAST_SUBJECT(RegExpLastMatchInfo);
   var start = RegExpLastMatchInfo[CAPTURE(length - 2)];
   var end = RegExpLastMatchInfo[CAPTURE(length - 1)];
   if (start != -1 && end != -1) {
     return %_SubString(regExpSubject, start, end);
   }
   return "";
 }
 
 
 function RegExpGetLeftContext() {
   var start_index;
   var subject;
-  if (!$regexpLastMatchInfoOverride) {
-    start_index = RegExpLastMatchInfo[CAPTURE0];
-    subject = LAST_SUBJECT(RegExpLastMatchInfo);
-  } else {
-    var override = $regexpLastMatchInfoOverride;
-    start_index = OVERRIDE_POS(override);
-    subject = OVERRIDE_SUBJECT(override);
-  }
+  start_index = RegExpLastMatchInfo[CAPTURE0];
+  subject = LAST_SUBJECT(RegExpLastMatchInfo);
   return %_SubString(subject, 0, start_index);
 }
 
 
 function RegExpGetRightContext() {
   var start_index;
   var subject;
-  if (!$regexpLastMatchInfoOverride) {
-    start_index = RegExpLastMatchInfo[CAPTURE1];
-    subject = LAST_SUBJECT(RegExpLastMatchInfo);
-  } else {
-    var override = $regexpLastMatchInfoOverride;
-    subject = OVERRIDE_SUBJECT(override);
-    var match = OVERRIDE_MATCH(override);
-    start_index = OVERRIDE_POS(override) + match.length;
-  }
+  start_index = RegExpLastMatchInfo[CAPTURE1];
+  subject = LAST_SUBJECT(RegExpLastMatchInfo);
   return %_SubString(subject, start_index, subject.length);
 }
 
 
 // The properties $1..$9 are the first nine capturing substrings of the last
 // successful match, or ''.  The function RegExpMakeCaptureGetter will be
 // called with indices from 1 to 9.
 function RegExpMakeCaptureGetter(n) {
   return function foo() {
-    if ($regexpLastMatchInfoOverride) {
-      if (n < $regexpLastMatchInfoOverride.length - 2) {
-        return OVERRIDE_CAPTURE($regexpLastMatchInfoOverride, n);
-      }
-      return '';
-    }
     var index = n * 2;
     if (index >= NUMBER_OF_CAPTURES(RegExpLastMatchInfo)) return '';
     var matchStart = RegExpLastMatchInfo[CAPTURE(index)];
     var matchEnd = RegExpLastMatchInfo[CAPTURE(index + 1)];
     if (matchStart == -1 || matchEnd == -1) return '';
     return %_SubString(LAST_SUBJECT(RegExpLastMatchInfo), matchStart, matchEnd);
   };
 }
 
 // -------------------------------------------------------------------
@@ skipping 83 matching lines @@
 // Exports
 
 utils.Export(function(to) {
   to.RegExpExec = DoRegExpExec;
   to.RegExpExecNoTests = RegExpExecNoTests;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
 });
 
 })