Revert of [regexp] Port test, match, and search

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) {
 
 'use strict';
 
 %CheckIsBootstrapping();
 
@@ skipping 85 matching lines @@
     if (start != -1) {
       end = MATCHINFO[j];
       result[i] = %_SubString(STRING, start, end);
     }
     j++;
   }
   return result;
 endmacro
 
 
+
 // 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(RegExpExecJS, 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;
 }
 
 
 // Fast path implementation of RegExp.prototype[Symbol.split] which
@@ skipping 133 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 374 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;
+  if (previousLastIndex != 0) this.lastIndex = 0;
+  var result = RegExpSubclassExec(this, string);
+  var currentLastIndex = this.lastIndex;
+  if (currentLastIndex != previousLastIndex) this.lastIndex = previousLastIndex;
+  if (IS_NULL(result)) return -1;
+  return result.index;
+}
+%FunctionRemovePrototype(RegExpSubclassSearch);
+
 
 // -------------------------------------------------------------------
 
 utils.InstallFunctions(GlobalRegExp.prototype, DONT_ENUM, [
+  "test", RegExpSubclassTest,
+  matchSymbol, RegExpSubclassMatch,
   replaceSymbol, RegExpSubclassReplace,
+  searchSymbol, RegExpSubclassSearch,
   splitSymbol, RegExpSubclassSplit,
 ]);
 
 %InstallToContext(["regexp_last_match_info", RegExpLastMatchInfo]);
 
 // -------------------------------------------------------------------
 // Internal
 
 var InternalRegExpMatchInfo = {
   REGEXP_NUMBER_OF_CAPTURES: 2,
@@ skipping 23 matching lines @@
   to.GetSubstitution = GetSubstitution;
   to.InternalRegExpMatch = InternalRegExpMatch;
   to.InternalRegExpReplace = InternalRegExpReplace;
   to.IsRegExp = IsRegExp;
   to.RegExpExec = DoRegExpExec;
   to.RegExpInitialize = RegExpInitialize;
   to.RegExpLastMatchInfo = RegExpLastMatchInfo;
 });
 
 })