API: expose RegExp.

src/api.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1973 matching lines @@
 
 void v8::Date::CheckCast(v8::Value* that) {
   if (IsDeadCheck("v8::Date::Cast()")) return;
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
   ApiCheck(obj->HasSpecificClassOf(i::Heap::Date_symbol()),
            "v8::Date::Cast()",
            "Could not convert to date");
 }
 
 
+void v8::RegExp::CheckCast(v8::Value* that) {
+  if (IsDeadCheck("v8::RegExp::Cast()")) return;
+  i::Handle<i::Object> obj = Utils::OpenHandle(that);
+  ApiCheck(obj->IsJSRegExp(),
+           "v8::RegExp::Cast()",
+           "Could not convert to regular expression");
+}
+
+
 bool Value::BooleanValue() const {
   if (IsDeadCheck("v8::Value::BooleanValue()")) return false;
   LOG_API("BooleanValue");
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   if (obj->IsBoolean()) {
     return obj->IsTrue();
   } else {
     ENTER_V8;
     i::Handle<i::Object> value = i::Execution::ToBoolean(obj);
     return value->IsTrue();
@@ skipping 1701 matching lines @@
 
 double v8::Date::NumberValue() const {
   if (IsDeadCheck("v8::Date::NumberValue()")) return 0;
   LOG_API("Date::NumberValue");
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
   return jsvalue->value()->Number();
 }
 
 
+static i::Handle<i::String> RegExpFlagsToString(RegExp::Flags flags) {
+  char flags_buf[3];
+  int num_flags = 0;
+  if ((flags & RegExp::kGlobal) != 0) flags_buf[num_flags++] = 'g';
+  if ((flags & RegExp::kMultiline) != 0) flags_buf[num_flags++] = 'm';
+  if ((flags & RegExp::kIgnoreCase) != 0) flags_buf[num_flags++] = 'i';
+  ASSERT(num_flags <= static_cast<int>(sizeof(flags_buf)));

[antonm, 2010/10/04 14:44:55]

You might prefer to use ARRAY_SIZE macro here

[Vitaly Repeshko, 2010/10/04 15:04:42]

Done. But it's longer and still requires a cast to int.

+  if (num_flags == 0) return i::Factory::empty_string();

[antonm, 2010/10/04 14:44:55]

should we have this special case here?  if it's performance critical, maybe do
the check at the top of the function?

[Vitaly Repeshko, 2010/10/04 15:04:42]

Changed to Factory::LookupSymbol.

+  return i::Factory::NewStringFromAscii(
+      i::Vector<const char>(flags_buf, num_flags));
+}
+
+
+Local<v8::RegExp> v8::RegExp::New(Handle<String> pattern,
+                                  Flags flags) {
+  EnsureInitialized("v8::RegExp::New()");
+  LOG_API("RegExp::New");
+  ENTER_V8;
+  EXCEPTION_PREAMBLE();
+  i::Handle<i::String> flags_string = RegExpFlagsToString(flags);
+  i::Object** argv[2] = {
+    i::Handle<i::Object>::cast(Utils::OpenHandle(*pattern)).location(),
+    i::Handle<i::Object>::cast(flags_string).location()
+  };
+  i::Handle<i::Object> obj = i::Execution::New(

[Mads Ager (chromium), 2010/10/05 08:55:46]

I think this code can be simplified by creating a Factory::NewJSRegExp method to
call instead of going into JavaScript code here. I believe the NewJSRegExp
function could be something like this:

Handle<JSRegExp> Factory::NewJSRegExp(Handle<String> pattern,
                                      Handle<String> flags) {
  Handle<JSFunction> constructor(Top::regexp_function());
  bool has_pending_exception;
  Handle<Object> regexp =
      RegExpImpl::CreateRegExpLiteral(constructor,
                                      pattern,
                                      flags,
                                      &has_pending_exception);
  if (has_pending_exception) return Handle<JSRegExp>::null();
  return Handle<JSRegExp>::cast(regexp);
}

Then this code could be:

i::Handle<i::JSRegExp> obj = i::Factory::NewJSRegExp(pattern, flags);
return scope.Close(Utils::ToLocal(obj));

+      i::Handle<i::JSFunction>(i::Top::global_context()->regexp_function()),
+      2, argv,
+      &has_pending_exception);
+  EXCEPTION_BAILOUT_CHECK(Local<v8::RegExp>());
+  if (!obj->IsJSRegExp()) return Local<v8::RegExp>();

[antonm, 2010/10/04 14:44:55]

could this condition be true?

[Vitaly Repeshko, 2010/10/04 15:04:42]

With the current spec only if there's a bug in regexp.js. Removed.

+  return Utils::ToLocal(i::Handle<i::JSRegExp>::cast(obj));
+}
+
+
+Local<v8::String> v8::RegExp::GetSource() const {
+  if (IsDeadCheck("v8::RegExp::GetSource()")) return Local<v8::String>();
+  i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this);
+  return Utils::ToLocal(i::Handle<i::String>(obj->Pattern()));
+}
+
+
+// Assert that the static flags cast in GetFlags is valid.
+#define REGEXP_FLAG_ASSERT_EQ(api_flag, internal_flag)        \

[Mads Ager (chromium), 2010/10/05 08:55:46]

Is this really worth the macro. Writing this out wouldn't take much more space
and would be just as readable I think?

+  STATIC_ASSERT(static_cast<int>(v8::RegExp::api_flag) ==     \
+                static_cast<int>(i::JSRegExp::internal_flag))
+REGEXP_FLAG_ASSERT_EQ(kNone, NONE);
+REGEXP_FLAG_ASSERT_EQ(kGlobal, GLOBAL);
+REGEXP_FLAG_ASSERT_EQ(kIgnoreCase, IGNORE_CASE);
+REGEXP_FLAG_ASSERT_EQ(kMultiline, MULTILINE);
+#undef REGEXP_FLAG_ASSERT_EQ
+
+v8::RegExp::Flags v8::RegExp::GetFlags() const {
+  if (IsDeadCheck("v8::RegExp::GetFlags()")) return v8::RegExp::kNone;
+  i::Handle<i::JSRegExp> obj = Utils::OpenHandle(this);
+  return static_cast<RegExp::Flags>(obj->GetFlags().value());
+}
+
+
 Local<v8::Array> v8::Array::New(int length) {
   EnsureInitialized("v8::Array::New()");
   LOG_API("Array::New");
   ENTER_V8;
   i::Handle<i::JSArray> obj = i::Factory::NewJSArray(length);
   return Utils::ToLocal(obj);
 }
 
 
 uint32_t v8::Array::Length() const {
@@ skipping 1169 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal