therubyracer-xcode 0.12.2

data/benchmarks.rb

@@ -0,0 +1,218 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'v8'
+require 'benchmark'
+require 'optparse'
+
+OPTIONS = {
+  :times => 5,
+  :mode => :object,
+  :objects => 500
+}
+
+parser = OptionParser.new do |opts|
+  opts.on("-t", "--times [T]", Integer, "run benchmark N times") do |t|
+    OPTIONS[:times] = t
+  end
+
+  opts.on("-m", "--mode [MODE]", [:object, :function, :eval], "select the type of object access to stress test") do |mode|
+    mode = mode.to_sym
+    raise "unsupported mode #{mode}" unless [:object,:function,:eval].include?(mode)
+    OPTIONS[:mode] = mode
+  end
+
+  opts.on("-o", "--objects [N]", Integer, "create N objects for each iteration") do |n|
+    OPTIONS[:objects] = n
+  end
+  opts
+end
+
+parser.parse! ARGV
+
+MODE = OPTIONS[:mode]
+TIMES = OPTIONS[:times]
+OBJECTS = OPTIONS[:objects]
+
+puts "using #{OPTIONS[:mode]}"
+if MODE==:object
+    def get(i)
+      @cxt["test"]["objects"][i]
+    end
+elsif  MODE==:function
+    def get(i)
+      @cxt["test"].getObject(i)
+    end
+elsif  MODE==:eval
+    def get(i)
+      @cxt.eval "test.getObject(#{i})"
+    end
+end
+
+js= <<JS
+
+function createTest()
+{
+    var test = {};
+    test.objects = [];
+    test.seed = 49734321;
+    test.summ;
+
+    test.random = function()
+    {
+        // Robert Jenkins' 32 bit integer hash function.
+        test.seed = ((test.seed + 0x7ed55d16) + (test.seed << 12))  & 0xffffffff;
+        test.seed = ((test.seed ^ 0xc761c23c) ^ (test.seed >>> 19)) & 0xffffffff;
+        test.seed = ((test.seed + 0x165667b1) + (test.seed << 5))   & 0xffffffff;
+        test.seed = ((test.seed + 0xd3a2646c) ^ (test.seed << 9))   & 0xffffffff;
+        test.seed = ((test.seed + 0xfd7046c5) + (test.seed << 3))   & 0xffffffff;
+        test.seed = ((test.seed ^ 0xb55a4f09) ^ (test.seed >>> 16)) & 0xffffffff;
+        return (test.seed & 0xfffffff) / 0x10000000;
+    };
+
+    test.init = function()
+    {
+        test.objects = [];
+        for(var i=0; i<#{OBJECTS}; i++)
+        {
+            var hash = {};
+            for(var j=0; j<10; j++)
+            {
+                var isString = test.random();
+                var key = "str" + test.random();
+                var value;
+                if(isString < 0.5)
+                    value = "str" + test.random();
+                else
+                    value = test.random();
+                hash[key] = value;
+            }
+            test.objects[i] = hash;
+        }
+        return test.objects.length;
+    }
+
+    test.findSum = function()
+    {
+        test.summ = 0;
+        var length = test.objects.length;
+        for(var i=0; i<length; i++)
+        {
+            var hash = test.objects[i];
+            for (var k in hash)
+            {
+                if (hash.hasOwnProperty(k) && (typeof(hash[k]) == "number"))
+                {
+                    test.summ += hash[k];
+                }
+            }
+        }
+        return test.summ;
+    };
+
+    test.finalCheck = function()
+    {
+        var summ = 0;
+        var length = test.objects.length;
+        for(var i=0; i<length; i++)
+        {
+            var hash = test.objects[i];
+            for (var k in hash)
+            {
+                if (hash.hasOwnProperty(k) && (typeof(hash[k]) == "number"))
+                {
+                    summ += hash[k];
+                }
+            }
+        }
+        return summ ;
+    };
+
+    test.getObject = function(index)
+    {
+        if(!test.objects[index]) return {};
+        return test.objects[index];
+    }
+
+    test.setObject = function(index, object)
+    {
+        test.objects[index] = object;
+    }
+
+    return test;
+}
+
+JS
+
+
+
+
+
+def profile
+ Benchmark.realtime do
+    yield
+   end
+end
+
+def get_res result
+  result.to_f
+end
+
+
+
+
+
+puts "init js context..."
+cxt = V8::Context.new
+@cxt=cxt
+cxt.eval(js)
+
+cxt.eval('var test = createTest()')
+
+puts "run init test"
+result =profile do
+  TIMES.times do
+    cxt['test'].init()
+  end
+end
+
+puts "init time: #{get_res(result) / TIMES} sec."
+sum1=sum2=0
+puts "run findSum test"
+
+result =profile do
+  TIMES.times do
+      sum1= cxt['test'].findSum
+  end
+end
+
+puts "findSum time: #{get_res(result) / TIMES} sec."
+
+
+puts "run Objects inversion in ruby test"
+result =profile do
+  TIMES.times do |j|
+    puts j
+    for i in 0..(OBJECTS-1) do
+      obj = get(i)
+      obj.each do |key, value|
+        if value.instance_of? Float
+          obj[key] = value * (-1)
+        end
+      end
+    end
+  end
+end
+
+puts "Objects time: #{get_res(result) / TIMES} sec."
+
+puts "run finalCheck test"
+
+
+result =profile do
+  TIMES.times do
+    sum2= cxt['test'].findSum
+  end
+end
+
+puts "final check time: #{get_res(result) / TIMES} sec."
+puts "#{sum1==sum2*(TIMES%2==0?1:-1) ? 'TEST PASS': 'TEST FAIL'}:  Sum before inversions: #{sum1} / Sum after inversions: #{sum2}"

data/ext/v8/accessor.cc

@@ -0,0 +1,181 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Accessor::Info::Class;
+
+  void Accessor::Init() {
+    ClassBuilder("AccessorInfo").
+      defineMethod("This", &Info::This).
+      defineMethod("Holder", &Info::Holder).
+      defineMethod("Data", &Info::Data).
+      store(&Info::Class);
+  }
+
+  Accessor::Accessor(VALUE getter, VALUE setter, VALUE data_) : get(getter), set(setter), query(Qnil), deleter(Qnil), enumerator(Qnil), data(data_) {}
+
+  Accessor::Accessor(VALUE get, VALUE set, VALUE query, VALUE deleter, VALUE enumerator, VALUE data) {
+    this->get = get;
+    this->set = set;
+    this->query = query;
+    this->deleter = deleter;
+    this->enumerator = enumerator;
+    this->data = data;
+  }
+
+  Accessor::Accessor(v8::Handle<v8::Value> value) {
+    v8::Local<v8::Object> wrapper = value->ToObject();
+    this->get = unwrap(wrapper, 0);
+    this->set = unwrap(wrapper, 1);
+    this->query = unwrap(wrapper, 2);
+    this->deleter = unwrap(wrapper, 3);
+    this->enumerator = unwrap(wrapper, 4);
+    v8::Handle<v8::Value> data = wrapper->Get(5);
+    if (!data.IsEmpty() && !data->IsNull() && !data->IsUndefined()) {
+      this->data = Value(data);
+    }
+  }
+
+  Accessor::operator v8::Handle<v8::Value>() {
+    v8::Local<v8::Object> wrapper = v8::Object::New();
+    wrap(wrapper, 0, this->get);
+    wrap(wrapper, 1, this->set);
+    wrap(wrapper, 2, this->query);
+    wrap(wrapper, 3, this->deleter);
+    wrap(wrapper, 4, this->enumerator);
+    if (RTEST(this->data)) {
+      wrapper->Set(5, Value(this->data));
+    }
+    return wrapper;
+  }
+
+  void Accessor::wrap(v8::Handle<v8::Object> wrapper, int index, VALUE value) {
+    if (RTEST(value)) {
+      wrapper->Set(index, External::wrap(value));
+    }
+  }
+
+  VALUE Accessor::unwrap(v8::Handle<v8::Object> wrapper, int index) {
+    v8::Handle<v8::Value> value = wrapper->Get(index);
+    if (value.IsEmpty() || !value->IsExternal()) {
+      return Qnil;
+    } else {
+      v8::Handle<v8::External> external(v8::External::Cast(*value));
+      return External::unwrap(external);
+    }
+  }
+
+
+  VALUE Accessor::Info::This(VALUE self) {
+    return Object(Info(self)->This());
+  }
+
+  VALUE Accessor::Info::Holder(VALUE self) {
+    return Object(Info(self)->Holder());
+  }
+
+  VALUE Accessor::Info::Data(VALUE self) {
+    return Accessor(Info(self)->Data()).data;
+  }
+
+  v8::Handle<v8::Value> Accessor::AccessorGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).get(property);
+  }
+
+  void Accessor::AccessorSetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    Info(info).set(property, value);
+  }
+  v8::Handle<v8::Value> Accessor::NamedPropertyGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).get(property);
+  }
+  v8::Handle<v8::Value> Accessor::NamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    return Info(info).set(property, value);
+  }
+  v8::Handle<v8::Integer> Accessor::NamedPropertyQuery(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).query(property);
+  }
+  v8::Handle<v8::Boolean> Accessor::NamedPropertyDeleter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).remove(property);
+  }
+  v8::Handle<v8::Array> Accessor::NamedPropertyEnumerator(const v8::AccessorInfo& info) {
+    return Info(info).enumerateNames();
+  }
+
+  v8::Handle<v8::Value> Accessor::IndexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).get(index);
+  }
+  v8::Handle<v8::Value> Accessor::IndexedPropertySetter(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    return Info(info).set(index, value);
+  }
+  v8::Handle<v8::Integer> Accessor::IndexedPropertyQuery(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).query(index);
+  }
+  v8::Handle<v8::Boolean> Accessor::IndexedPropertyDeleter(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).remove(index);
+  }
+  v8::Handle<v8::Array> Accessor::IndexedPropertyEnumerator(const v8::AccessorInfo& info) {
+    return Info(info).enumerateIndices();
+  }
+
+  Accessor::Info::Info(const v8::AccessorInfo& info) {
+    this->info = &info;
+  }
+
+  Accessor::Info::Info(VALUE value) {
+    Data_Get_Struct(value, class v8::AccessorInfo, info);
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::get(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.get, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::set(v8::Local<v8::String> property, v8::Local<v8::Value> value) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.set, rb_intern("call"), 3, (VALUE)String(property), (VALUE)Value(value), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Integer> Accessor::Info::query(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return v8::Integer::New(NUM2INT(rb_funcall(accessor.query, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Boolean> Accessor::Info::remove(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return v8::Boolean::New(Bool(rb_funcall(accessor.deleter, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Array> Accessor::Info::enumerateNames() {
+    Accessor accessor(info->Data());
+    return Array(rb_funcall(accessor.enumerator, rb_intern("call"), 1, (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::get(uint32_t index) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.get, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::set(uint32_t index, v8::Local<v8::Value> value) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.set, rb_intern("call"), 3, UINT2NUM(index), (VALUE)Value(value), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Integer> Accessor::Info::query(uint32_t index) {
+    Accessor accessor(info->Data());
+    return v8::Integer::New(NUM2INT(rb_funcall(accessor.query, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Boolean> Accessor::Info::remove(uint32_t index) {
+    Accessor accessor(info->Data());
+    return v8::Boolean::New(Bool(rb_funcall(accessor.deleter, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Array> Accessor::Info::enumerateIndices() {
+    Accessor accessor(info->Data());
+    return Array(rb_funcall(accessor.enumerator, rb_intern("call"), 1, (VALUE)*this));
+  }
+
+  Accessor::Info::operator VALUE() {
+    return Data_Wrap_Struct(Class, 0, 0, (void*)this->info);
+  }
+}

data/ext/v8/array.cc

@@ -0,0 +1,26 @@
+#include "rr.h"
+
+namespace rr {
+
+void Array::Init() {
+  ClassBuilder("Array", Object::Class).
+    defineSingletonMethod("New", &New).
+    defineMethod("Length", &Length).
+    defineMethod("CloneElementAt", &CloneElementAt).
+    store(&Class);
+}
+
+VALUE Array::New(int argc, VALUE argv[], VALUE self) {
+  VALUE length; rb_scan_args(argc, argv, "01", &length);
+  return Array(v8::Array::New(RTEST(length) ? NUM2INT(length) : 0));
+}
+
+VALUE Array::Length(VALUE self) {
+  return UInt32(Array(self)->Length());
+}
+
+VALUE Array::CloneElementAt(VALUE self, VALUE index) {
+  return Object(Array(self)->CloneElementAt(UInt32(index)));
+}
+
+}

data/ext/v8/backref.cc

@@ -0,0 +1,45 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Backref::Storage;
+  ID Backref::_new;
+  ID Backref::object;
+
+  void Backref::Init() {
+    Storage = rb_eval_string("V8::Weak::Ref");
+    rb_gc_register_address(&Storage);
+    _new = rb_intern("new");
+    object = rb_intern("object");
+  }
+
+  Backref::Backref(VALUE initial) {
+    set(initial);
+    rb_gc_register_address(&storage);
+  }
+
+  Backref::~Backref() {
+    rb_gc_unregister_address(&storage);
+  }
+
+  VALUE Backref::set(VALUE data) {
+    this->storage = rb_funcall(Storage, _new, 1, data);
+    return data;
+  }
+
+  VALUE Backref::get() {
+    return rb_funcall(storage, object, 0);
+  }
+
+  v8::Handle<v8::Value> Backref::toExternal() {
+    v8::Local<v8::Value> wrapper = v8::External::New(this);
+    v8::Persistent<v8::Value>::New(wrapper).MakeWeak(this, &release);
+    return wrapper;
+  }
+
+  void Backref::release(v8::Persistent<v8::Value> handle, void* data) {
+    handle.Dispose();
+    Backref* backref = (Backref*)data;
+    delete backref;
+  }
+}

data/ext/v8/constants.cc

@@ -0,0 +1,34 @@
+#include "rr.h"
+
+namespace rr {
+  VALUE Constants::_Undefined;
+  VALUE Constants::_Null;
+  VALUE Constants::_True;
+  VALUE Constants::_False;
+  void Constants::Init() {
+    ModuleBuilder("V8::C").
+      defineSingletonMethod("Undefined", &Undefined).
+      defineSingletonMethod("Null", &Null).
+      defineSingletonMethod("True", &True).
+      defineSingletonMethod("False", &False);
+
+    _Undefined = _Null = _True = _False = Qnil;
+    rb_gc_register_address(&_Undefined);
+    rb_gc_register_address(&_Null);
+    rb_gc_register_address(&_True);
+    rb_gc_register_address(&_False);
+  }
+
+  VALUE Constants::Undefined(VALUE self) {
+    return cached<Primitive, v8::Primitive>(&_Undefined, v8::Undefined());
+  }
+  VALUE Constants::Null(VALUE self) {
+    return cached<Primitive, v8::Primitive>(&_Null, v8::Null());
+  }
+  VALUE Constants::True(VALUE self) {
+    return cached<Bool, v8::Boolean>(&_True, v8::True());
+  }
+  VALUE Constants::False(VALUE self) {
+    return cached<Bool, v8::Boolean>(&_False, v8::False());
+  }
+}

data/ext/v8/constraints.cc

@@ -0,0 +1,52 @@
+#include "rr.h"
+
+namespace rr {
+  void ResourceConstraints::Init() {
+    ClassBuilder("ResourceConstraints").
+      defineSingletonMethod("new", &initialize).
+      defineMethod("max_young_space_size", &max_young_space_size).
+      defineMethod("set_max_young_space_size", &set_max_young_space_size).
+      defineMethod("max_old_space_size", &max_old_space_size).
+      defineMethod("set_max_old_space_size", &set_max_old_space_size).
+      defineMethod("max_executable_size", &set_max_executable_size).
+      defineMethod("set_max_executable_size", &set_max_executable_size).
+      store(&Class);
+    ModuleBuilder("V8::C").
+      defineSingletonMethod("SetResourceConstraints", &SetResourceConstraints);
+  }
+
+  VALUE ResourceConstraints::SetResourceConstraints(VALUE self, VALUE constraints) {
+    Void(v8::SetResourceConstraints(ResourceConstraints(constraints)));
+  }
+
+  VALUE ResourceConstraints::initialize(VALUE self) {
+    return ResourceConstraints(new v8::ResourceConstraints());
+  }
+  VALUE ResourceConstraints::max_young_space_size(VALUE self) {
+    return INT2FIX(ResourceConstraints(self)->max_young_space_size());
+  }
+  VALUE ResourceConstraints::set_max_young_space_size(VALUE self, VALUE value) {
+    Void(ResourceConstraints(self)->set_max_young_space_size(NUM2INT(value)));
+  }
+  VALUE ResourceConstraints::max_old_space_size(VALUE self) {
+    return INT2FIX(ResourceConstraints(self)->max_old_space_size());
+  }
+  VALUE ResourceConstraints::set_max_old_space_size(VALUE self, VALUE value) {
+    Void(ResourceConstraints(self)->set_max_old_space_size(NUM2INT(value)));
+  }
+  VALUE ResourceConstraints::max_executable_size(VALUE self) {
+    return INT2FIX(ResourceConstraints(self)->max_executable_size());
+  }
+  VALUE ResourceConstraints::set_max_executable_size(VALUE self, VALUE value) {
+    Void(ResourceConstraints(self)->set_max_executable_size(NUM2INT(value)));
+  }
+
+  // What do these even mean?
+  // uint32_t* stack_limit() const { return stack_limit_; }
+  // // Sets an address beyond which the VM's stack may not grow.
+  // void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
+
+  template <> void Pointer<v8::ResourceConstraints>::unwrap(VALUE value) {
+    Data_Get_Struct(value, class v8::ResourceConstraints, pointer);
+  }
+}

data/ext/v8/context.cc

@@ -0,0 +1,130 @@
+#include "rr.h"
+
+namespace rr {
+
+void Context::Init() {
+  ClassBuilder("Context").
+    defineSingletonMethod("New", &New).
+    defineSingletonMethod("GetCurrent", &GetCurrent).
+    defineSingletonMethod("GetEntered", &GetEntered).
+    defineSingletonMethod("GetCalling", &GetCalling).
+    defineSingletonMethod("InContext", &InContext).
+    defineMethod("Dispose", &Dispose).
+    defineMethod("Global", &Global).
+    defineMethod("DetachGlobal", &Global).
+    defineMethod("ReattachGlobal", &ReattachGlobal).
+    defineMethod("SetSecurityToken", &SetSecurityToken).
+    defineMethod("UseDefaultSecurityToken", &UseDefaultSecurityToken).
+    defineMethod("GetSecurityToken", &GetSecurityToken).
+    defineMethod("HasOutOfMemoryException", &HasOutOfMemoryException).
+    defineMethod("SetEmbedderData", &SetEmbedderData).
+    defineMethod("GetEmbedderData", &GetEmbedderData).
+    defineMethod("AllowCodeGenerationFromStrings", &AllowCodeGenerationFromStrings).
+    defineMethod("IsCodeGenerationFromStringsAllowed", &IsCodeGenerationFromStringsAllowed).
+    defineMethod("Enter", &Enter).
+    defineMethod("Exit", &Exit).
+    store(&Class);
+  ClassBuilder("ExtensionConfiguration").
+    defineSingletonMethod("new", &ExtensionConfiguration::initialize).
+    store(&ExtensionConfiguration::Class);
+}
+
+VALUE Context::Dispose(VALUE self) {
+  Void(Context(self).dispose())
+}
+
+VALUE Context::Global(VALUE self) {
+  return Object(Context(self)->Global());
+}
+
+VALUE Context::DetachGlobal(VALUE self) {
+  Void(Context(self)->DetachGlobal());
+}
+
+VALUE Context::ReattachGlobal(VALUE self, VALUE global) {
+  Void(Context(self)->ReattachGlobal(Object(global)));
+}
+
+VALUE Context::GetEntered(VALUE self) {
+  return Context(v8::Context::GetEntered());
+}
+
+VALUE Context::GetCurrent(VALUE self) {
+  return Context(v8::Context::GetCurrent());
+}
+
+VALUE Context::GetCalling(VALUE self) {
+  return Context(v8::Context::GetCalling());
+}
+
+VALUE Context::SetSecurityToken(VALUE self, VALUE token) {
+  Void(Context(self)->SetSecurityToken(Value(token)));
+}
+
+VALUE Context::UseDefaultSecurityToken(VALUE self) {
+  Void(Context(self)->UseDefaultSecurityToken());
+}
+
+VALUE Context::GetSecurityToken(VALUE self) {
+  return Value(Context(self)->GetSecurityToken());
+}
+
+VALUE Context::HasOutOfMemoryException(VALUE self) {
+  return Bool(Context(self)->HasOutOfMemoryException());
+}
+
+VALUE Context::InContext(VALUE self) {
+  return Bool(v8::Context::InContext());
+}
+
+VALUE Context::SetEmbedderData(VALUE self, VALUE index, VALUE data) {
+  Void(Context(self)->SetEmbedderData(NUM2INT(index), Value(data)));
+}
+
+VALUE Context::GetEmbedderData(VALUE self, VALUE index) {
+  Void(Context(self)->GetEmbedderData(NUM2INT(index)));
+}
+
+VALUE Context::AllowCodeGenerationFromStrings(VALUE self, VALUE allow) {
+  Void(Context(self)->AllowCodeGenerationFromStrings(RTEST(allow)));
+}
+
+VALUE Context::IsCodeGenerationFromStringsAllowed(VALUE self) {
+  return Bool(Context(self)->IsCodeGenerationFromStringsAllowed());
+}
+
+VALUE ExtensionConfiguration::initialize(VALUE self, VALUE names) {
+  int length = RARRAY_LENINT(names);
+  const char* array[length];
+  for (int i = 0; i < length; i++) {
+    array[i] = RSTRING_PTR(rb_ary_entry(names, i));
+  }
+  return ExtensionConfiguration(new v8::ExtensionConfiguration(length, array));
+}
+
+VALUE Context::New(int argc, VALUE argv[], VALUE self) {
+  VALUE extension_configuration; VALUE global_template; VALUE global_object;
+  rb_scan_args(argc, argv, "03", &extension_configuration, &global_template, &global_object);
+  v8::Persistent<v8::Context> context(v8::Context::New(
+    ExtensionConfiguration(extension_configuration),
+    *ObjectTemplate(global_template),
+    *Object(global_object)
+  ));
+  Context reference(context);
+  context.Dispose();
+  return reference;
+}
+
+VALUE Context::Enter(VALUE self) {
+  Void(Context(self)->Enter());
+}
+
+VALUE Context::Exit(VALUE self) {
+  Void(Context(self)->Exit());
+}
+
+template <> void Pointer<v8::ExtensionConfiguration>::unwrap(VALUE value) {
+  Data_Get_Struct(value, class v8::ExtensionConfiguration, pointer);
+}
+
+}