therubyracer-tmpfork 0.12.2

data/ext/v8/gc.cc

@@ -0,0 +1,43 @@
+#include "rr.h"
+
+namespace rr {
+  GC::Queue* queue;
+
+  GC::Queue::Queue() : first(0), divider(0), last(0){
+    first = new GC::Queue::Node(NULL);
+    divider = first;
+    last = first;
+  }
+
+  void GC::Queue::Enqueue(void* reference) {
+    last->next = new Node(reference);
+    last = last->next;
+    while (first != divider) {
+      Node* tmp = first;
+      first = first->next;
+      delete tmp;
+    }
+  }
+
+  void* GC::Queue::Dequeue() {
+    void* result = NULL;
+    if (divider != last) {
+      result = divider->next->value;
+      divider = divider->next;
+    }
+    return result;
+  }
+
+  void GC::Finalize(void* phantom) {
+    queue->Enqueue(phantom);
+  }
+  void GC::Drain(v8::GCType type, v8::GCCallbackFlags flags) {
+    for(Phantom phantom = queue->Dequeue(); phantom.NotNull(); phantom = queue->Dequeue()) {
+      phantom.destroy();
+    }
+  }
+  void GC::Init() {
+    queue = new GC::Queue();
+    v8::V8::AddGCPrologueCallback(GC::Drain);
+  }
+}

data/ext/v8/handles.cc

@@ -0,0 +1,34 @@
+#include "rr.h"
+
+namespace rr {
+
+void Handles::Init() {
+  VALUE v8 = rb_define_module("V8");
+  VALUE c = rb_define_module_under(v8, "C");
+  rb_define_singleton_method(c, "HandleScope", (VALUE (*)(...))&HandleScope, -1);
+}
+
+VALUE Handles::HandleScope(int argc, VALUE* argv, VALUE self) {
+  if (!rb_block_given_p()) {
+    return Qnil;
+  }
+  int state = 0;
+  VALUE code;
+  rb_scan_args(argc,argv,"00&", &code);
+  VALUE result = SetupAndCall(&state, code);
+  if (state != 0) {
+    rb_jump_tag(state);
+  }
+  return result;
+}
+
+VALUE Handles::SetupAndCall(int* state, VALUE code) {
+  v8::HandleScope scope;
+  return rb_protect(&DoCall, code, state);
+}
+
+VALUE Handles::DoCall(VALUE code) {
+  return rb_funcall(code, rb_intern("call"), 0);
+}
+
+}

data/ext/v8/heap.cc

@@ -0,0 +1,35 @@
+#include "rr.h"
+
+namespace rr {
+  void HeapStatistics::Init() {
+    ClassBuilder("HeapStatistics").
+      defineSingletonMethod("new", &initialize).
+      defineMethod("total_heap_size", &total_heap_size).
+      defineMethod("total_heap_size_executable", &total_heap_size_executable).
+      defineMethod("total_physical_size", &total_physical_size).
+      defineMethod("used_heap_size", &used_heap_size).
+      defineMethod("heap_size_limit", &heap_size_limit).
+      store(&Class);
+  }
+  VALUE HeapStatistics::initialize(VALUE self) {
+    return HeapStatistics(new v8::HeapStatistics());
+  }
+  VALUE HeapStatistics::total_heap_size(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->total_heap_size());
+  }
+  VALUE HeapStatistics::total_heap_size_executable(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->total_heap_size_executable());
+  }
+  VALUE HeapStatistics::total_physical_size(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->total_physical_size());
+  }
+  VALUE HeapStatistics::used_heap_size(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->used_heap_size());
+  }
+  VALUE HeapStatistics::heap_size_limit(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->heap_size_limit());
+  }
+  template <> void Pointer<v8::HeapStatistics>::unwrap(VALUE value) {
+    Data_Get_Struct(value, class v8::HeapStatistics, pointer);
+  }
+}

data/ext/v8/init.cc

