[regexp/string] Merge ExpandReplacement and GetSubstitution

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.
 
 (function(global, utils) {
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
-var ExpandReplacement;
 var GlobalArray = global.Array;
 var GlobalObject = global.Object;
 var GlobalRegExp = global.RegExp;
 var GlobalRegExpPrototype;
 var InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
 var MaxSimple;
 var MinSimple;
 var matchSymbol = utils.ImportNow("match_symbol");
 var replaceSymbol = utils.ImportNow("replace_symbol");
 var searchSymbol = utils.ImportNow("search_symbol");
 var speciesSymbol = utils.ImportNow("species_symbol");
 var splitSymbol = utils.ImportNow("split_symbol");
 var SpeciesConstructor;
 
 utils.Import(function(from) {
-  ExpandReplacement = from.ExpandReplacement;
   MaxSimple = from.MaxSimple;
   MinSimple = from.MinSimple;
   SpeciesConstructor = from.SpeciesConstructor;
 });
 
 // -------------------------------------------------------------------
 
 // Property of the builtins object for recording the result of the last
 // regexp match.  The property RegExpLastMatchInfo includes the matchIndices
 // array of the last successful regexp match (an array of start/end index
@@ skipping 643 matching lines @@
 
     replacement = %reflect_apply(replace, UNDEFINED, parameters);
   }
 
   result += replacement;  // The add method converts to string if necessary.
   // Can't use matchInfo any more from here, since the function could
   // overwrite it.
   return result + %_SubString(subject, endOfMatch, subject.length);
 }
 
+// Wraps access to matchInfo's captures into a format understood by
+// GetSubstitution.
+function MatchInfoCaptureWrapper(matches, subject) {
+  this.length = NUMBER_OF_CAPTURES(matches) >> 1;
+  this.match = matches;
+  this.subject = subject;
+}
+
+MatchInfoCaptureWrapper.prototype.at = function(ix) {
+  const match = this.match;
+  const start = match[CAPTURE(ix << 1)];
+  if (start < 0) return UNDEFINED;
+  return %_SubString(this.subject, start, match[CAPTURE((ix << 1) + 1)]);
+};
+%SetForceInlineFlag(MatchInfoCaptureWrapper.prototype.at);
+
+function ArrayCaptureWrapper(array) {
+  this.length = array.length;
+  this.array = array;
+}
+
+ArrayCaptureWrapper.prototype.at = function(ix) {
+  return this.array[ix];
+};
+%SetForceInlineFlag(ArrayCaptureWrapper.prototype.at);
 
 function RegExpReplace(string, replace) {
   if (!IS_REGEXP(this)) {
     throw %make_type_error(kIncompatibleMethodReceiver,
                         "RegExp.prototype.@@replace", this);
   }
   var subject = TO_STRING(string);
   var search = this;
 
   if (!IS_CALLABLE(replace)) {
     replace = TO_STRING(replace);
 
     if (!REGEXP_GLOBAL(search)) {
       // Non-global regexp search, string replace.
       var match = DoRegExpExec(search, subject, 0);
       if (match == null) {
         search.lastIndex = 0
         return subject;
       }
       if (replace.length == 0) {
         return %_SubString(subject, 0, match[CAPTURE0]) +
                %_SubString(subject, match[CAPTURE1], subject.length)
       }
-      return ExpandReplacement(replace, subject, RegExpLastMatchInfo,
-                                 %_SubString(subject, 0, match[CAPTURE0])) +
-             %_SubString(subject, match[CAPTURE1], subject.length);
+      const captures = new MatchInfoCaptureWrapper(match, subject);
+      const start = match[CAPTURE0];
+      const end = match[CAPTURE1];
+
+      const prefix = %_SubString(subject, 0, start);
+      const matched = %_SubString(subject, start, end);
+      const suffix = %_SubString(subject, end, subject.length);
+
+      return prefix +
+             GetSubstitution(matched, subject, start, captures, replace) +
+             suffix;
     }
 
     // Global regexp search, string replace.
     search.lastIndex = 0;
     return %StringReplaceGlobalRegExpWithString(
         subject, search, replace, RegExpLastMatchInfo);
   }
 
   if (REGEXP_GLOBAL(search)) {
     // Global regexp search, function replace.
     return StringReplaceGlobalRegExpWithFunction(subject, search, replace);
   }
   // Non-global regexp search, function replace.
   return StringReplaceNonGlobalRegExpWithFunction(subject, search, replace);
 }
 
 
 // ES#sec-getsubstitution
 // GetSubstitution(matched, str, position, captures, replacement)
 // Expand the $-expressions in the string and return a new string with
 // the result.
-// TODO(littledan): Call this function from String.prototype.replace instead
-// of the very similar ExpandReplacement in src/js/string.js
 function GetSubstitution(matched, string, position, captures, replacement) {
   var matchLength = matched.length;
   var stringLength = string.length;
   var capturesLength = captures.length;
   var tailPos = position + matchLength;
   var result = "";
   var pos, expansion, peek, next, scaledIndex, advance, newScaledIndex;
 
   var next = %StringIndexOf(replacement, '$', 0);
   if (next < 0) {
@@ skipping 28 matching lines @@
           next = %_StringCharCodeAt(replacement, pos + 1);
           if (next >= 48 && next <= 57) {
             newScaledIndex = scaledIndex * 10 + ((next - 48));
             if (newScaledIndex < capturesLength) {
               scaledIndex = newScaledIndex;
               advance = 2;
             }
           }
         }
         if (scaledIndex != 0 && scaledIndex < capturesLength) {
-          var capture = captures[scaledIndex];
+          var capture = captures.at(scaledIndex);
           if (!IS_UNDEFINED(capture)) result += capture;
           pos += advance;
         } else {
           result += '$';
         }
       } else {
         result += '$';
       }
     } else {
       result += '$';
@@ skipping 103 matching lines @@
     if (functionalReplace) {
       var parameters = new InternalArray(capturesLength + 2);
       for (var j = 0; j < capturesLength; j++) {
         parameters[j] = captures[j];
       }
       parameters[j] = position;
       parameters[j + 1] = string;
       replacement = %reflect_apply(replace, UNDEFINED, parameters, 0,
                                    parameters.length);
     } else {
-      replacement = GetSubstitution(matched, string, position, captures,
+      const capturesWrapper = new ArrayCaptureWrapper(captures);
+      replacement = GetSubstitution(matched, string, position, capturesWrapper,
                                     replace);
     }
     if (position >= nextSourcePosition) {
       accumulatedResult +=
         %_SubString(string, nextSourcePosition, position) + replacement;
       nextSourcePosition = position + matchedLength;
     }
   }
   if (nextSourcePosition >= length) return accumulatedResult;
   return accumulatedResult + %_SubString(string, nextSourcePosition, length);
@@ skipping 287 matching lines @@
 
 function InternalRegExpReplace(regexp, subject, replacement) {
   return %StringReplaceGlobalRegExpWithString(
       subject, regexp, replacement, InternalRegExpMatchInfo);
 }
 
 // -------------------------------------------------------------------
 // Exports
 
 utils.Export(function(to) {
+  to.GetSubstitution = GetSubstitution;
   to.InternalRegExpMatch = InternalRegExpMatch;
   to.InternalRegExpReplace = InternalRegExpReplace;
   to.IsRegExp = IsRegExp;
   to.RegExpExec = DoRegExpExec;
   to.RegExpInitialize = RegExpInitialize;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
   to.RegExpTest = RegExpTest;
 });
 
 })