[regexp] Port RegExpCompile and RegExpToString

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.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/string-builder.h"
 
 namespace v8 {
@@ skipping 130 matching lines @@
 
   Handle<JSObject> object;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, object, JSObject::New(target, new_target_receiver));
   Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(object);
 
   RETURN_RESULT_OR_FAILURE(isolate,
                            RegExpInitialize(isolate, regexp, pattern, flags));
 }
 
+BUILTIN(RegExpPrototypeCompile) {
+  HandleScope scope(isolate);
+  CHECK_RECEIVER(JSRegExp, regexp, "RegExp.prototype.compile");
+
+  Handle<Object> pattern = args.atOrUndefined(isolate, 1);
+  Handle<Object> flags = args.atOrUndefined(isolate, 2);
+
+  if (pattern->IsJSRegExp()) {
+    Handle<JSRegExp> pattern_regexp = Handle<JSRegExp>::cast(pattern);
+
+    if (!flags->IsUndefined(isolate)) {
+      THROW_NEW_ERROR_RETURN_FAILURE(
+          isolate, NewTypeError(MessageTemplate::kRegExpFlags));
+    }
+
+    flags = PatternFlags(isolate, pattern_regexp);
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+        isolate, pattern,
+        Object::GetProperty(pattern, isolate->factory()->source_string()));
+  }
+
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, regexp, RegExpInitialize(isolate, regexp, pattern, flags));
+
+  // Return undefined for compatibility with JSC.
+  // See http://crbug.com/585775 for web compat details.
+
+  return isolate->heap()->undefined_value();
+}
+
 #define APPEND_CHAR_FOR_FLAG(flag, c)                                        \
   do {                                                                       \
     Handle<Object> property;                                                 \
     Handle<Name> name = isolate->factory()->flag##_string();                 \
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, property,                    \
                                        JSReceiver::GetProperty(recv, name)); \
     if (property->BooleanValue()) {                                          \
       builder.AppendCharacter(c);                                            \
     }                                                                        \
   } while (false);
@@ skipping 31 matching lines @@
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kRegExpNonRegExp,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "RegExp.prototype.source")));
   }
 
   Handle<JSRegExp> regexp = Handle<JSRegExp>::cast(recv);
   return regexp->source();
 }
 
+BUILTIN(RegExpPrototypeToString) {
+  HandleScope scope(isolate);
+  CHECK_RECEIVER(JSReceiver, recv, "RegExp.prototype.toString");
+
+  if (*recv == isolate->regexp_function()->prototype()) {
+    isolate->CountUsage(v8::Isolate::kRegExpPrototypeToString);
+  }
+
+  IncrementalStringBuilder builder(isolate);
+
+  builder.AppendCharacter('/');
+  {
+    Handle<Object> source;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+        isolate, source,
+        JSReceiver::GetProperty(recv, isolate->factory()->source_string()));
+    Handle<String> source_str;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, source_str,
+                                       Object::ToString(isolate, source));
+    builder.AppendString(source_str);
+  }
+
+  builder.AppendCharacter('/');
+  {
+    Handle<Object> flags;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+        isolate, flags,
+        JSReceiver::GetProperty(recv, isolate->factory()->flags_string()));
+    Handle<String> flags_str;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, flags_str,
+                                       Object::ToString(isolate, flags));
+    builder.AppendString(flags_str);
+  }
+
+  RETURN_RESULT_OR_FAILURE(isolate, builder.Finish());
+}
+
 // ES6 21.2.4.2.
 BUILTIN(RegExpPrototypeSpeciesGetter) {
   HandleScope scope(isolate);
   return *args.receiver();
 }
 
 #define REGEXP_FLAG_GETTER(name, counter, getter)                              \
   BUILTIN(RegExpPrototype##name##Getter) {                                     \
     HandleScope scope(isolate);                                                \
     Handle<Object> recv = args.receiver();                                     \
@@ skipping 175 matching lines @@
 BUILTIN(RegExpPrototypeRightContextGetter) {
   HandleScope scope(isolate);
   const int start_index = GetLastMatchCapture(isolate, 1);
   Handle<String> last_subject = GetLastMatchSubject(isolate);
   const int len = last_subject->length();
   return *isolate->factory()->NewSubString(last_subject, start_index, len);
 }
 
 }  // namespace internal
 }  // namespace v8