therubyracer 0.9.0beta2 → 0.9.0beta3

data/ext/v8/upstream/v8/tools/visual_studio/x64.vsprops

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	OutputDirectory="$(SolutionDir)$(ConfigurationName)64"
+	IntermediateDirectory="$(SolutionDir)$(ConfigurationName)64\obj\$(ProjectName)"
+	Name="x64"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		PreprocessorDefinitions="V8_TARGET_ARCH_X64"
+	/>
+	<Tool
+		Name="VCLinkerTool"
+                StackReserveSize="2091752"
+		TargetMachine="17"
+	/>
+</VisualStudioPropertySheet>

data/ext/v8/v8_callbacks.cpp

@@ -7,115 +7,75 @@ using namespace v8;
 namespace {
   VALUE ArgumentsClass;
   VALUE AccessorInfoClass;
-    
-  struct Wrap {
-    Persistent<Object> thisObj;
-    Persistent<Object> holder;
-    Persistent<Value> data;
-    Wrap(Handle<Object> thisObj, Handle<Object> holder, Handle<Value> data);
-    virtual ~Wrap();
-  };
   
-  Wrap::Wrap(Handle<Object> thisObj_, Handle<Object> holder_, Handle<Value> data_) : 
-    thisObj(Persistent<Object>::New(thisObj_)), 
-    holder(Persistent<Object>::New(holder_)), 
-    data(Persistent<Value>::New(data_)) {}
-  Wrap::~Wrap() {
-    thisObj.Dispose();
-    holder.Dispose();
-    data.Dispose();
-  }
-  void gc_wrap_mark(Wrap *wrapper) {}
-  void gc_wrap_free(Wrap *wrapper) {
-    delete wrapper;
+  VALUE _Data(VALUE self) {
+    return rb_iv_get(self, "data");
   }
-  
-  struct WrapArguments : Wrap {
-    int length;
-    Persistent<Function> callee;
-    bool isConstructCall;
-    Persistent<Array> values;
-    WrapArguments(const Arguments& arguments);
-    virtual ~WrapArguments();    
-  };
-  
-  WrapArguments::WrapArguments(const Arguments& arguments) : Wrap(arguments.This(), arguments.Holder(), arguments.Data()),
-    callee(Persistent<Function>::New(arguments.Callee())),
-    values(Persistent<Array>::New(Array::New(arguments.Length()))) {
-    length = arguments.Length();
-    isConstructCall = arguments.IsConstructCall();
-    for (int i = 0; i < arguments.Length(); i++) {
-      values->Set(Integer::New(i), arguments[i]);
+
+  namespace Accessor {
+    AccessorInfo *info(VALUE value) {
+      AccessorInfo* i = 0;
+      Data_Get_Struct(value, class AccessorInfo, i);
+      return i;
+    }
+    VALUE This(VALUE self) {
+      return rr_v82rb(info(self)->This());
+    }
+    VALUE Holder(VALUE self) {
+      return rr_v82rb(info(self)->Holder());
     }
-  }
-    
-  WrapArguments::~WrapArguments() {
-    callee.Dispose();
-    values.Dispose();
-  }
-  
-  Wrap *info(VALUE value) {
-    Wrap *wrap = 0;
-    Data_Get_Struct(value, struct Wrap, wrap);
-    return wrap;
-  }
-  
-  WrapArguments* args(VALUE value) {
-    WrapArguments *wrap = 0;
-    Data_Get_Struct(value, struct WrapArguments, wrap);
-    return wrap;
   }
   
-  VALUE Length(VALUE self) {
-    return rr_v82rb(args(self)->length);
-  }
-  VALUE Get(VALUE self, VALUE index) {
-    int i = NUM2INT(index);
-    return rr_v82rb(args(self)->values->Get(i));
-  }
-  VALUE Callee(VALUE self) {
-    return rr_v82rb(args(self)->callee);
-  }
-  VALUE This(VALUE self) {
-    return rr_v82rb(info(self)->thisObj);    
-  }
-  VALUE Holder(VALUE self) {
-    return rr_v82rb(info(self)->holder);    
-  }
-  VALUE IsConstructCall(VALUE self) {
-    return rr_v82rb(args(self)->isConstructCall);
-  }
-  VALUE _Data(VALUE self) {
-    return rb_iv_get(self, "data");
+  namespace Args {
+    Arguments* args(VALUE value) {
+      Arguments *arguments = 0;
+      Data_Get_Struct(value, class Arguments, arguments);
+      return arguments;
+    }
+    VALUE This(VALUE self) {
+      return rr_v82rb(args(self)->This());    
+    }
+
+    VALUE Holder(VALUE self) {
+      return rr_v82rb(args(self)->Holder());
+    }
+
+    VALUE Length(VALUE self) {
+      return rr_v82rb(args(self)->Length());
+    }
+    VALUE Get(VALUE self, VALUE index) {
+      int i = NUM2INT(index);
+      return rr_v82rb((*args(self))[i]);
+    }
+    VALUE Callee(VALUE self) {
+      return rr_v82rb(args(self)->Callee());
+    }
+    VALUE IsConstructCall(VALUE self) {
+      return rr_v82rb(args(self)->IsConstructCall());
+    }
   }
-  
-  struct WrapAccessorInfo : Wrap {
-    WrapAccessorInfo(const AccessorInfo& info);
-  };
-  WrapAccessorInfo::WrapAccessorInfo(const AccessorInfo& info) : Wrap(info.This(), info.Holder(), info.Data()) {}
-  
+
 }
 
 void rr_init_v8_callbacks() {
   AccessorInfoClass = rr_define_class("AccessorInfo");
-  rr_define_method(AccessorInfoClass, "This", This, 0);
-  rr_define_method(AccessorInfoClass, "Holder", Holder, 0);
+  rr_define_method(AccessorInfoClass, "This", Accessor::This, 0);
+  rr_define_method(AccessorInfoClass, "Holder", Accessor::Holder, 0);
   rr_define_method(AccessorInfoClass, "Data", _Data, 0);
   
   ArgumentsClass = rr_define_class("Arguments");
-  rr_define_method(ArgumentsClass, "This", This, 0);
-  rr_define_method(ArgumentsClass, "Holder", Holder, 0);
+  rr_define_method(ArgumentsClass, "This", Args::This, 0);
+  rr_define_method(ArgumentsClass, "Holder", Args::Holder, 0);
   rr_define_method(ArgumentsClass, "Data", _Data, 0);
-  rr_define_method(ArgumentsClass, "Length", Length, 0);
-  rr_define_method(ArgumentsClass, "Callee", Callee, 0);
-  rr_define_method(ArgumentsClass, "IsConstructCall", IsConstructCall, 0);
-  rr_define_method(ArgumentsClass, "[]", Get, 1);
+  rr_define_method(ArgumentsClass, "Length", Args::Length, 0);
+  rr_define_method(ArgumentsClass, "Callee", Args::Callee, 0);
+  rr_define_method(ArgumentsClass, "IsConstructCall", Args::IsConstructCall, 0);
+  rr_define_method(ArgumentsClass, "[]", Args::Get, 1);
 }
 
 VALUE rr_v82rb(const AccessorInfo& info) {
-  return Data_Wrap_Struct(AccessorInfoClass, gc_wrap_mark, gc_wrap_free, new WrapAccessorInfo(info));
+  return Data_Wrap_Struct(AccessorInfoClass, 0, 0, (void*)&info);
 }
-
 VALUE rr_v82rb(const Arguments& arguments) {
-  return Data_Wrap_Struct(ArgumentsClass, gc_wrap_mark, gc_wrap_free, new WrapArguments(arguments));  
+  return Data_Wrap_Struct(ArgumentsClass, 0, 0, (void*)&arguments);
 }

data/ext/v8/v8_date.cpp

@@ -2,6 +2,7 @@
 #include "v8_date.h"
 #include "v8_value.h"
 #include "v8_handle.h"
+#include "v8_object.h"
 
 using namespace v8;
 
@@ -29,7 +30,5 @@ void rr_init_v8_date() {
 }
 
 VALUE rr_reflect_v8_date(Handle<Value> value) {
-  HandleScope hs;
-  Local<Date> date(Date::Cast(*value));
-  return rr_v8_handle_new(DateClass, date);
+  return rr_reflect_v8_object_as(Handle<Object>::Cast(value), DateClass);
 }

data/ext/v8/v8_object.cpp

@@ -52,6 +52,9 @@ namespace {
     Local<Value> names = object->GetPropertyNames();
     return rr_v82rb(names);
   }
+  VALUE GetIdentityHash(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetIdentityHash());
+  }
   VALUE SetHiddenValue(VALUE self, VALUE key, VALUE value) {
     HandleScope scope;
     if (Context::InContext()) {
@@ -86,6 +89,7 @@ void rr_init_object() {
   rr_define_method(ObjectClass, "Get", Get, 1);
   rr_define_method(ObjectClass, "Set", Set, 2);
   rr_define_method(ObjectClass, "GetPropertyNames", GetPropertyNames, 0);
+  rr_define_method(ObjectClass, "GetIdentityHash", GetIdentityHash, 0);
   rr_define_method(ObjectClass, "GetHiddenValue", GetHiddenValue, 1);
   rr_define_method(ObjectClass, "SetHiddenValue", SetHiddenValue, 2);
   rr_define_method(ObjectClass, "GetPrototype", GetPrototype, 0);

data/ext/v8/v8_template.cpp

@@ -59,9 +59,9 @@ namespace {
   Handle<Value> RubyInvocationCallback(const Arguments& args) {
     Handle<External> v8_data_wrapper = Handle<External>::Cast(args.Data());
     v8_callback_data* v8_data = (v8_callback_data*)v8_data_wrapper->Value();
-    VALUE rb_args = rr_v82rb(args);
-    rb_iv_set(rb_args, "data", v8_data->data);
     if (RTEST(v8_data->handler)) {
+    VALUE rb_args = rr_v82rb(args);
+      rb_iv_set(rb_args, "data", v8_data->data);
       VALUE result = rb_funcall(v8_data->handler, rb_intern("call"), 1, rb_args);
       return rr_rb2v8(result);
     } else {

data/ext/v8/v8_try_catch.cpp

@@ -7,43 +7,14 @@ using namespace v8;
 namespace {
   VALUE TryCatchClass;
 
-  struct try_catch {
-    TryCatch *tc;
-    bool alive;
-    try_catch(TryCatch *ptr);
-  };
-
-  try_catch::try_catch(TryCatch *ptr) :tc(ptr) {
-    this->alive = true;
-  }
-  
-  struct kill_try_catch {
-    try_catch *tc;
-    kill_try_catch(try_catch *ptr);
-    ~kill_try_catch();
-  };
-  kill_try_catch::kill_try_catch(try_catch *ptr) : tc(ptr) {}
-  kill_try_catch::~kill_try_catch() {
-    tc->alive = false;
-  }
-  
-  
-  void mark_try_catch(try_catch *tc) {
-    //nothing to mark since the TryCatch object is stack allocated.
-  }
-  
-  void free_try_catch(try_catch *ptr) {
-    delete ptr;
-  }
-  
   TryCatch *unwrap(VALUE self) {
-    try_catch *ref = 0;
-    Data_Get_Struct(self, struct try_catch, ref);
-    if (ref->alive) {
-      return ref->tc;
-    } else {
+    TryCatch *tc = 0;
+    Data_Get_Struct(self, class TryCatch, tc);
+    if (RTEST(rb_iv_get(self, "dead"))) {
       rb_raise(rb_eScriptError, "out of scope access of %s", RSTRING_PTR(rb_inspect(self)));
       return false;
+    } else {
+      return tc;
     }
   }
   
@@ -51,10 +22,9 @@ namespace {
     if (rb_block_given_p()) {
       HandleScope scope;
       TryCatch tc;
-      try_catch *wrapper = new try_catch(&tc);
-      kill_try_catch kill_on_return(wrapper);
-      VALUE rb_ref = Data_Wrap_Struct(TryCatchClass, mark_try_catch, free_try_catch, wrapper);
-      VALUE result = rb_yield(rb_ref);
+      VALUE try_catch = Data_Wrap_Struct(TryCatchClass, 0, 0, &tc);
+      VALUE result = rb_yield(try_catch);
+      rb_iv_set(try_catch, "dead", Qtrue);
       tc.Reset();
       return result;
     } else {

data/lib/v8/version.rb

@@ -1,3 +1,3 @@
 module V8
-  VERSION = "0.9.0beta2"
+  VERSION = "0.9.0beta3"
 end

data/spec/ext/ext_spec_helper.rb

@@ -1,9 +1,8 @@
 
 module V8::ExtSpec
-  
+
   def self.included(object)
     object.class_eval do
-      before(:all) {c::V8::SetFlagsFromString("--expose-gc")}
       before do
         @cxt = c::Context::New()
         @cxt.Enter()
@@ -14,7 +13,7 @@ module V8::ExtSpec
       end
     end
   end
-  
+
   def v8_eval(script, sourcename = "<eval>")
     c::Script::New(c::String::New(script), c::String::New(sourcename)).Run()
   end
@@ -22,22 +21,5 @@ module V8::ExtSpec
   def c
     V8::C
   end
-  
-  def ruby_gc
-    if GC.respond_to?(:stress)
-      current = GC.stress
-      GC.stress = true
-    end
-    yield
-  ensure
-    if GC.respond_to?(:stess)
-      GC.stress = current
-    end
-  end
-
-  def v8_gc
-    while !c::V8::IdleNotification();end
-    v8_eval('gc()', 'gc.js')
-  end
 
 end

data/spec/ext/object_spec.rb

@@ -7,16 +7,4 @@ describe V8::C::Object do
     v8_eval('var o = new Object()')
     v8_eval('o').should be(v8_eval('o'))
   end
-
-  it "will return a new peer and not barf if the old peer has been garbage collected" do
-    v8_eval('var o = {foo: "bar"}')
-    o = v8_eval('o')
-    old_id = o.object_id
-    ruby_gc do
-      o = nil
-      v8_eval('o').Get(c::String::New("foo")).Utf8Value().should == "bar"
-      v8_eval('o').object_id.should_not be(old_id)
-    end
-    #can't quite get this to work in 1.8. I'm questioning if it's worth the effort
-  end if RUBY_VERSION >= "1.9.2"
 end

data/spec/ext/try_catch_spec.rb

@@ -4,6 +4,9 @@ include V8
 
 describe C::TryCatch do
 
+  before {@cxt = C::Context::New()}
+  after {@cxt.Dispose()}
+
   it "does not allow instance creation by default" do
     lambda {
      C::TryCatch.new 
@@ -28,5 +31,30 @@ describe C::TryCatch do
       tc.HasCaught()
     }.should raise_error(ScriptError)
   end
-  
+
+    it "doesn't segfault when an error is raised in a javascript function on a native prototype" do
+      constructor = Class.new
+      constructor.class_eval do
+        def detonate(*a)
+          raise "BOOM!"
+        end
+      end
+      V8::Context.new do |cxt|
+        cxt['Boom'] = constructor
+        cxt['puts'] = method(:puts)
+        danger = <<-JS
+  Boom.prototype.boom = function() {
+    this.detonate()
+  }
+  var go = new(Boom)()
+  try {
+    go.boom()
+  } catch (e) {
+  }
+  go.boom()
+  JS
+        expect {cxt.eval(danger, 'danger.js')}.should raise_error(V8::JSError)
+      end
+    end
+
 end