mustang 0.0.1 → 0.1.0

data/ext/v8/v8_object.h

@@ -0,0 +1,17 @@
+#ifndef __V8_OBJECT_H
+#define __V8_OBJECT_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::Object class */
+RUBY_EXTERN VALUE rb_cV8Object;
+
+/* API */
+Handle<Value> to_v8_object(VALUE value);
+VALUE rb_v8_object_new2(VALUE data);
+VALUE rb_v8_object_new3();
+void Init_V8_Object();
+
+#endif//__V8_OBJECT_H

data/ext/v8/v8_ref.cpp

@@ -0,0 +1,72 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_external.h"
+
+using namespace v8;
+
+void gc_v8_object_mark(v8_ref *r)
+{
+  rb_gc_mark(r->origin);
+  rb_gc_mark(r->references);
+}
+
+void gc_v8_object_free(v8_ref *r)
+{
+  delete r;
+}
+
+/*
+ * Creates new reference to V8 object for ruby object.
+ *
+ *   v8_ref_new(rb_cV8Integer, Integer::New());
+ *   v8_ref_new(rb_cV8String, String::Cast(*value));
+ *
+ */
+VALUE v8_ref_new(VALUE klass, Handle<void> handle, VALUE orig/* = Qnil */)
+{
+  v8_ref *r = new v8_ref(handle, orig);
+  return Data_Wrap_Struct(klass, gc_v8_object_mark, gc_v8_object_free, r);
+}
+
+/*
+ * Appends additional reference to ruby object wrapped with v8_ref.
+ *
+ */
+void v8_ref_set(VALUE obj, const char *name, VALUE ref)
+{
+  v8_ref *r = 0;
+  Data_Get_Struct(obj, struct v8_ref, r);
+  r->set(name, ref);
+}
+
+/*
+ * Returns original object from which v8 reflection has been created.
+ *
+ */
+VALUE v8_ref_orig(VALUE obj)
+{
+  v8_ref *r = 0;
+  Data_Get_Struct(obj, struct v8_ref, r);
+  return r->origin;
+}
+
+/* The v8_ref struct methods. */
+
+v8_ref::v8_ref(Handle<void> object, VALUE orig/* = Qnil */)
+{
+  handle = Persistent<void>::New(object);
+  references = rb_hash_new();
+  origin = orig;
+}
+
+v8_ref::~v8_ref()
+{
+  handle.Dispose();
+}
+
+void v8_ref::set(const char *name, VALUE ref)
+{
+  if (ref != 0 && RTEST(ref)) {
+    rb_hash_aset(references, rb_str_new2(name), ref);
+  }
+}

data/ext/v8/v8_ref.h

@@ -0,0 +1,43 @@
+#ifndef __V8_REF_H
+#define __V8_REF_H
+
+#include <ruby.h>
+#include <v8.h>
+
+using namespace v8;
+
+/*
+ * The objectRef keeps a persistent V8 handle, so ruby object can access
+ * a reference to it.
+ *
+ */
+struct v8_ref {
+  v8_ref(Handle<void> object, VALUE orig=Qnil);
+  virtual ~v8_ref();
+  void set(const char *name, VALUE ref);
+  Persistent<void> handle;
+  VALUE references;
+  VALUE origin;
+};
+
+/* API */
+VALUE v8_ref_new(VALUE obj, Handle<void> handle, VALUE orig=Qnil);
+VALUE v8_ref_orig(VALUE obj);
+void v8_ref_set(VALUE obj, const char *name, VALUE ref);
+
+/*
+ * Gets reference to V8 object from related ruby object, and reflects
+ * it to specified type.
+ *
+ *   v8_ref_get<String>(rb_str_value);
+ *   v8_ref_get<Integer>(rb_int_value);
+ *
+ */
+template <class T> Local<T> v8_ref_get(VALUE obj)
+{
+  v8_ref* r = 0;
+  Data_Get_Struct(obj, struct v8_ref, r);
+  return (T*)*r->handle;
+}
+
+#endif//__V8_REF_H

data/ext/v8/v8_regexp.cpp

