[regexp] Port RegExpMatch, RegExpSearch, and RegExpTest

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 InternalArray = utils.InternalArray;
 var InternalPackedArray = utils.InternalPackedArray;
 var MaxSimple;
 var MinSimple;
 var lastMatchInfoSymbol = utils.ImportNow("regexp_last_match_info_symbol");
 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;
+var RegExpSubclassExecJS;
 
 utils.Import(function(from) {
   ExpandReplacement = from.ExpandReplacement;
   MaxSimple = from.MaxSimple;
   MinSimple = from.MinSimple;
   SpeciesConstructor = from.SpeciesConstructor;
 });
 
 // -------------------------------------------------------------------
 
@@ skipping 58 matching lines @@
     if (start != -1) {
       end = MATCHINFO[j];
       result[i] = %_SubString(STRING, start, end);
     }
     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) {
-    // ES6 21.2.5.2.2 step 18.
-    if (REGEXP_STICKY(regexp)) regexp.lastIndex = matchInfo[CAPTURE1];
-    RETURN_NEW_RESULT_FROM_MATCH_INFO(matchInfo, string);
-  }
-  regexp.lastIndex = 0;
-  return null;
-}
-
-
-// ES#sec-regexp.prototype.exec
-// RegExp.prototype.exec ( string )
-function RegExpSubclassExecJS(string) {
-  if (!IS_REGEXP(this)) {
-    throw %make_type_error(kIncompatibleMethodReceiver,
-                        'RegExp.prototype.exec', this);
-  }
-
-  string = TO_STRING(string);
-  var lastIndex = this.lastIndex;
-
-  // Conversion is required by the ES2015 specification (RegExpBuiltinExec
-  // algorithm, step 4) even if the value is discarded for non-global RegExps.
-  var i = TO_LENGTH(lastIndex);
-
-  var global = TO_BOOLEAN(REGEXP_GLOBAL(this));
-  var sticky = TO_BOOLEAN(REGEXP_STICKY(this));
-  var updateLastIndex = global || sticky;
-  if (updateLastIndex) {
-    if (i > string.length) {
-      this.lastIndex = 0;
-      return null;
-    }
-  } else {
-    i = 0;
-  }
-
-  // matchIndices is either null or the RegExpLastMatchInfo array.
-  // TODO(littledan): Whether a RegExp is sticky is compiled into the RegExp
-  // itself, but ES2015 allows monkey-patching this property to differ from
-  // the internal flags. If it differs, recompile a different RegExp?
-  var matchIndices = %_RegExpExec(this, string, i, RegExpLastMatchInfo);
-
-  if (IS_NULL(matchIndices)) {
-    this.lastIndex = 0;
-    return null;
-  }
-
-  // Successful match.
-  if (updateLastIndex) {
-    this.lastIndex = RegExpLastMatchInfo[CAPTURE1];
-  }
-  RETURN_NEW_RESULT_FROM_MATCH_INFO(matchIndices, string);
-}
-%FunctionRemovePrototype(RegExpSubclassExecJS);
-
-
 // ES#sec-regexpexec Runtime Semantics: RegExpExec ( R, S )
 // Also takes an optional exec method in case our caller
 // has already fetched exec.
 function RegExpSubclassExec(regexp, string, exec) {
   if (IS_UNDEFINED(exec)) {
     exec = regexp.exec;
   }
   if (IS_CALLABLE(exec)) {
     var result = %_Call(exec, regexp, string);
     if (!IS_RECEIVER(result) && !IS_NULL(result)) {
       throw %make_type_error(kInvalidRegExpExecResult);
     }
     return result;
   }
   return %_Call(RegExpSubclassExecJS, regexp, string);
 }
 %SetForceInlineFlag(RegExpSubclassExec);
 
 
-// ES#sec-regexp.prototype.test RegExp.prototype.test ( S )
-function RegExpSubclassTest(string) {
-  if (!IS_RECEIVER(this)) {
-    throw %make_type_error(kIncompatibleMethodReceiver,
-                        'RegExp.prototype.test', this);
-  }
-  string = TO_STRING(string);
-  var match = RegExpSubclassExec(this, string);
-  return !IS_NULL(match);
-}
-%FunctionRemovePrototype(RegExpSubclassTest);
-
-
 function AtSurrogatePair(subject, index) {
   if (index + 1 >= subject.length) return false;
   var first = %_StringCharCodeAt(subject, index);
   if (first < 0xD800 || first > 0xDBFF) return false;
   var second = %_StringCharCodeAt(subject, index + 1);
   return second >= 0xDC00 || second <= 0xDFFF;
 }
 
 
 // Legacy implementation of RegExp.prototype[Symbol.split] which