@@ -0,0 +1,39 @@
+#include "rr.h"
+
+extern "C" {
+  void Init_init();
+}
+
+using namespace rr;
+
+extern "C" {
+  void Init_init() {
+    v8::Locker lock();
+    GC::Init();
+    V8::Init();
+    Handles::Init();
+    Accessor::Init();
+    Context::Init();
+    Invocation::Init();
+    Signature::Init();
+    Value::Init();
+    Primitive::Init();
+    String::Init();
+    Object::Init();
+    Array::Init();
+    Function::Init();
+    Date::Init();
+    Constants::Init();
+    External::Init();
+    Script::Init();
+    Template::Init();
+    Stack::Init();
+    Message::Init();
+    TryCatch::Init();
+    Exception::Init();
+    Locker::Init();
+    ResourceConstraints::Init();
+    HeapStatistics::Init();
+    Backref::Init();
+  }
+}

data/ext/v8/invocation.cc

@@ -0,0 +1,86 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Invocation::Arguments::Class;
+
+  void Invocation::Init() {
+    Arguments::Init();
+  }
+
+  void Invocation::Arguments::Init() {
+    ClassBuilder("Arguments").
+      defineMethod("Length", &Length).
+      defineMethod("[]", &Get).
+      defineMethod("Callee", &Callee).
+      defineMethod("This", &This).
+      defineMethod("Holder", &Holder).
+      defineMethod("IsConstructCall", &IsConstructCall).
+      defineMethod("Data", &Data).
+    store(&Invocation::Arguments::Class);
+  }
+
+  Invocation::Invocation(VALUE code, VALUE data) {
+    this->code = code;
+    this->data = data;
+  }
+  Invocation::Invocation(v8::Handle<v8::Value> value) {
+    v8::Local<v8::Object> wrapper = value->ToObject();
+    this->code = External::unwrap((v8::Handle<v8::External>)v8::External::Cast(*wrapper->Get(0)));
+    this->data = Value(wrapper->Get(1));
+  }
+  Invocation::operator v8::InvocationCallback() {
+    return &Callback;
+  }
+  Invocation::operator v8::Handle<v8::Value>() {
+    v8::Local<v8::Object> wrapper = v8::Object::New();
+    wrapper->Set(0, External::wrap(this->code));
+    wrapper->Set(1, Value(this->data));
+    return wrapper;
+  }
+
+  v8::Handle<v8::Value> Invocation::Callback(const v8::Arguments& args) {
+    return Arguments(args).Call();
+  }
+
+  Invocation::Arguments::Arguments(const v8::Arguments& args) {
+    this->args = &args;
+  }
+
+  Invocation::Arguments::Arguments(VALUE value) {
+    Data_Get_Struct(value, class v8::Arguments, args);
+  }
+
+  v8::Handle<v8::Value> Invocation::Arguments::Call() {
+    Invocation invocation(args->Data());
+    return Value(rb_funcall(invocation.code, rb_intern("call"), 1, Data_Wrap_Struct(Class, 0, 0, (void*)this->args)));
+  }
+
+  VALUE Invocation::Arguments::Length(VALUE self) {
+    return INT2FIX(Arguments(self)->Length());
+  }
+
+  VALUE Invocation::Arguments::Get(VALUE self, VALUE index) {
+    return Value((*Arguments(self))[NUM2INT(index)]);
+  }
+
+  VALUE Invocation::Arguments::Callee(VALUE self) {
+    return Function(Arguments(self)->Callee());
+  }
+
+  VALUE Invocation::Arguments::This(VALUE self) {
+    return Object(Arguments(self)->This());
+  }
+
+  VALUE Invocation::Arguments::Holder(VALUE self) {
+    return Object(Arguments(self)->Holder());
+  }
+
+  VALUE Invocation::Arguments::IsConstructCall(VALUE self) {
+    return Bool(Arguments(self)->IsConstructCall());
+  }
+
+  VALUE Invocation::Arguments::Data(VALUE self) {
+    return Invocation(Arguments(self)->Data()).data;
+  }
+}

data/ext/v8/locker.cc