@@ -0,0 +1,148 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_value.h"
+#include "v8_regexp.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Regexp;
+UNWRAPPER(RegExp);
+
+/* Typecasting */
+
+RegExp::Flags to_v8_regexp_flags(VALUE value)
+{
+  int opts = FIX2INT(value);
+  int flags = 0;
+  
+  if (opts & 1) { // Regexp::IGNORECASE
+    flags |= RegExp::kIgnoreCase;
+  }
+  if (opts & 2) { // Regexp::EXTENDED
+    flags |= RegExp::kGlobal;
+  }
+  if (opts & 4) { // Regexp::MULTILINE
+    flags |= RegExp::kMultiline;
+  }
+
+  return RegExp::Flags(flags);
+}
+
+Handle<Value> to_v8_regexp(VALUE src, VALUE opts)
+{
+  return RegExp::New(String::New(StringValuePtr(src)), to_v8_regexp_flags(opts));
+}
+
+Handle<Value> to_v8_regexp(VALUE value)
+{
+  if (rb_obj_is_kind_of(value, rb_cRegexp)) {
+    VALUE src = rb_funcall2(value, rb_intern("source"), 0, NULL);
+    VALUE opts = rb_funcall2(value, rb_intern("options"), 0, NULL);
+    return to_v8_regexp(src, opts);
+  } else if (rb_obj_is_kind_of(value, rb_cString)) {
+    return to_v8_regexp(value, INT2FIX(0));
+  } else {
+    rb_raise(rb_eArgError, "wrong source type, expected Regexp, got %s", RSTRING_PTR(rb_inspect(value)));
+    return Null();
+  }
+}
+
+/* V8::Regexp methods */
+
+/*
+ * call-seq:
+ *   V8::Regexp.new(rxp)         => new_regexp
+ *   V8::Regexp.new(str, flags)  => new_regexp
+ *
+ * Returns new V8 regexp reflected from given ruby regexp or source and flags.
+ *
+ */
+static VALUE rb_v8_regexp_new(int argc, VALUE *argv, VALUE klass)
+{
+  HandleScope scope;
+
+  if (argc == 1) {
+    return v8_ref_new(klass, to_v8_regexp(argv[0]));
+  } else if (argc == 2) {
+    return v8_ref_new(klass, to_v8_regexp(argv[0], argv[1]));
+  } else {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    return Qnil;
+  }
+  
+}
+
+/*
+ * call-seq:
+ *   rxp.source  => str
+ *
+ * Returns regexp source string.
+ *
+ *   rxp = V8::Regexp.new(/foo(bar)?/i)
+ *   rxp.source # => "foo(bar)?"
+ * 
+ */
+static VALUE rb_v8_regexp_source(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->GetSource());
+}
+
+/*
+ * call-seq:
+ *   rxp.options  => int
+ *
+ * Returns fixnum value of v8 regexp flags.
+ *
+ */
+static VALUE rb_v8_regexp_flags(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->GetFlags());
+}
+
+/*
+ * call-seq:
+ *   rxp.flags  => int
+ *
+ * Returns fixnum value of ruby regexp flags.
+ *
+ */
+static VALUE rb_v8_regexp_options(VALUE self)
+{
+  HandleScope scope;
+  int flags = (int)unwrap(self)->GetFlags();
+  int opts = 0;
+
+  if (flags & RegExp::kIgnoreCase) {
+    opts |= 1; // Regexp::IGNORECASE
+  }
+  if (flags & RegExp::kGlobal) {
+    opts |= 2; // Regexp::EXTENDED
+  }
+  if (flags & RegExp::kMultiline) {
+    opts |= 4; // Regexp::MULTILINE
+  }
+  
+  return to_ruby(opts);
+}
+
+
+/* Public constructors */
+
+VALUE rb_v8_regexp_new2(VALUE data)
+{
+  return rb_v8_regexp_new(1, &data, rb_cV8Regexp);
+}
+
+
+/* V8::Regexp initializer. */
+void Init_V8_Regexp()
+{
+  rb_cV8Regexp = rb_define_class_under(rb_mV8, "Regexp", rb_cV8Value);
+  rb_define_singleton_method(rb_cV8Regexp, "new", RUBY_METHOD_FUNC(rb_v8_regexp_new), -1);
+  rb_define_method(rb_cV8Regexp, "source", RUBY_METHOD_FUNC(rb_v8_regexp_source), 0);
+  rb_define_method(rb_cV8Regexp, "flags", RUBY_METHOD_FUNC(rb_v8_regexp_flags), 0);
+  rb_define_method(rb_cV8Regexp, "options", RUBY_METHOD_FUNC(rb_v8_regexp_options), 0);
+}

data/ext/v8/v8_regexp.h

