therubyracer 0.4.9-x86-linux

data/ext/v8/convert_ruby.cpp

@@ -0,0 +1,8 @@
+#include "convert_ruby.h"
+
+
+RubyValueDest::RubyValueDest() {
+}
+
+RubyValueDest::~RubyValueDest() {
+}

data/ext/v8/convert_ruby.h

@@ -0,0 +1,99 @@
+#ifndef __convert_ruby_h__
+#define __convert_ruby_h__
+
+#include <ruby.h>
+#include <string>
+
+/**
+ * A RubyValueSource takes a Destination class and a return
+ * type as a template argument, it converts a Ruby Value to
+ * the appropriate intermediate type and feed it to an 
+ * instance Destination type.  
+ * 
+ * The destination type should have a default constructor, 
+ * and provide the methods detailed in data_conversion.txt
+ * \tparam DEST destination type for the converted data
+ * \tparam RET is the return type of T's methods
+ */
+
+template<class DEST, class RET> class RubyValueSource {
+
+    /**
+    * An instance of the destination class
+    */
+    DEST dest;
+
+    public:
+    RubyValueSource() {}
+    ~RubyValueSource() {}
+
+
+    bool operator() (VALUE& value, RET& result) {
+        switch (TYPE(value)) {
+        case T_FIXNUM:
+          result = dest.pushInt(FIX2INT(value));
+          return true;
+        case T_FLOAT:
+          result = dest.pushDouble(NUM2DBL(value));
+          return true;
+        case T_STRING:
+          result = convertString(value);
+          return true;
+        case T_NIL:
+          result = dest.pushNull();
+          return true;
+        case T_TRUE:
+          result = dest.pushBool(true);
+          return true;
+        case T_FALSE:
+          result = dest.pushBool(false);
+          return true;
+        }
+        return false;
+    }
+    
+private:
+    RET convertString(VALUE& value) {
+        std::string stringValue(RSTRING_PTR(value));
+        return dest.pushString(stringValue);
+    }
+};
+
+/**
+ * A RubyValueDest class receives on of the types defined in
+ * data_conversion.txt, and converts it to the appropriate
+ * Ruby VALUE.
+ */
+class RubyValueDest {
+
+    public:
+    RubyValueDest();
+    ~RubyValueDest();
+
+    VALUE pushString(const std::string& value) {
+        return rb_str_new2(value.c_str());
+    }
+
+    VALUE pushInt(int64_t value) {
+        return INT2FIX(value);
+    }
+
+    VALUE pushDouble(double value) {
+        return rb_float_new(value);
+    }
+
+    VALUE pushBool(bool value) {
+        return value ? Qtrue : Qfalse;
+    }
+
+    VALUE pushNull() {
+        return Qnil;
+    }
+
+    VALUE pushUndefined() {
+        return Qnil;
+    }
+};
+
+
+#endif

data/ext/v8/convert_string.cpp

@@ -0,0 +1,10 @@
+#include "convert_string.h"
+
+StringDest::StringDest() {
+}
+
+StringDest::~StringDest(){
+}
+
+const std::string StringDest::TRUE("true");
+const std::string StringDest::FALSE("false");

data/ext/v8/convert_string.h

@@ -0,0 +1,73 @@
+#ifndef __convert_string_h__
+#define __convert_string_h__
+
+#include "v8.h"
+#include <string>
+
+/**
+ * StringDest is a data type conversion destination that converts
+ * any argument into a string.  It should have all methods listed
+ * in data_conversion.txt so it can be used as a template argument
+ * for a conversion source class.
+ */
+class StringDest {
+
+public:
+    StringDest();
+    ~StringDest();
+
+    std::string pushString(const std::string& value) {
+        return value;
+    }
+
+#ifdef FIGURED_OUT_INT_ISSUES
+    const char* pushInt(int32_t value) {
+        char buffer[64];
+        sprintf(buffer, "%d", value);
+        convertedValue = buffer;
+        return convertedValue.c_str();
+    }
+#endif
+
+    std::string pushInt(int64_t value) {
+        char buffer[64];
+				sprintf(buffer, "%lld", value);
+        std::string convertedValue(buffer);   
+        return convertedValue;
+    }
+
+    std::string pushDouble(double value) {
+        char buffer[64];
+        sprintf(buffer, "%g", value);
+        std::string convertedValue(buffer);   
+        return convertedValue;
+    }
+
+    std::string pushBool(bool value) {
+        std::string convertedValue(value ? TRUE : FALSE);
+        return convertedValue;
+    }
+
+    std::string pushNull() {
+      printf("I bet we aren't even getting here<br/>");
+        return ""; // this kind of sucks
+    }
+    
+    std::string pushUndefined() {
+        return "undefined"; // this too
+    }
+
+private:
+
+    /**
+     * constant "true" used for pushBool
+     */
+    static const std::string TRUE;
+
+    /**
+     * constant "false" used for pushBool
+     */
+    static const std::string FALSE;
+};
+
+#endif