@@ -0,0 +1,77 @@
+#include "rr.h"
+
+namespace rr {
+  void Locker::Init() {
+    ClassBuilder("Locker").
+      defineSingletonMethod("StartPreemption", &StartPreemption).
+      defineSingletonMethod("StopPreemption", &StopPreemption).
+      defineSingletonMethod("IsLocked", &IsLocked).
+      defineSingletonMethod("IsActive", &IsActive);
+      VALUE v8 = rb_define_module("V8");
+      VALUE c = rb_define_module_under(v8, "C");
+      rb_define_singleton_method(c, "Locker", (VALUE (*)(...))&doLock, -1);
+      rb_define_singleton_method(c, "Unlocker",(VALUE (*)(...))&doUnlock, -1);
+  }
+
+   VALUE Locker::StartPreemption(VALUE self, VALUE every_n_ms) {
+     Void(v8::Locker::StartPreemption(NUM2INT(every_n_ms)));
+   }
+
+   VALUE Locker::StopPreemption(VALUE self) {
+     Void(v8::Locker::StopPreemption());
+   }
+
+   VALUE Locker::IsLocked(VALUE self) {
+     return Bool(v8::Locker::IsLocked(v8::Isolate::GetCurrent()));
+   }
+
+   VALUE Locker::IsActive(VALUE self) {
+     return Bool(v8::Locker::IsActive());
+   }
+
+   VALUE Locker::doLock(int argc, VALUE* argv, VALUE self) {
+     if (!rb_block_given_p()) {
+       return Qnil;
+     }
+     int state = 0;
+     VALUE code;
+     rb_scan_args(argc,argv,"00&", &code);
+     VALUE result = setupLockAndCall(&state, code);
+     if (state != 0) {
+       rb_jump_tag(state);
+     }
+     return result;
+   }
+
+   VALUE Locker::setupLockAndCall(int* state, VALUE code) {
+     v8::Locker locker;
+     return rb_protect(&doLockCall, code, state);
+   }
+
+   VALUE Locker::doLockCall(VALUE code) {
+     return rb_funcall(code, rb_intern("call"), 0);
+   }
+
+   VALUE Locker::doUnlock(int argc, VALUE* argv, VALUE self) {
+     if (!rb_block_given_p()) {
+       return Qnil;
+     }
+     int state = 0;
+     VALUE code;
+     rb_scan_args(argc,argv,"00&", &code);
+     VALUE result = setupUnlockAndCall(&state, code);
+     if (state != 0) {
+       rb_jump_tag(state);
+     }
+     return result;
+   }
+
+   VALUE Locker::setupUnlockAndCall(int* state, VALUE code) {
+     v8::Unlocker unlocker;
+     return rb_protect(&doUnlockCall, code, state);
+   }
+
+   VALUE Locker::doUnlockCall(VALUE code) {
+     return rb_funcall(code, rb_intern("call"), 0);
+   }
+}

data/ext/v8/message.cc

@@ -0,0 +1,51 @@
+#include "rr.h"
+
+namespace rr {
+
+  void Message::Init() {
+    ClassBuilder("Message").
+      defineMethod("Get", &Get).
+      defineMethod("GetSourceLine", &GetSourceLine).
+      defineMethod("GetScriptResourceName", &GetScriptResourceName).
+      defineMethod("GetScriptData", &GetScriptData).
+      defineMethod("GetStackTrace", &GetStackTrace).
+      defineMethod("GetLineNumber", &GetLineNumber).
+      defineMethod("GetStartPosition", &GetStartPosition).
+      defineMethod("GetEndPosition", &GetEndPosition).
+      defineMethod("GetStartColumn", &GetEndColumn).
+      defineSingletonMethod("kNoLineNumberInfo", &kNoLineNumberInfo).
+      defineSingletonMethod("kNoColumnInfo", &kNoColumnInfo).
+      store(&Class);
+  }
+
+  VALUE Message::Get(VALUE self) {
+    return String(Message(self)->Get());
+  }
+  VALUE Message::GetSourceLine(VALUE self) {
+    return String(Message(self)->GetSourceLine());
+  }
+  VALUE Message::GetScriptResourceName(VALUE self) {
+    return Value(Message(self)->GetScriptResourceName());
+  }
+  VALUE Message::GetScriptData(VALUE self) {
+    return Value(Message(self)->GetScriptData());
+  }
+  VALUE Message::GetStackTrace(VALUE self) {
+    return Stack::Trace(Message(self)->GetStackTrace());
+  }
+  VALUE Message::GetLineNumber(VALUE self) {
+    return INT2FIX(Message(self)->GetLineNumber());
+  }
+  VALUE Message::GetStartPosition(VALUE self) {
+    return INT2FIX(Message(self)->GetStartPosition());
+  }
+  VALUE Message::GetEndPosition(VALUE self) {
+    return INT2FIX(Message(self)->GetEndPosition());
+  }
+  VALUE Message::GetStartColumn(VALUE self) {
+    return INT2FIX(Message(self)->GetStartColumn());
+  }
+  VALUE Message::GetEndColumn(VALUE self) {
+    return INT2FIX(Message(self)->GetEndColumn());
+  }
+}