@@ -0,0 +1,16 @@
+#ifndef __V8_REGEXP_H
+#define __V8_REGEXP_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::Regexp class */
+RUBY_EXTERN VALUE rb_cV8Regexp;
+
+/* API */
+Handle<Value> to_v8_regexp(VALUE value);
+VALUE rb_v8_regexp_new2(VALUE data);
+void Init_V8_Regexp();
+
+#endif//__V8_REGEXP_H

data/ext/v8/v8_string.cpp

@@ -0,0 +1,78 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_value.h"
+#include "v8_string.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8String;
+UNWRAPPER(String);
+
+/* Typecasting helpers */
+
+Handle<Value> to_v8_string(VALUE value)
+{
+  return String::New(StringValuePtr(value));
+}
+
+/* V8::String methods */
+
+/*
+ * call-seq:
+ *   V8::String.new(str)  => new_string
+ *
+ * Returns new V8 string reflected from given string.
+ *
+ */
+static VALUE rb_v8_string_new(VALUE klass, VALUE data)
+{
+  HandleScope scope;
+  VALUE str = rb_funcall2(data, rb_intern("to_s"), 0, NULL);
+  return v8_ref_new(klass, to_v8_string(str));
+}
+
+/*
+ * call-seq:
+ *   str.to_utf8  => value
+ *   str.to_s     => value
+ *
+ * Returns UTF-8 representation of referenced string.
+ *
+ */
+static VALUE rb_v8_string_to_utf8(VALUE self)
+{
+  HandleScope scope;
+  return rb_str_new2(*String::Utf8Value(unwrap(self)));
+}
+
+/*
+ * call-seq:
+ *   str.to_ascii  => value
+ *
+ * Returns ASCII representation of referenced string.
+ *
+ */
+static VALUE rb_v8_string_to_ascii(VALUE self)
+{
+  HandleScope scope;
+  return rb_str_new2(*String::AsciiValue(unwrap(self)));
+}
+
+/* Public constructors */
+
+VALUE rb_v8_string_new2(VALUE data)
+{
+  return rb_v8_string_new(rb_cV8String, data);
+}
+
+
+/* V8::String initializer. */
+void Init_V8_String()
+{
+  rb_cV8String = rb_define_class_under(rb_mV8, "String", rb_cV8Primitive);
+  rb_define_singleton_method(rb_cV8String, "new", RUBY_METHOD_FUNC(rb_v8_string_new), 1);
+  rb_define_method(rb_cV8String, "to_ascii", RUBY_METHOD_FUNC(rb_v8_string_to_ascii), 0);
+  rb_define_method(rb_cV8String, "to_utf8", RUBY_METHOD_FUNC(rb_v8_string_to_utf8), 0);
+  rb_define_method(rb_cV8String, "to_s", RUBY_METHOD_FUNC(rb_v8_string_to_utf8), 0);
+}

data/ext/v8/v8_string.h

@@ -0,0 +1,16 @@
+#ifndef __V8_STRING_H
+#define __V8_STRING_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::String class */
+RUBY_EXTERN VALUE rb_cV8String;
+
+/* API */
+Handle<Value> to_v8_string(VALUE value);
+VALUE rb_v8_string_new2(VALUE data);
+void Init_V8_String();
+
+#endif//__V8_STRING_H

data/ext/v8/v8_value.cpp

