[regexp] Port remaining JS functions in regexp.js

src/builtins/builtins-regexp.cc

 // Copyright 2016 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.
 
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 
 #include "src/code-factory.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 49 matching lines @@
   }
 
   // TODO(jgruber): We could avoid the flags back and forth conversions.
   RETURN_RESULT(isolate,
                 JSRegExp::Initialize(regexp, pattern_string, flags_string),
                 JSRegExp);
 }
 
 }  // namespace
 
+BUILTIN(RegExpInitialize) {
+  HandleScope scope(isolate);
+  Handle<JSRegExp> regexp = args.at<JSRegExp>(1);
+  Handle<Object> pattern = args.atOrUndefined(isolate, 2);
+  Handle<Object> flags = args.atOrUndefined(isolate, 3);
+  RETURN_RESULT_OR_FAILURE(isolate,
+                           RegExpInitialize(isolate, regexp, pattern, flags));
+}
+
+BUILTIN(RegExpIsRegExp) {
+  HandleScope scope(isolate);
+  Handle<Object> object = args.at<Object>(1);
+
+  Maybe<bool> maybe_is_regexp = RegExpUtils::IsRegExp(isolate, object);
+  if (maybe_is_regexp.IsNothing()) {
+    DCHECK(isolate->has_pending_exception());
+    return isolate->heap()->exception();
+  }
+
+  return isolate->heap()->ToBoolean(maybe_is_regexp.FromJust());
+}
+
 // ES#sec-regexp-pattern-flags
 // RegExp ( pattern, flags )
 BUILTIN(RegExpConstructor) {
   HandleScope scope(isolate);
 
   Handle<HeapObject> new_target = args.new_target();
   Handle<Object> pattern = args.atOrUndefined(isolate, 1);
   Handle<Object> flags = args.atOrUndefined(isolate, 2);
 
   Handle<JSFunction> target = isolate->regexp_function();
@@ skipping 1568 matching lines @@
   }
 
   a->Bind(&runtime);
   {
     Node* const result = a->CallRuntime(Runtime::kRegExpReplace, context,
                                         receiver, string, replace_value);
     a->Return(result);
   }
 }
 
+namespace {
+
+// TODO(jgruber): Replace this with a FixedArray.
+compiler::Node* GetInternalMatchInfo(CodeStubAssembler* a,

[Yang, 2016/10/13 11:51:11]

This allocates a new array on every invocation. I guess for i18n this is fine,
but the inspector also wants to use these two functions. Maybe we can reuse this
by putting it on the native context?

[jgruber, 2016/10/13 12:02:37]

Sure. I'll take care of it once the FixedArray conversion for match infos is
done.

+                                     compiler::Node* context) {
+  typedef compiler::Node Node;
+
+  const ElementsKind elements_kind = FAST_ELEMENTS;
+  Node* const native_context = a->LoadNativeContext(context);
+  Node* const array_map =
+      a->LoadJSArrayElementsMap(elements_kind, native_context);
+  Node* const capacity = a->IntPtrConstant(RegExpImpl::kLastMatchOverhead + 2);
+  Node* const allocation_site = nullptr;
+
+  return a->AllocateJSArray(elements_kind, array_map, capacity, capacity,
+                            allocation_site,
+                            CodeStubAssembler::INTPTR_PARAMETERS);
+}
+
+}  // namespace
+
+// Simple string matching functionality for internal use which does not modify
+// the last match info.
+void Builtins::Generate_RegExpInternalMatch(CodeStubAssembler* a) {
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+
+  Isolate* const isolate = a->isolate();
+
+  Node* const regexp = a->Parameter(1);
+  Node* const string = a->Parameter(2);
+  Node* const context = a->Parameter(5);
+
+  Node* const null = a->NullConstant();
+  Node* const smi_zero = a->SmiConstant(Smi::FromInt(0));
+  Node* const internal_match_info = GetInternalMatchInfo(a, context);
+
+  Callable exec_callable = CodeFactory::RegExpExec(isolate);
+  Node* const match_indices = a->CallStub(
+      exec_callable, context, regexp, string, smi_zero, internal_match_info);
+
+  Label if_matched(a), if_didnotmatch(a);
+  a->Branch(a->WordEqual(match_indices, null), &if_didnotmatch, &if_matched);
+
+  a->Bind(&if_didnotmatch);
+  a->Return(null);
+
+  a->Bind(&if_matched);
+  {
+    Node* const match_elements = a->LoadElements(match_indices);
+    Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
+                                                   match_elements, string);
+    a->Return(result);
+  }
+}
+
+// Simple string replacement functionality for internal use which does not
+// modify the last match info.
+void Builtins::Generate_RegExpInternalReplace(CodeStubAssembler* a) {
+  typedef compiler::Node Node;
+
+  Node* const regexp = a->Parameter(1);
+  Node* const subject_string = a->Parameter(2);
+  Node* const replace_string = a->Parameter(3);
+  Node* const context = a->Parameter(6);
+
+  Node* const internal_match_info = GetInternalMatchInfo(a, context);
+
+  Node* const result = a->CallRuntime(
+      Runtime::kStringReplaceGlobalRegExpWithString, context, subject_string,
+      regexp, replace_string, internal_match_info);
+  a->Return(result);
+}
+
 }  // namespace internal
 }  // namespace v8