data/ext/v8/object.cc

@@ -0,0 +1,335 @@
+#include "rr.h"
+
+namespace rr {
+
+void Object::Init() {
+  ClassBuilder("Object", Value::Class).
+    defineSingletonMethod("New", &New).
+    defineMethod("Set", &Set).
+    defineMethod("ForceSet", &ForceSet).
+    defineMethod("Get", &Get).
+    defineMethod("GetPropertyAttributes", &GetPropertyAttributes).
+    defineMethod("Has", &Has).
+    defineMethod("Delete", &Delete).
+    defineMethod("ForceDelete", &ForceDelete).
+    defineMethod("SetAccessor", &SetAccessor).
+    defineMethod("GetPropertyNames", &GetPropertyNames).
+    defineMethod("GetOwnPropertyNames", &GetOwnPropertyNames).
+    defineMethod("GetPrototype", &GetPrototype).
+    defineMethod("SetPrototype", &SetPrototype).
+    defineMethod("FindInstanceInPrototypeChain", &FindInstanceInPrototypeChain).
+    defineMethod("ObjectProtoToString", &ObjectProtoToString).
+    defineMethod("GetConstructorName", &GetConstructorName).
+    defineMethod("InternalFieldCount", &InternalFieldCount).
+    defineMethod("GetInternalField", &GetInternalField).
+    defineMethod("SetInternalField", &SetInternalField).
+    defineMethod("HasOwnProperty", &HasOwnProperty).
+    defineMethod("HasRealNamedProperty", &HasRealNamedProperty).
+    defineMethod("HasRealIndexedProperty", &HasRealIndexedProperty).
+    defineMethod("HasRealNamedCallbackProperty", &HasRealNamedCallbackProperty).
+    defineMethod("GetRealNamedPropertyInPrototypeChain", &GetRealNamedPropertyInPrototypeChain).
+    defineMethod("GetRealNamedProperty", &GetRealNamedProperty).
+    defineMethod("HasNamedLookupInterceptor", &HasNamedLookupInterceptor).
+    defineMethod("HasIndexedLookupInterceptor", &HasIndexedLookupInterceptor).
+    defineMethod("TurnOnAccessCheck", &TurnOnAccessCheck).
+    defineMethod("GetIdentityHash", &GetIdentityHash).
+    defineMethod("SetHiddenValue", &SetHiddenValue).
+    defineMethod("GetHiddenValue", &GetHiddenValue).
+    defineMethod("DeleteHiddenValue", &DeleteHiddenValue).
+    defineMethod("IsDirty", &IsDirty).
+    defineMethod("Clone", &Clone).
+    defineMethod("CreationContext", &CreationContext).
+    defineMethod("SetIndexedPropertiesToPixelData", &SetIndexedPropertiesToPixelData).
+    defineMethod("GetIndexedPropertiesPixelData", &GetIndexedPropertiesPixelData).
+    defineMethod("HasIndexedPropertiesToPixelData", &HasIndexedPropertiesInPixelData).
+    defineMethod("GetIndexedPropertiesPixelDataLength", &GetIndexedPropertiesPixelDataLength).
+    defineMethod("SetIndexedPropertiesToExternalArrayData", &SetIndexedPropertiesToExternalArrayData).
+    defineMethod("HasIndexedPropertiesInExternalArrayData", &HasIndexedPropertiesInExternalArrayData).
+    defineMethod("GetIndexedPropertiesExternalArrayData", &GetIndexedPropertiesExternalArrayData).
+    defineMethod("GetIndexedPropertiesExternalArrayDataType", &GetIndexedPropertiesExternalArrayDataType).
+    defineMethod("GetIndexedPropertiesExternalArrayDataLength", &GetIndexedPropertiesExternalArrayDataLength).
+    defineMethod("IsCallable", &IsCallable).
+    defineMethod("CallAsFunction", &CallAsFunction).
+    defineMethod("CallAsConstructor", &CallAsConstructor).
+    store(&Class);
+  ClassBuilder("PropertyAttribute").
+    defineEnumConst("None", v8::None).
+    defineEnumConst("ReadOnly", v8::ReadOnly).
+    defineEnumConst("DontEnum", v8::DontEnum).
+    defineEnumConst("DontDelete", v8::DontDelete);
+  ClassBuilder("AccessControl").
+    defineEnumConst("DEFAULT", v8::DEFAULT).
+    defineEnumConst("ALL_CAN_READ", v8::ALL_CAN_READ).
+    defineEnumConst("ALL_CAN_WRITE", v8::ALL_CAN_WRITE).
+    defineEnumConst("PROHIBITS_OVERWRITING", v8::PROHIBITS_OVERWRITING);
+}
+
+
+VALUE Object::New(VALUE self) {
+  return Object(v8::Object::New());
+}
+
+//TODO: Allow setting of property attributes
+VALUE Object::Set(VALUE self, VALUE key, VALUE value) {
+  if (rb_obj_is_kind_of(key, rb_cNumeric)) {
+    return Bool(Object(self)->Set(UInt32(key), Value(value)));
+  } else {
+    return Bool(Object(self)->Set(*Value(key), Value(value)));
+  }
+}
+
+VALUE Object::ForceSet(VALUE self, VALUE key, VALUE value) {
+  return Bool(Object(self)->ForceSet(Value(key), Value(value)));
+}
+
+VALUE Object::Get(VALUE self, VALUE key) {
+  if (rb_obj_is_kind_of(key, rb_cNumeric)) {
+    return Value(Object(self)->Get(UInt32(key)));
+  } else {
+    return Value(Object(self)->Get(*Value(key)));
+  }
+}
+
+VALUE Object::GetPropertyAttributes(VALUE self, VALUE key) {
+  return PropertyAttribute(Object(self)->GetPropertyAttributes(Value(key)));
+}
+
+VALUE Object::Has(VALUE self, VALUE key) {
+  Object obj(self);
+  if (rb_obj_is_kind_of(key, rb_cNumeric)) {
+    return Bool(obj->Has(UInt32(key)));
+  } else {
+    return Bool(obj->Has(*String(key)));
+  }
+}
+
+VALUE Object::Delete(VALUE self, VALUE key) {
+  Object obj(self);
+  if (rb_obj_is_kind_of(key, rb_cNumeric)) {
+    return Bool(obj->Delete(UInt32(key)));
+  } else {
+    return Bool(obj->Delete(*String(key)));
+  }
+}
+
+VALUE Object::ForceDelete(VALUE self, VALUE key) {
+  return Bool(Object(self)->ForceDelete(Value(key)));
+}
+
+
+VALUE Object::SetAccessor(int argc, VALUE* argv, VALUE self) {
+  VALUE name; VALUE get; VALUE set; VALUE data; VALUE settings; VALUE attribs;
+  rb_scan_args(argc, argv, "24", &name, &get, &set, &data, &settings, &attribs);
+  Accessor access(get, set, data);
+  return Bool(Object(self)->SetAccessor(
+    String(name),
+    access.accessorGetter(),
+    access.accessorSetter(),
+    access,
+    AccessControl(settings),
+    PropertyAttribute(attribs))
+  );
+}
+
+Object::operator VALUE() {
+  if (handle.IsEmpty()) {
+    return Qnil;
+  }
+  Backref* backref;
+  v8::Local<v8::String> key(v8::String::NewSymbol("rr::Backref"));
+  v8::Local<v8::Value> external = handle->GetHiddenValue(key);
+  VALUE value;
+  if (external.IsEmpty()) {
+    value = downcast();
+    backref = new Backref(value);
+    handle->SetHiddenValue(key, backref->toExternal());
+  } else {
+    v8::Local<v8::External> wrapper = v8::External::Cast(*external);
+    backref = (Backref*)wrapper->Value();
+    value = backref->get();
+    if (!RTEST(value)) {
+      value = downcast();
+      backref->set(value);
+    }
+  }
+  return value;
+}
+
+VALUE Object::downcast() {
+  if (handle->IsFunction()) {
+    return Function((v8::Handle<v8::Function>) v8::Function::Cast(*handle));
+  }
+  if (handle->IsArray()) {
+    return Array((v8::Handle<v8::Array>)v8::Array::Cast(*handle));
+  }
+  if (handle->IsDate()) {
+    // return Date(handle);
+  }
+  if (handle->IsBooleanObject()) {
+    // return BooleanObject(handle);
+  }
+  if (handle->IsNumberObject()) {
+    // return NumberObject(handle);
+  }
+  if (handle->IsStringObject()) {
+    // return StringObject(handle);
+  }
+  if (handle->IsRegExp()) {
+    // return RegExp(handle);
+  }
+  return Ref<v8::Object>::operator VALUE();
+}
+
+VALUE Object::GetPropertyNames(VALUE self) {
+  return Array(Object(self)->GetPropertyNames());
+}
+
+VALUE Object::GetOwnPropertyNames(VALUE self) {
+  return Array(Object(self)->GetOwnPropertyNames());
+}
+
+VALUE Object::GetPrototype(VALUE self) {
+  return Value(Object(self)->GetPrototype());
+}
+
+VALUE Object::SetPrototype(VALUE self, VALUE prototype) {
+  return Bool(Object(self)->SetPrototype(Value(prototype)));
+}
+
+VALUE Object::FindInstanceInPrototypeChain(VALUE self, VALUE impl) {
+  return Object(Object(self)->FindInstanceInPrototypeChain(FunctionTemplate(impl)));
+}
+
+VALUE Object::ObjectProtoToString(VALUE self) {
+  return String(Object(self)->ObjectProtoToString());
+}
+
+VALUE Object::GetConstructorName(VALUE self) {
+  return String(Object(self)->GetConstructorName());
+}
+
+VALUE Object::InternalFieldCount(VALUE self) {
+  return INT2FIX(Object(self)->InternalFieldCount());
+}
+
+VALUE Object::GetInternalField(VALUE self, VALUE idx) {
+  return Value(Object(self)->GetInternalField(NUM2INT(idx)));
+}
+
+VALUE Object::SetInternalField(VALUE self, VALUE idx, VALUE value) {
+  Void(Object(self)->SetInternalField(NUM2INT(idx), Value(value)));
+}
+
+VALUE Object::HasOwnProperty(VALUE self, VALUE key) {
+  return Bool(Object(self)->HasOwnProperty(String(key)));
+}
+
+VALUE Object::HasRealNamedProperty(VALUE self, VALUE key) {
+  return Bool(Object(self)->HasRealNamedProperty(String(key)));
+}
+
+VALUE Object::HasRealIndexedProperty(VALUE self, VALUE idx) {
+  return Bool(Object(self)->HasRealIndexedProperty(UInt32(idx)));
+}
+
+VALUE Object::HasRealNamedCallbackProperty(VALUE self, VALUE key) {
+  return Bool(Object(self)->HasRealNamedCallbackProperty(String(key)));
+}
+
+VALUE Object::GetRealNamedPropertyInPrototypeChain(VALUE self, VALUE key) {
+  return Value(Object(self)->GetRealNamedPropertyInPrototypeChain(String(key)));
+}
+
+VALUE Object::GetRealNamedProperty(VALUE self, VALUE key) {
+  return Value(Object(self)->GetRealNamedProperty(String(key)));
+}
+
+VALUE Object::HasNamedLookupInterceptor(VALUE self) {
+  return Bool(Object(self)->HasNamedLookupInterceptor());
+}
+
+VALUE Object::HasIndexedLookupInterceptor(VALUE self) {
+  return Bool(Object(self)->HasIndexedLookupInterceptor());
+}
+
+VALUE Object::TurnOnAccessCheck(VALUE self) {
+  Void(Object(self)->TurnOnAccessCheck());
+}
+
+VALUE Object::GetIdentityHash(VALUE self) {
+  return INT2FIX(Object(self)->GetIdentityHash());
+}
+
+VALUE Object::SetHiddenValue(VALUE self, VALUE key, VALUE value) {
+  return Bool(Object(self)->SetHiddenValue(String(key), Value(value)));
+}
+
+VALUE Object::GetHiddenValue(VALUE self, VALUE key) {
+  return Value(Object(self)->GetHiddenValue(String(key)));
+}
+
+VALUE Object::DeleteHiddenValue(VALUE self, VALUE key) {
+  return Bool(Object(self)->DeleteHiddenValue(String(key)));
+}
+
+VALUE Object::IsDirty(VALUE self) {
+  return Bool(Object(self)->IsDirty());
+}
+
+VALUE Object::Clone(VALUE self) {
+  return Object(Object(self)->Clone());
+}
+
+VALUE Object::CreationContext(VALUE self) {
+  return Context(Object(self)->CreationContext());
+}
+
+VALUE Object::SetIndexedPropertiesToPixelData(VALUE self, VALUE data, VALUE length) {
+  return not_implemented("SetIndexedPropertiesToPixelData");
+}
+
+VALUE Object::GetIndexedPropertiesPixelData(VALUE self) {
+  return not_implemented("GetIndexedPropertiesPixelData");
+}
+
+VALUE Object::HasIndexedPropertiesInPixelData(VALUE self) {
+  return Bool(Object(self)->HasIndexedPropertiesInPixelData());
+}
+
+VALUE Object::GetIndexedPropertiesPixelDataLength(VALUE self) {
+  return INT2FIX(Object(self)->GetIndexedPropertiesPixelDataLength());
+}
+
+VALUE Object::SetIndexedPropertiesToExternalArrayData(VALUE self) {
+  return not_implemented("SetIndexedPropertiesToExternalArrayData");
+}
+
+VALUE Object::HasIndexedPropertiesInExternalArrayData(VALUE self) {
+  return Bool(Object(self)->HasIndexedPropertiesInExternalArrayData());
+}
+
+VALUE Object::GetIndexedPropertiesExternalArrayData(VALUE self) {
+  return not_implemented("GetIndexedPropertiesExternalArrayData");
+}
+
+VALUE Object::GetIndexedPropertiesExternalArrayDataType(VALUE self) {
+  return not_implemented("GetIndexedPropertiesExternalArrayDataType");
+}
+
+VALUE Object::GetIndexedPropertiesExternalArrayDataLength(VALUE self) {
+  return INT2FIX(Object(self)->GetIndexedPropertiesExternalArrayDataLength());
+}
+
+VALUE Object::IsCallable(VALUE self) {
+  return Bool(Object(self)->IsCallable());
+}
+
+VALUE Object::CallAsFunction(VALUE self, VALUE recv, VALUE argv) {
+  return Value(Object(self)->CallAsFunction(Object(recv), RARRAY_LENINT(argv), Value::array<Value>(argv)));
+}
+
+VALUE Object::CallAsConstructor(VALUE self, VALUE argv) {
+  return Value(Object(self)->CallAsConstructor(RARRAY_LENINT(argv), Value::array<Value>(argv)));
+}
+
+}