data/ext/v8/convert_v8.cpp

@@ -0,0 +1,9 @@
+#include "convert_v8.h"
+
+V8LocalDest::V8LocalDest() {
+    
+}
+
+V8LocalDest::~V8LocalDest() {
+    
+}

data/ext/v8/convert_v8.h

@@ -0,0 +1,121 @@
+#ifndef __convert_v8_h__
+#define __convert_v8_h__
+
+#include <v8.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string>
+
+template<class T, class R> class V8HandleSource {
+
+  T dest;
+
+ public:
+
+  V8HandleSource() {}
+  ~V8HandleSource() {}
+
+  bool operator() (v8::Handle<v8::Value>& value, R& result) {
+
+    // a bit klunky, but alternative is to evaluate what type the
+    // object is twice, which is unappealing
+    
+    if (value.IsEmpty()) {
+      result = dest.pushNull();
+      return true;
+    }
+
+    if (value->IsUndefined()) {
+      result = dest.pushNull();
+      return true;
+    }
+
+    if(value->IsNull()) {
+      result = dest.pushNull();
+      return true;
+    }
+    
+    if(value->IsTrue()) {
+      result = dest.pushBool(true);
+      return true;
+    }
+
+    if(value->IsFalse()) {
+      result = dest.pushBool(false);
+      return true;
+    }
+
+    if(value->IsString()) {
+      v8::Local<v8::String> str = value->ToString();
+      result = convertString(str);
+      return true;
+    }
+
+    if(value->IsInt32()) {
+      result = dest.pushInt(value->Int32Value());
+      return true;
+    }
+
+    if(value->IsNumber()) {
+      result = dest.pushDouble(value->NumberValue());
+      return true;
+    }
+    
+    result = dest.pushNull();
+    return false;
+  }
+
+  R convertString(v8::Local<v8::String>& str) {
+    char buffer[1024];
+    int strlen = str->Length();
+    std::string output(strlen, 0);
+    for (int total = 0; total < strlen;) {
+      int written = str->WriteAscii(buffer, total, 1024);
+      output.replace(total, written, buffer);
+      total += written;
+    }
+    return dest.pushString(output);    
+  }
+
+
+};
+
+/**
+ * StringDest is a data type conversion destination that converts
+ * any argument into a string.  It should have all methods listed
+ * in data_conversion.txt so it can be used as a template argument
+ * for a conversion source class.
+ */
+class V8LocalDest {
+
+public:
+    V8LocalDest();
+    ~V8LocalDest();
+
+    v8::Local<v8::Value> pushString(const std::string& value) {
+        return v8::Local<v8::Value>::New(v8::String::New(value.c_str()));
+    }
+
+    v8::Local<v8::Value> pushInt(int64_t value) {
+        return v8::Local<v8::Value>::New(v8::Integer::New(value));
+    }
+
+    v8::Local<v8::Value> pushDouble(double value) {
+        return v8::Local<v8::Value>::New(v8::Number::New(value));
+    }
+
+    v8::Local<v8::Value> pushBool(bool value) {
+        return v8::Local<v8::Value>::New(v8::Boolean::New(value));
+    }
+
+    v8::Local<v8::Value> pushNull() {
+      return v8::Local<v8::Value>::New(v8::Null());
+    }
+    
+    v8::Local<v8::Value> pushUndefined() {
+      return v8::Local<v8::Value>::New(v8::Undefined());
+    }
+};
+
+
+#endif

data/ext/v8/converters.cpp