@@ skipping 140 matching lines @@
       }
     }
   }
   %AddElement(array, arrayIndex,
                      %_SubString(string, prevStringIndex, size));
   return array;
 }
 %FunctionRemovePrototype(RegExpSubclassSplit);
 
 
-// ES#sec-regexp.prototype-@@match
-// RegExp.prototype [ @@match ] ( string )
-function RegExpSubclassMatch(string) {
-  if (!IS_RECEIVER(this)) {
-    throw %make_type_error(kIncompatibleMethodReceiver,
-                        "RegExp.prototype.@@match", this);
-  }
-  string = TO_STRING(string);
-  var global = this.global;
-  if (!global) return RegExpSubclassExec(this, string);
-  var unicode = this.unicode;
-  this.lastIndex = 0;
-  var array = new InternalArray();
-  var n = 0;
-  var result;
-  while (true) {
-    result = RegExpSubclassExec(this, string);
-    if (IS_NULL(result)) {
-      if (n === 0) return null;
-      break;
-    }
-    var matchStr = TO_STRING(result[0]);
-    array[n] = matchStr;
-    if (matchStr === "") SetAdvancedStringIndex(this, string, unicode);
-    n++;
-  }
-  var resultArray = [];
-  %MoveArrayContents(array, resultArray);
-  return resultArray;
-}
-%FunctionRemovePrototype(RegExpSubclassMatch);
-
-
 // Legacy implementation of RegExp.prototype[Symbol.replace] which
 // doesn't properly call the underlying exec method.
 
 // TODO(lrn): This array will survive indefinitely if replace is never
 // called again. However, it will be empty, since the contents are cleared
 // in the finally block.
 var reusableReplaceArray = new InternalArray(4);
 
 // Helper function for replacing regular expressions with the result of a
 // function application in String.prototype.replace.
@@ skipping 346 matching lines @@
         %_SubString(string, nextSourcePosition, position) + replacement;
       nextSourcePosition = position + matchedLength;
     }
   }
   if (nextSourcePosition >= length) return accumulatedResult;
   return accumulatedResult + %_SubString(string, nextSourcePosition, length);
 }
 %FunctionRemovePrototype(RegExpSubclassReplace);
 
 
-// ES#sec-regexp.prototype-@@search
-// RegExp.prototype [ @@search ] ( string )
-function RegExpSubclassSearch(string) {
-  if (!IS_RECEIVER(this)) {
-    throw %make_type_error(kIncompatibleMethodReceiver,
-                        "RegExp.prototype.@@search", this);
-  }
-  string = TO_STRING(string);
-  var previousLastIndex = this.lastIndex;
-  this.lastIndex = 0;
-  var result = RegExpSubclassExec(this, string);
-  this.lastIndex = previousLastIndex;
-  if (IS_NULL(result)) return -1;
-  return result.index;
-}
-%FunctionRemovePrototype(RegExpSubclassSearch);
-
-
 // -------------------------------------------------------------------
 
 utils.InstallFunctions(GlobalRegExp.prototype, DONT_ENUM, [
-  "exec", RegExpSubclassExecJS,
-  "test", RegExpSubclassTest,
-  matchSymbol, RegExpSubclassMatch,
   replaceSymbol, RegExpSubclassReplace,
-  searchSymbol, RegExpSubclassSearch,
   splitSymbol, RegExpSubclassSplit,
 ]);
 
 // Temporary until all RegExpLastMatchInfo accesses are ported to C++.
 SET_PRIVATE(GlobalRegExp, lastMatchInfoSymbol, RegExpLastMatchInfo);
 
+var RegExpSubclassExecJS = GlobalRegExp.prototype.exec;
+
 // -------------------------------------------------------------------
 // Internal
 
 var InternalRegExpMatchInfo = {
   REGEXP_NUMBER_OF_CAPTURES: 2,
   REGEXP_LAST_SUBJECT:       "",
   REGEXP_LAST_INPUT:         UNDEFINED,
   CAPTURE0:                  0,
   CAPTURE1:                  0
 };
@@ skipping 15 matching lines @@
 // Exports
 
 utils.Export(function(to) {
   to.InternalRegExpMatch = InternalRegExpMatch;
   to.InternalRegExpReplace = InternalRegExpReplace;
   to.IsRegExp = IsRegExp;
   to.RegExpInitialize = RegExpInitialize;
 });
 
 })