therubyracer-freebsd 0.10.1

data/bin/therubyracer

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'v8'
+rescue LoadError
+  require 'rubygems'
+  require 'v8'
+end
+require 'v8/cli'
+
+V8::CLI.run(File.basename(__FILE__), ARGV)

data/ext/v8/extconf.rb

@@ -0,0 +1,26 @@
+require 'mkmf'
+require 'set'
+begin
+  require 'libv8'
+rescue LoadError
+  require 'rubygems'
+  require 'libv8'
+end
+
+have_library('objc') if RUBY_PLATFORM =~ /darwin/
+
+#we have to manually prepend the libv8 include path to INCFLAGS
+#since find_header() does not actually work as advertized.
+#see https://github.com/cowboyd/therubyracer/issues/91
+$INCFLAGS.insert 0, "-I#{Libv8.include_path} "
+
+$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
+$CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
+$CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
+
+$LDFLAGS.insert 0, "#{Libv8.library_path}/libv8.#{$LIBEXT} "
+$LIBS << ' -lpthread'
+
+CONFIG['LDSHARED'] = '$(CXX) -shared' unless RUBY_PLATFORM =~ /darwin/
+
+create_makefile('v8')

data/ext/v8/rr.cpp

@@ -0,0 +1,189 @@
+#include "rr.h"
+#include "v8_context.h"
+#include "v8_handle.h"
+#include "v8_value.h"
+#include "v8_object.h"
+#include "v8_function.h"
+#include "v8_array.h"
+#include "v8_string.h"
+#include "v8_date.h"
+#include "v8_message.h"
+#include "v8_external.h"
+#include "v8_exception.h"
+
+using namespace v8;
+
+VALUE rr_define_class(const char *name, VALUE superclass) {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  VALUE klass = rb_define_class_under(V8_C, name, superclass);
+  rb_funcall(klass, rb_intern("private_class_method"), 1, rb_str_new2("new"));
+  return klass;
+}
+
+VALUE rr_define_module(const char *name) {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  return rb_define_module_under(V8_C, name);
+}
+
+VALUE rr_define_const(const char *name, VALUE value) {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  rb_define_const(V8_C, name, value);
+  return value;
+}
+
+VALUE rr_const_get(const char *name) {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  return rb_const_get(V8_C, rb_intern(name));
+}
+
+VALUE rr_define_finalizer(VALUE object, void* finalizer, VALUE data) {
+  VALUE finalizer_proc = rb_proc_new((VALUE (*)(...))finalizer, data);
+  rb_iv_set(finalizer_proc, "data", data);
+  VALUE ospace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+  rb_funcall(ospace, rb_intern("define_finalizer"), 2, object, finalizer_proc);
+}
+
+VALUE rr_v82rb(Handle<Value> value) {
+  if (value.IsEmpty()) {
+    return rr_v8_value_empty();
+  }
+  if (value->IsUndefined() || value->IsNull()) {
+    return Qnil;
+  }
+  if (value->IsExternal()) {
+    return rr_reflect_v8_external(value);
+  }
+  if (value->IsUint32()) {
+    return UINT2NUM(value->Uint32Value());
+  }
+  if (value->IsInt32()) {
+    return INT2FIX(value->Int32Value());
+  }
+  if (value->IsBoolean()) {
+    return value->BooleanValue() ? Qtrue : Qfalse;
+  }
+  if (value->IsNumber()) {
+    return rb_float_new(value->NumberValue());
+  }  
+  if (value->IsString()) {
+    return rr_reflect_v8_string(value);
+  }
+  if (value->IsFunction()) {
+    return rr_reflect_v8_function(value);
+  }
+  if (value->IsArray()) {
+    return rr_reflect_v8_array(value);
+  }
+  if (value->IsDate()) {
+    return rr_reflect_v8_date(value);
+  }
+  if (value->IsObject()) {
+    return rr_reflect_v8_object(value);
+  }
+  return rr_wrap_v8_value(value);  
+}
+
+VALUE rr_v82rb(Handle<Message> value) {
+  return rr_reflect_v8_message(value);
+}
+VALUE rr_v82rb(Handle<StackTrace> value) {
+  return rr_reflect_v8_stacktrace(value);
+}
+VALUE rr_v82rb(Handle<StackFrame> value) {
+  return rr_reflect_v8_stackframe(value);
+}
+
+VALUE rr_v82rb(Handle<Boolean> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<Number> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<String> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<Object> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<Array> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(v8::Handle<v8::Function> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<Integer> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<Uint32> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(Handle<Int32> value) {
+  return rr_v82rb((Handle<Value>)value);
+}
+VALUE rr_v82rb(bool value) {
+  return value ? Qtrue : Qfalse;
+}
+VALUE rr_v82rb(double value) {
+  return rb_float_new(value);
+}
+VALUE rr_v82rb(int64_t value) {
+  return LONG2NUM(value);
+}
+VALUE rr_v82rb(uint32_t value) {
+  return UINT2NUM(value);
+}
+VALUE rr_v82rb(int32_t value) {
+  return INT2FIX(value);
+}
+
+Handle<Value> rr_rb2v8(VALUE value) {
+  switch (TYPE(value)) {
+  case T_FIXNUM:
+    // TODO: use this conversion if value will fit in 32 bits.
+    // return Integer::New(FIX2LONG(value));
+  case T_FLOAT:
+    return Number::New(NUM2DBL(value));    
+  case T_STRING:
+    return String::New(RSTRING_PTR(value), RSTRING_LEN(value));
+  case T_NIL:
+    return Null();
+  case T_TRUE:
+    return True();
+  case T_FALSE:
+    return False();
+  case T_DATA:
+    return rr_v8_handle<Value>(value);
+  case T_OBJECT:
+  case T_CLASS:
+  case T_ICLASS:
+  case T_MODULE:
+  case T_REGEXP:
+  case T_MATCH:
+  case T_ARRAY:
+  case T_HASH:
+  case T_STRUCT:
+  case T_BIGNUM:
+  case T_FILE:
+  case T_SYMBOL:
+//  case T_BLKTAG: (not in 1.9)
+  case T_UNDEF:
+//  case T_VARMAP: (not in 1.9)
+//  case T_SCOPE: (not in 1.9)
+  case T_NODE:  
+  default:
+    rb_warn("unknown conversion to V8 for: %s", RSTRING_PTR(rb_inspect(value)));
+    return String::New("Undefined Conversion");
+  }
+
+  return Undefined();
+}
+// VALUE rr_v82rb(v8::ScriptData *data) {
+//   return rr_thunk(rr_wrap_script_data(data));
+// }
+
+
+

data/ext/v8/rr.h

@@ -0,0 +1,41 @@
+#ifndef _THE_RUBY_RACER_
+#define _THE_RUBY_RACER_ 
+
+#include <ruby.h>
+#include <v8.h>
+
+#define rr_define_method(klass, name, impl, argc) rb_define_method(klass, name, (VALUE(*)(...))impl, argc)
+#define rr_define_singleton_method(object, name, impl, argc) rb_define_singleton_method(object, name, (VALUE(*)(...))impl, argc)
+
+VALUE rr_define_class(const char *name, VALUE superclass = rb_cObject);
+VALUE rr_define_module(const char *name);
+VALUE rr_define_const(const char *name, VALUE value);
+VALUE rr_const_get(const char *name);
+VALUE rr_define_finalizer(VALUE object, void* finalizer, VALUE data);
+
+extern "C" VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
+
+
+VALUE rr_v82rb(v8::Handle<v8::Value> value);
+VALUE rr_v82rb(v8::Handle<v8::Boolean> value);
+VALUE rr_v82rb(v8::Handle<v8::Number> value);
+VALUE rr_v82rb(v8::Handle<v8::String> value);
+VALUE rr_v82rb(v8::Handle<v8::Object> value);
+VALUE rr_v82rb(v8::Handle<v8::Array> value);
+VALUE rr_v82rb(v8::Handle<v8::Function> value);
+VALUE rr_v82rb(v8::Handle<v8::Integer> value);
+VALUE rr_v82rb(v8::Handle<v8::Uint32> value);
+VALUE rr_v82rb(v8::Handle<v8::Int32> value);
+VALUE rr_v82rb(v8::Handle<v8::Message> value);
+VALUE rr_v82rb(v8::Handle<v8::StackTrace> value);
+VALUE rr_v82rb(v8::Handle<v8::StackFrame> value);
+
+VALUE rr_v82rb(bool value);
+VALUE rr_v82rb(double value);
+VALUE rr_v82rb(int64_t value);
+VALUE rr_v82rb(uint32_t value);
+VALUE rr_v82rb(int32_t value);
+
+v8::Handle<v8::Value> rr_rb2v8(VALUE value);
+
+#endif

data/ext/v8/v8.cpp

@@ -0,0 +1,48 @@
+#include "v8_handle.h"
+#include "v8_context.h"
+#include "v8_value.h"
+#include "v8_string.h"
+#include "v8_object.h"
+#include "v8_array.h"
+#include "v8_message.h"
+#include "v8_function.h"
+#include "v8_date.h"
+#include "v8_script.h"
+#include "v8_template.h"
+#include "v8_try_catch.h"
+#include "v8_callbacks.h"
+#include "v8_external.h"
+#include "v8_exception.h"
+#include "v8_locker.h"
+#include "v8_debug.h"
+#include "v8_v8.h"
+
+#include <stdio.h>
+
+extern "C" {
+  void Init_v8();
+}
+
+extern "C" {
+  void Init_v8() {
+    v8::Locker locker;
+    rr_init_handle();
+    rr_init_context();
+    rr_init_value();
+    rr_init_string();
+    rr_init_script();
+    rr_init_template();
+    rr_init_object();
+    rr_init_function();
+    rr_init_v8_array();
+    rr_init_v8_date();
+    rr_init_message();
+    rr_init_v8_try_catch();
+    rr_init_v8_callbacks();
+    rr_init_v8_external();
+    rr_init_v8_exception();
+    rr_init_v8_locker();
+    rr_init_v8_debug();
+    rr_init_v8_v8();
+  }
+}

data/ext/v8/v8_array.cpp

@@ -0,0 +1,48 @@
+#include "v8_handle.h"
+#include "v8_array.h"
+#include "v8_object.h"
+
+using namespace v8;
+
+
+namespace {
+  
+  VALUE ArrayClass;
+  
+  Persistent<Array>& unwrap(VALUE self) {
+    return rr_v8_handle<Array>(self);
+  }
+  
+  VALUE New(int argc, VALUE *argv, VALUE self) {
+    if (!Context::InContext()) {
+      rb_raise(rb_eScriptError, "must be in a context to call Array::New()");
+      return Qnil;
+    }
+    VALUE length;
+    rb_scan_args(argc, argv, "01", &length);
+    if (NIL_P(length)) {
+      length = INT2FIX(0);
+    }
+    HandleScope scope;
+    return rr_v8_handle_new(self, Array::New(NUM2INT(length)));
+  }
+  
+  VALUE Length(VALUE self) {
+    return rr_v82rb(unwrap(self)->Length());
+  }
+  
+  VALUE CloneElementAt(VALUE self, VALUE index) {
+    return rr_v82rb(unwrap(self)->CloneElementAt(NUM2UINT(index)));
+  }
+}
+
+void rr_init_v8_array() {
+  ArrayClass = rr_define_class("Array", rr_v8_object_class());
+  rr_define_singleton_method(ArrayClass, "New", New, -1);
+  rr_define_method(ArrayClass, "Length", Length, 0);
+  rr_define_method(ArrayClass, "CloneElementAt", CloneElementAt, 1);
+}
+
+VALUE rr_reflect_v8_array(Handle<Value> value) {
+  return rr_reflect_v8_object_as(value, ArrayClass);
+}

data/ext/v8/v8_array.h

@@ -0,0 +1,8 @@
+#ifndef _RR_V8_ARRAY_
+#define _RR_V8_ARRAY_ 
+
+#include "rr.h"
+
+void rr_init_v8_array();
+VALUE rr_reflect_v8_array(v8::Handle<v8::Value> value);
+#endif

data/ext/v8/v8_callbacks.cpp

@@ -0,0 +1,81 @@
+#include "v8_callbacks.h"
+#include "rr.h"
+
+using namespace v8;
+
+
+namespace {
+  VALUE ArgumentsClass;
+  VALUE AccessorInfoClass;
+  
+  VALUE _Data(VALUE self) {
+    return rb_iv_get(self, "data");
+  }
+
+  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());
+    }
+  }
+  
+  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());
+    }
+  }
+
+}
+
+void rr_init_v8_callbacks() {
+  AccessorInfoClass = rr_define_class("AccessorInfo");
+  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", Args::This, 0);
+  rr_define_method(ArgumentsClass, "Holder", Args::Holder, 0);
+  rr_define_method(ArgumentsClass, "Data", _Data, 0);
+  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, 0, 0, (void*)&info);
+}
+VALUE rr_v82rb(const Arguments& arguments) {
+  return Data_Wrap_Struct(ArgumentsClass, 0, 0, (void*)&arguments);
+}