@@ -0,0 +1,370 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_base.h"
+#include "v8_value.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Value;
+VALUE rb_cV8Primitive;
+UNWRAPPER(Value);
+
+/* V8::Value methods */
+
+/*
+ * call-seq:
+ *   V8::Value.new(obj)  => new_value
+ *
+ * Returns new V8 value reflected from given object.
+ *
+ */
+static VALUE rb_v8_value_new(VALUE self, VALUE data)
+{
+  return v8_ref_new(self, to_v8(data));
+}
+
+/*
+ * call-seq:
+ *   val.object?  => true or false
+ *   val.obj?     => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt object.
+ *
+ */
+static VALUE rb_v8_value_object_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsObject());
+}
+
+/*
+ * call-seq:
+ *   val.integer?  => true or false
+ *   val.int?      => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt integer.
+ *
+ */
+static VALUE rb_v8_value_integer_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsInt32() || unwrap(self)->IsUint32());
+}
+
+/*
+ * call-seq:
+ *   val.number?  => true or false
+ *   val.num?     => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt floating point number.
+ *
+ */
+static VALUE rb_v8_value_number_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsNumber());
+}
+
+/*
+ * call-seq:
+ *   val.string?  => true or false
+ *   val.str?     => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt string.
+ *
+ */
+static VALUE rb_v8_value_string_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsString());
+}
+
+/*
+ * call-seq:
+ *   val.external?  => true or false
+ *
+ * Returns <code>true</code> when value is a v8 external value.
+ *
+ */
+static VALUE rb_v8_value_external_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsExternal());
+}
+
+/*
+ * call-seq:
+ *   val.function?  => true or false
+ *   val.func?      => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt function.
+ *
+ */
+static VALUE rb_v8_value_function_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsFunction());
+}
+
+/*
+ * call-seq:
+ *   val.array?  => true or false
+ *   val.ary?    => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt array.
+ *
+ */
+static VALUE rb_v8_value_array_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsArray());
+}
+
+/*
+ * call-seq:
+ *   val.boolean?  => true or false
+ *   val.bool?     => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt boolean.
+ *
+ */
+static VALUE rb_v8_value_boolean_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsBoolean());
+}
+
+/*
+ * call-seq:
+ *   val.regexp?  => true or false
+ *   val.regex?   => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt regexp.
+ *
+ */
+static VALUE rb_v8_value_regexp_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsRegExp());
+}
+
+/*
+ * call-seq:
+ *   val.date?  => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt date.
+ *
+ */
+static VALUE rb_v8_value_date_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsDate());
+}
+
+/*
+ * call-seq:
+ *   val.true?  => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt bool true.
+ *
+ */
+static VALUE rb_v8_value_true_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsTrue());
+}
+
+/*
+ * call-seq:
+ *   val.false?  => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt bool false.
+ *
+ */
+static VALUE rb_v8_value_false_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsFalse());
+}
+
+/*
+ * call-seq:
+ *   val.empty?  => true or false
+ *
+ * Returns <code>true</code> when value is empty.
+ *
+ */
+static VALUE rb_v8_value_empty_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self).IsEmpty());
+}
+
+/*
+ * call-seq:
+ *   val.null?  => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt null.
+ *
+ */
+static VALUE rb_v8_value_null_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsNull());
+}
+
+/*
+ * call-seq:
+ *   val.undefined?  => true or false
+ *
+ * Returns <code>true</code> when value is undefined.
+ *
+ */
+static VALUE rb_v8_value_undefined_p(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->IsUndefined());
+}
+
+/*
+ * call-seq:
+ *   val.to_string  => str
+ *
+ * Returns string representation of this value.
+ *
+ */
+static VALUE rb_v8_value_to_string(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->ToString());
+}
+
+/*
+ * call-seq:
+ *   val.to_integer  => int
+ *
+ * Returns integer representation of this value.
+ *
+ */
+static VALUE rb_v8_value_to_integer(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->ToInteger());
+}
+
+/*
+ * call-seq:
+ *   val.to_number  => num
+ *
+ * Returns number representation of this value.
+ *
+ */
+static VALUE rb_v8_value_to_number(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->ToNumber());
+}
+
+/*
+ * call-seq:
+ *   val.to_boolean  => bool
+ *
+ * Returns bool representation of this value.
+ *
+ */
+static VALUE rb_v8_value_to_boolean(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->ToBoolean());
+}
+
+/*
+ * call-seq:
+ *   val.to_object  => obj
+ *
+ * Returns object representation of this value.
+ *
+ */
+static VALUE rb_v8_value_to_object(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->ToObject());
+}
+
+/*
+ * call-seq:
+ *   val === other_val  => true or false
+ *
+ * Returns <code>true</code> when compared values are the same objects.
+ *
+ */
+static VALUE rb_v8_value_equals(VALUE self, VALUE value)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->Equals(to_v8(value)));
+}
+
+/*
+ * call-seq:
+ *   val == other_val  => true or false
+ *
+ * Returns <code>true</code> when compared values are equal.
+ *
+ */
+static VALUE rb_v8_value_strict_equals(VALUE self, VALUE value)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->StrictEquals(to_v8(value)));
+}
+
+/* Public constructors */
+
+VALUE rb_v8_value_new2(VALUE data)
+{
+  return rb_v8_value_new(rb_cV8Value, data);
+}
+
+
+/* V8::Value class initializer. */
+void Init_V8_Value()
+{
+  rb_cV8Value = rb_define_class_under(rb_mV8, "Value", rb_cV8Data);
+  rb_define_singleton_method(rb_cV8Value, "new", RUBY_METHOD_FUNC(rb_v8_value_new), 1);
+  rb_define_method(rb_cV8Value, "object?", RUBY_METHOD_FUNC(rb_v8_value_object_p), 0);
+  rb_define_method(rb_cV8Value, "obj?", RUBY_METHOD_FUNC(rb_v8_value_object_p), 0);
+  rb_define_method(rb_cV8Value, "integer?", RUBY_METHOD_FUNC(rb_v8_value_integer_p), 0);
+  rb_define_method(rb_cV8Value, "int?", RUBY_METHOD_FUNC(rb_v8_value_integer_p), 0);
+  rb_define_method(rb_cV8Value, "string?", RUBY_METHOD_FUNC(rb_v8_value_string_p), 0);
+  rb_define_method(rb_cV8Value, "str?", RUBY_METHOD_FUNC(rb_v8_value_string_p), 0);
+  rb_define_method(rb_cV8Value, "number?", RUBY_METHOD_FUNC(rb_v8_value_number_p), 0);
+  rb_define_method(rb_cV8Value, "num?", RUBY_METHOD_FUNC(rb_v8_value_number_p), 0);
+  rb_define_method(rb_cV8Value, "external?", RUBY_METHOD_FUNC(rb_v8_value_external_p), 0);
+  rb_define_method(rb_cV8Value, "array?", RUBY_METHOD_FUNC(rb_v8_value_array_p), 0);
+  rb_define_method(rb_cV8Value, "ary?", RUBY_METHOD_FUNC(rb_v8_value_array_p), 0);
+  rb_define_method(rb_cV8Value, "function?", RUBY_METHOD_FUNC(rb_v8_value_function_p), 0);
+  rb_define_method(rb_cV8Value, "func?", RUBY_METHOD_FUNC(rb_v8_value_function_p), 0);
+  rb_define_method(rb_cV8Value, "boolean?", RUBY_METHOD_FUNC(rb_v8_value_boolean_p), 0);
+  rb_define_method(rb_cV8Value, "bool?", RUBY_METHOD_FUNC(rb_v8_value_boolean_p), 0);
+  rb_define_method(rb_cV8Value, "regexp?", RUBY_METHOD_FUNC(rb_v8_value_regexp_p), 0);
+  rb_define_method(rb_cV8Value, "regex?", RUBY_METHOD_FUNC(rb_v8_value_regexp_p), 0);
+  rb_define_method(rb_cV8Value, "date?", RUBY_METHOD_FUNC(rb_v8_value_date_p), 0);
+  rb_define_method(rb_cV8Value, "true?", RUBY_METHOD_FUNC(rb_v8_value_true_p), 0);
+  rb_define_method(rb_cV8Value, "false?", RUBY_METHOD_FUNC(rb_v8_value_false_p), 0);
+  rb_define_method(rb_cV8Value, "empty?", RUBY_METHOD_FUNC(rb_v8_value_empty_p), 0);
+  rb_define_method(rb_cV8Value, "undefined?", RUBY_METHOD_FUNC(rb_v8_value_undefined_p), 0);
+  rb_define_method(rb_cV8Value, "null?", RUBY_METHOD_FUNC(rb_v8_value_null_p), 0);
+  rb_define_method(rb_cV8Value, "to_string", RUBY_METHOD_FUNC(rb_v8_value_to_string), 0);
+  rb_define_method(rb_cV8Value, "to_integer", RUBY_METHOD_FUNC(rb_v8_value_to_integer), 0);
+  rb_define_method(rb_cV8Value, "to_number", RUBY_METHOD_FUNC(rb_v8_value_to_number), 0);
+  rb_define_method(rb_cV8Value, "to_object", RUBY_METHOD_FUNC(rb_v8_value_to_object), 0);
+  rb_define_method(rb_cV8Value, "to_boolean", RUBY_METHOD_FUNC(rb_v8_value_to_boolean), 0);
+  rb_define_method(rb_cV8Value, "===", RUBY_METHOD_FUNC(rb_v8_value_strict_equals), 1);
+  rb_define_method(rb_cV8Value, "==", RUBY_METHOD_FUNC(rb_v8_value_equals), 1);
+}
+
+/* V8::Primitive initializer. */
+void Init_V8_Primitive()
+{
+  rb_cV8Primitive = rb_define_class_under(rb_mV8, "Primitive", rb_cV8Value);
+}