@@ -0,0 +1,83 @@
+#include "converters.h"
+#include "callbacks.h"
+#include "v8_ref.h"
+#include "v8_obj.h"
+#include "v8_cxt.h"
+#include "v8_template.h"
+
+using namespace v8;
+
+namespace {
+  std::string UNDEFINED_STR("undefined");
+}
+
+VALUE V8_To;
+
+VALUE V82RB(Handle<Value>& value) {
+  convert_v8_to_rb_t convert;
+  VALUE result;
+  if(convert(value, result)) {
+    return result;
+  }
+  
+  if (value->IsArray()) {  
+    Local<Array> array(Array::Cast(*value));
+    VALUE rb_array = rb_ary_new2(array->Length());
+    for (unsigned int i = 0; i < array->Length(); i++) {
+      Local<Value> value = array->Get(Integer::New(i));
+      rb_ary_push(rb_array, V82RB(value));
+    }
+    return rb_array;
+  }
+  
+  if (value->IsObject()) {
+    Local<Object> object(Object::Cast(*value));
+    Local<Value> peer = object->GetHiddenValue(String::New("TheRubyRacer::RubyObject"));
+    // Local<Value> peer = object->GetInternalField(0);
+    if (peer.IsEmpty()) {
+      VALUE context_ref = V8_Ref_Create(V8_C_Context, Context::GetCurrent());
+      // object->SetPointerInInternalField(1, (void *)context_ref);
+      object->SetHiddenValue(String::New("TheRubyRacer::Context"), External::Wrap((void *)context_ref));
+      return V8_Ref_Create(V8_C_Object, value, context_ref);
+    } else {      
+      return (VALUE)External::Unwrap(peer);
+    }
+  }
+  
+  return Qnil;
+}
+
+Local<Value> RB2V8(VALUE value) {  
+  VALUE valueClass = rb_class_of(value);
+  if(valueClass == rb_cProc || valueClass == rb_cMethod) {
+    Local<FunctionTemplate> t = FunctionTemplate::New(RacerRubyInvocationCallback, External::Wrap((void *)value));
+    return t->GetFunction();  
+  }
+  convert_rb_to_v8_t convert;
+  Local<Value> result;
+  if (convert(value, result)) {
+    return result;
+  }
+  Local<Object> o = Racer_Create_V8_ObjectTemplate(value)->NewInstance();
+  o->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), External::Wrap((void *) value));
+  // o->SetPointerInInternalField(0, (void*)value);
+  return o;
+}
+
+std::string V82String(Handle<Value>& value) {
+  convert_v8_to_string_t convert;
+  std::string result;
+  if(convert(value, result)) {
+    return result;
+  }
+  
+  if (value->IsObject()) {
+    Local<Object> object(Object::Cast(*value));
+    Local<String> str = object->ToString();
+    if(convert(value, result)) {
+      return result;
+    }
+  }  
+  
+  return UNDEFINED_STR;
+}

data/ext/v8/converters.h

@@ -0,0 +1,23 @@
+#ifndef __converters_h__
+#define __converters_h__
+
+#include "convert_ruby.h"
+#include "convert_string.h"
+#include "convert_v8.h"
+#include <cstring>
+
+extern VALUE V8_To;
+
+typedef RubyValueSource<V8LocalDest, v8::Local<v8::Value> > convert_rb_to_v8_t; 
+typedef V8HandleSource<RubyValueDest, VALUE> convert_v8_to_rb_t;
+
+typedef RubyValueSource<StringDest, std::string> convert_rb_to_string_t;
+typedef V8HandleSource<StringDest, std::string> convert_v8_to_string_t;
+
+VALUE V82RB(v8::Handle<v8::Value>& value);
+v8::Local<v8::Value> RB2V8(VALUE value);
+
+std::string RB2String(VALUE value);
+std::string V82String(v8::Handle<v8::Value>& value);
+
+#endif

data/ext/v8/extconf.rb

@@ -0,0 +1,36 @@
+require 'mkmf'
+
+UPSTREAM = File.expand_path(File.dirname(__FILE__) + "/upstream")
+BUILD = "#{UPSTREAM}/build/v8"
+
+
+puts "Compiling V8"
+
+system("cd #{UPSTREAM} && make") or raise "Error compiling V8"
+
+dir_config('v8', "#{BUILD}/include", "#{BUILD}")
+have_library('v8') or raise "Unable to find libv8 in #{BUILD}, was there an error compiling it?"
+
+$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
+
+CONFIG['LDSHARED'] = '$(CXX) -shared'
+
+create_makefile('v8')
+
+# now add a few extra targets
+File.open("Makefile", "a") do |makefile|
+makefile.print <<EOF
+
+test: all
+	@echo running spec...
+	spec -O spec/spec.opts spec/therubyracer_spec.rb
+
+docs/cpp:
+	mkdir -p docs/cpp
+
+docs: all docs/cpp
+	@echo Generate C++ docs to docs/cpp/html
+	doxygen Doxyfile
+
+EOF
+end