classiccms 0.3.0 → 0.3.1

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_handle.cpp

@@ -0,0 +1,186 @@
+
+#include "rr.h"
+#include "v8_handle.h"
+
+using namespace v8;
+
+/**
+* Creates a new Persistent storage cell for `handle`
+* so that we can reference it from Ruby. Ruby metadat
+* is contained on the handle object, and then the actual
+* v8 references are contain in an instance of `Payload`
+*/
+v8_handle::v8_handle(Handle<void> object) {
+  this->weakref_callback = Qnil;
+  this->weakref_callback_parameters = Qnil;
+  this->dead = false;
+  this->payload = new Payload(object);
+}
+
+v8_handle::~v8_handle() {}
+
+/**
+* Construct a new handle payload.
+*
+* Each payload contains a Ruby object wrapper so that it
+* can be enqueued for V8 GC (the GC queue is a ruby Array)
+* the wrapper is pre-allocated at payload creation time
+* so that no Ruby objects are allocated during Ruby GC.
+*/
+v8_handle::Payload::Payload(Handle<void> object) {
+  rb_gc_register_address(&wrapper);
+  handle = Persistent<void>::New(object);
+  wrapper = Data_Wrap_Struct(rb_cObject, 0, destroy, this);
+}
+
+v8_handle::Payload::~Payload() {
+  rb_gc_unregister_address(&wrapper);
+}
+
+void v8_handle::Payload::release() {
+  handle.Dispose();
+  handle.Clear();
+}
+
+void v8_handle::Payload::destroy(v8_handle::Payload* payload) {
+  delete payload;
+}
+
+namespace {
+  /**
+  * Holds dead references, that are no longer being held in Ruby, so that they can be garbage collected
+  * inside of V8
+  */
+  VALUE handle_queue;
+
+  /**
+  * Invoked by the Ruby garbage collector whenever it determines that this handle is
+  * still reachable. We in turn, mark our weak callback parameters, so that it knows
+  * they are reachable too.
+  */
+  void v8_handle_mark(v8_handle* handle) {
+    rb_gc_mark(handle->weakref_callback);
+    rb_gc_mark(handle->weakref_callback_parameters);
+  }
+
+  /**
+  * Whenver a V8::C::Handle becomes garbage collected, we do not free it immediately.
+  * instead, we put them into a "zombie" queue, where its corresponding V8 storage cell
+  * can be released safely while the V8 engine is running. A zombie Ruby object is
+  * created to wrap it so that it can be stored in the queue.
+  */
+  void v8_handle_enqueue(v8_handle* handle) {
+    handle->dead = true;
+    rb_ary_unshift(handle_queue, handle->payload->wrapper);
+  }
+
+  /**
+  * Drains the dead handle queue, and releases them from V8
+  *
+  * This implements the V8 `GCPrologueCallback` and is registered to run before
+  * each invocation of the V8 garbage collector. It empties the queue of dead handles
+  * and disposes of them. It is important to do this operations inside V8 so that
+  * Ruby garbage collection is never locked, and never touches V8.
+  */
+  void v8_handle_dequeue(GCType type, GCCallbackFlags flags) {
+    for (VALUE handle = rb_ary_pop(handle_queue); RTEST(handle); handle = rb_ary_pop(handle_queue)) {
+      v8_handle::Payload* payload = NULL;
+      Data_Get_Struct(handle, struct v8_handle::Payload, payload);
+      payload->release();
+    }
+  }
+
+  VALUE New(VALUE self, VALUE handle) {
+    if (RTEST(handle)) {
+      Persistent<void> that = rr_v8_handle<void>(handle);
+      return rr_v8_handle_new(self, that);
+    } else {
+      return rr_v8_handle_new(self, Handle<void>());
+    }
+  }
+
+  VALUE IsEmpty(VALUE self) {
+    return rr_v82rb(rr_v8_handle<void>(self).IsEmpty());
+  }
+
+  VALUE Clear(VALUE self) {
+    rr_v8_handle<void>(self).Clear();
+    return Qnil;
+  }
+
+  VALUE Dispose(VALUE self) {
+    rr_v8_handle<void>(self).Dispose();
+    return Qnil;
+  }
+
+  void RubyWeakReferenceCallback(Persistent<Value> value, void* parameter) {
+    VALUE self = (VALUE)parameter;
+    v8_handle* handle = rr_v8_handle_raw(self);
+    VALUE callback = handle->weakref_callback;
+    VALUE parameters = handle->weakref_callback_parameters;
+    if (RTEST(callback)) {
+      rb_funcall(callback, rb_intern("call"), 2, self, parameters);
+    }
+    value.Dispose();
+    handle->payload->release();
+    handle->dead = true;
+
+  }
+
+  VALUE MakeWeak(VALUE self, VALUE parameters, VALUE callback) {
+    v8_handle* handle = rr_v8_handle_raw(self);
+    handle->weakref_callback = callback;
+    handle->weakref_callback_parameters = parameters;
+    rr_v8_handle<void>(self).MakeWeak((void*)self, RubyWeakReferenceCallback);
+    return Qnil;
+  }
+
+  VALUE ClearWeak(VALUE self) {
+    rr_v8_handle<void>(self).ClearWeak();
+    return Qnil;
+  }
+
+  VALUE IsNearDeath(VALUE self) {
+    return rr_v82rb(rr_v8_handle<void>(self).IsNearDeath());
+  }
+
+  VALUE IsWeak(VALUE self) {
+    return rr_v82rb(rr_v8_handle<void>(self).IsWeak());
+  }
+
+  VALUE dead_p(VALUE self) {
+    return rr_v8_handle_raw(self)->dead ? Qtrue : Qfalse;
+  }
+}
+
+void rr_init_handle() {
+  VALUE HandleClass = rr_define_class("Handle");
+  rr_define_method(HandleClass, "dead?", dead_p, 0);
+  rr_define_singleton_method(HandleClass, "New", New, 1);
+  rr_define_method(HandleClass, "IsEmpty", IsEmpty, 0);
+  rr_define_method(HandleClass, "Clear", Clear, 0);
+  rr_define_method(HandleClass, "Dispose", Dispose, 0);
+  rr_define_method(HandleClass, "MakeWeak", MakeWeak, 2);
+  rr_define_method(HandleClass, "ClearWeak", ClearWeak, 0);
+  rr_define_method(HandleClass, "IsNearDeath", IsNearDeath, 0);
+  rr_define_method(HandleClass, "IsWeak", IsWeak, 0);
+
+  rb_gc_register_address(&handle_queue);
+  handle_queue = rb_ary_new();
+  V8::AddGCPrologueCallback(v8_handle_dequeue);
+}
+
+VALUE rr_v8_handle_new(VALUE klass, v8::Handle<void> handle) {
+  v8_handle* new_handle = new v8_handle(handle);
+  return Data_Wrap_Struct(klass, v8_handle_mark, v8_handle_enqueue, new_handle);
+}
+
+VALUE rr_v8_handle_class() {
+  return rr_define_class("Handle");
+}
+
+v8_handle* rr_v8_handle_raw(VALUE value) {
+  v8_handle* handle = 0;
+  Data_Get_Struct(value, struct v8_handle, handle);
+  return handle;
+}

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_handle.h

@@ -0,0 +1,48 @@
+#ifndef _RR_V8_HANDLE_
+#define _RR_V8_HANDLE_
+
+#include <v8.h>
+#include "ruby.h"
+
+/**
+* Holds a reference to a V8 heap object. This serves as the base
+* class for all of the low-level proxies that reference into V8.
+*/
+struct v8_handle  {
+
+  /**
+  * Contains the *actual* V8 references. This object is kept
+  * separate so that it can be "detached" from the handle when
+  * it is garbage collected, and enqueued separately and
+  * collected in the context of a V8 thread.
+  */
+
+  struct Payload {
+    Payload(v8::Handle<void> object);
+    virtual ~Payload();
+    void release();
+    static void destroy(v8_handle::Payload* payload);
+    v8::Persistent<void> handle;
+    VALUE wrapper;
+  };
+
+  v8_handle(v8::Handle<void> object);
+  virtual ~v8_handle();
+
+  Payload* payload;
+  bool dead;
+  VALUE weakref_callback;
+  VALUE weakref_callback_parameters;
+};
+
+void rr_init_handle();
+
+v8_handle* rr_v8_handle_raw(VALUE value);
+
+template <class T> v8::Persistent<T>& rr_v8_handle(VALUE value) {
+  return (v8::Persistent<T>&)(rr_v8_handle_raw(value)->payload->handle);
+}
+VALUE rr_v8_handle_new(VALUE rbclass, v8::Handle<void> handle);
+VALUE rr_v8_handle_class();
+
+#endif

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_locker.cpp

@@ -0,0 +1,139 @@
+#include "rr.h"
+#include "v8_locker.h"
+
+using namespace v8;
+
+namespace {
+  namespace Lock {
+
+    /**
+    * Document-method: V8::C::Locker#new
+    *
+    * Allocates and returns a new `v8::Locker` object. The thread that instantiated
+    * this object will hold the V8 interpreter lock until it is released with a
+    * corresponding call to {#delete}.
+    *
+    * It critical that you call {#delete} to deallocate it, preferably within the same method.
+    * If you don't, two bad things will happen:
+    *
+    * 1. You'll leak the underlying C++ object
+    * 1. Worse, you'll leave the V8 vm locked to this thread forever
+    *
+    * It's dangerous! Be sure to `ensure`.
+    *
+    * for detailed semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    *
+    * @return [V8::C::Locker] the new locker
+    */
+
+    VALUE New(VALUE LockerClass) {
+      Locker* locker = new Locker();
+      return Data_Wrap_Struct(LockerClass, 0, 0, (void*)locker);
+    }
+
+    /**
+    * Document-method: V8::C::Locker#delete
+    *
+    * Pop this lock off the stack for this thread. For a full run down of V8 locking
+    * semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    * @return nil
+    */
+    VALUE Delete(VALUE self) {
+      Locker* locker = 0;
+      Data_Get_Struct(self, class Locker, locker);
+      delete locker;
+    }
+  }
+
+  namespace Unlock {
+    /**
+    * Document-method: V8::C::Unlocker#new
+    *
+    * Allocates and returns a new `v8::UnLocker` object, temporarily releasing any locks that
+    * this thread is holding. It will reaquire all of the locksto {#delete}.
+    *
+    * This is a great thing to do when you want to call out to some code that might do some
+    * waiting, sleeping, and you want to politely let other threads use this VM.
+    *
+    * It critical that you call {#delete} to deallocate it, preferably within the same method.
+    * If you don't, two bad things will happen:
+    *
+    * 1. You'll leak the underlying C++ object
+    * 1. You won't restore the locks to your current thread, and will mess things up horribly
+    *
+    * It's dangerous! Be sure to `ensure`.
+    *
+    * For details on V8 locking semantics, see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    * @return [V8::C::Unocker] the new locker
+    */
+    VALUE New(VALUE UnlockerClass) {
+      Unlocker* unlocker = new Unlocker();
+      return Data_Wrap_Struct(UnlockerClass, 0, 0, (void*)unlocker);
+    }
+
+    /**
+    * Document-method: V8::C::Unlocker#delete
+    *
+    * Restore any locks to the stack that were temporarily removed by this `Unlocker`.
+    * For a full run down, see semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    * @return nil
+    */
+    VALUE Delete(VALUE self) {
+      Unlocker* unlocker;
+      Data_Get_Struct(self, class Unlocker, unlocker);
+      delete unlocker;
+    }
+  }
+
+  /**
+  * Document-method: V8::C::Locker#StartPreemption
+  * Start preemption.
+  * When preemption is started, a timer is fired every n milli seconds that will switch between
+  * multiple threads that are in contention for the V8 lock.
+  *
+  * @param [Integer] every_n_ms
+  * @return nil
+  */
+  VALUE StartPreemption(VALUE self, VALUE every_n_ms) {
+    Locker::StartPreemption(NUM2INT(rb_to_int(every_n_ms)));
+    return Qnil;
+  }
+
+  /**
+  * Document-method: V8::C::Locker#StartPreemption
+  * Stop preemption
+  */
+  VALUE StopPreemption(VALUE self) {
+    Locker::StopPreemption();
+    return Qnil;
+  }
+
+  /**
+  * Document-method: V8::C::Locker#IsLocked
+  * Returns whether or not the locker is locked by the current thread.
+  */
+  VALUE IsLocked(VALUE self) {
+    return rr_v82rb(Locker::IsLocked());
+  }
+
+  /**
+  * Document-method: V8::C::Locker#IsActive
+  * Returns whether v8::Locker is being used by this V8 instance.
+  */
+  VALUE IsActive(VALUE self) {
+    return rr_v82rb(Locker::IsActive());
+  }
+}
+
+void rr_init_v8_locker() {
+  VALUE LockerClass = rr_define_class("Locker");
+  VALUE UnlockerClass = rr_define_class("Unlocker");
+  rr_define_singleton_method(LockerClass, "new", Lock::New, 0);
+  rr_define_method(LockerClass, "delete", Lock::Delete, 0);
+  rr_define_singleton_method(UnlockerClass, "new", Unlock::New, 0);
+  rr_define_method(UnlockerClass, "delete", Unlock::Delete, 0);
+  rr_define_singleton_method(LockerClass, "StartPreemption", StartPreemption, 1);
+  rr_define_singleton_method(LockerClass, "StopPreemption", StopPreemption, 0);
+  rr_define_singleton_method(LockerClass, "IsLocked", IsLocked, 0);
+  rr_define_singleton_method(LockerClass, "IsActive", IsActive, 0);
+}

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_locker.h

@@ -0,0 +1,6 @@
+#ifndef _RUBY_V8_LOCKER
+#define _RUBY_V8_LOCKER
+
+void rr_init_v8_locker();
+
+#endif

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_message.cpp

@@ -0,0 +1,67 @@
+#include "v8_message.h"
+#include "v8_handle.h"
+
+using namespace v8;
+
+namespace {
+  VALUE MessageClass;
+  
+  Persistent<Message>& unwrap(VALUE self) {
+    return rr_v8_handle<Message>(self);
+  }
+  
+  VALUE Get(VALUE self) {
+    return rr_v82rb(unwrap(self)->Get());
+  }
+
+  VALUE GetSourceLine(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetSourceLine());
+  }
+
+  VALUE GetScriptResourceName(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetScriptResourceName());
+  }
+
+  VALUE GetStackTrace(VALUE self) {
+    Handle<StackTrace> trace = unwrap(self)->GetStackTrace();
+    return trace.IsEmpty() ? Qnil : rr_v82rb(trace);
+  }
+
+  VALUE GetLineNumber(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetLineNumber());
+  }
+
+  VALUE GetStartPosition(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetStartPosition());
+  }
+
+  VALUE GetEndPosition(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetEndPosition());
+  }
+
+  VALUE GetStartColumn(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetStartColumn());
+  }
+
+  VALUE GetEndColumn(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetEndColumn());
+  }
+}
+
+void rr_init_message() {
+  MessageClass = rr_define_class("Message", rr_v8_handle_class());
+  rr_define_method(MessageClass, "Get", Get, 0);
+  rr_define_method(MessageClass, "GetSourceLine", GetSourceLine, 0);
+  rr_define_method(MessageClass, "GetScriptResourceName", GetScriptResourceName, 0);
+  rr_define_method(MessageClass, "GetStackTrace", GetStackTrace, 0);
+  rr_define_method(MessageClass, "GetLineNumber", GetLineNumber, 0);
+  rr_define_method(MessageClass, "GetStartPosition", GetStartPosition, 0);
+  rr_define_method(MessageClass, "GetEndPosition", GetEndPosition, 0);
+  rr_define_method(MessageClass, "GetStartColumn", GetStartColumn, 0);
+  rr_define_method(MessageClass, "GetEndColumn", GetEndColumn, 0);  
+}
+
+VALUE rr_reflect_v8_message(Handle<Message> value) {
+  return rr_v8_handle_new(MessageClass, value);
+}
+

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_message.h

@@ -0,0 +1,10 @@
+#ifndef _RUBY_V8_MESSAGE_
+#define _RUBY_V8_MESSAGE_ 
+
+#include "v8.h"
+#include "rr.h"
+
+void rr_init_message();
+VALUE rr_reflect_v8_message(v8::Handle<v8::Message> value);
+
+#endif

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_object.cpp

@@ -0,0 +1,122 @@
+#include "v8_handle.h"
+#include "v8_weakref.h"
+#include "v8_object.h"
+#include "v8_value.h"
+#include "v8_template.h"
+#include "v8_external.h"
+
+using namespace v8;
+
+#include <cstdio>
+
+namespace {
+
+  VALUE ObjectClass;
+
+  Persistent<Object>& unwrap(VALUE object) {
+    return rr_v8_handle<Object>(object);
+  }
+
+  VALUE Get(VALUE self, VALUE key) {
+    HandleScope handles;
+    Persistent<Object> obj(unwrap(self));
+    if (rb_obj_is_kind_of(key, rb_cNumeric)) {
+      return rr_v82rb(obj->Get(NUM2UINT(key)));
+    } else {
+      return rr_v82rb(obj->Get(rr_rb2v8(key)->ToString()));
+    }
+  }
+
+  VALUE New(VALUE rbclass) {
+    HandleScope handles;
+    if (!Context::InContext()) {
+      rb_raise(rb_eScriptError, "Object::New() called without an entered Context");
+      return Qnil;
+    }
+    return rr_v8_handle_new(rbclass, Object::New());
+  }
+
+  VALUE Set(VALUE self, VALUE key, VALUE value) {
+    HandleScope handles;
+    Persistent<Object> obj = unwrap(self);
+    if (rb_obj_is_kind_of(key, rb_cNumeric)) {
+      return rr_v82rb(obj->Set(NUM2UINT(key), rr_rb2v8(value)));
+    } else {
+      return rr_v82rb(obj->Set(rr_rb2v8(key), rr_rb2v8(value)));
+    }
+  }
+
+  VALUE GetPropertyNames(VALUE self) {
+    HandleScope handles;
+    Persistent<Object> object = unwrap(self);
+    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()) {
+      unwrap(self)->SetHiddenValue(rr_rb2v8(key)->ToString(), rr_rb2v8(value));
+    } else {
+      rb_raise(rb_eScriptError, "Object::SetHiddenValue() called without an entered Context");
+    }
+    return Qnil;
+  }
+  VALUE GetHiddenValue(VALUE self, VALUE key) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->GetHiddenValue(rr_rb2v8(key)->ToString()));
+  }
+  VALUE GetPrototype(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->GetPrototype());
+  }
+  VALUE SetPrototype(VALUE self, VALUE prototype) {
+    HandleScope scope;
+    Handle<Value> proto(rr_rb2v8(prototype));
+    return rr_v82rb(unwrap(self)->SetPrototype(rr_rb2v8(prototype)));
+  }
+}
+
+VALUE rr_v8_object_class() {
+  return ObjectClass;
+}
+
+void rr_init_object() {
+  ObjectClass = rr_define_class("Object", rr_v8_value_class());
+  rr_define_singleton_method(ObjectClass, "New", New, 0);
+  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);
+  rr_define_method(ObjectClass, "SetPrototype", SetPrototype, 1);
+}
+
+VALUE rr_reflect_v8_object_as(Handle<Value> value, VALUE ruby_class) {
+  Handle<Object> object = Handle<Object>::Cast(value);
+  VALUE handle;
+  v8_weakref* backref;
+  Local<Value> holder = object->GetHiddenValue(String::NewSymbol("TheRubyRacer::Backref"));
+  if (holder.IsEmpty()) {
+    handle = rr_v8_handle_new(ruby_class, object);
+    backref = new v8_weakref(handle);
+    object->SetHiddenValue(String::NewSymbol("TheRubyRacer::Backref"), backref->external);
+  } else {
+    backref = (v8_weakref*)External::Unwrap(holder);
+    handle = backref->get();
+    if (!RTEST(handle)) {
+      handle = rr_v8_handle_new(ruby_class, object);
+      backref->set(handle);
+    }
+  }
+  return handle;
+}
+
+VALUE rr_reflect_v8_object(Handle<Value> value) {
+  return rr_reflect_v8_object_as(value, ObjectClass);
+}
+

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_object.h

@@ -0,0 +1,10 @@
+#ifndef _RUBY_V8_OBJECT_
+#define _RUBY_V8_OBJECT_ 
+
+#include "rr.h"
+
+void rr_init_object();
+VALUE rr_v8_object_class();
+VALUE rr_reflect_v8_object(v8::Handle<v8::Value> value);
+VALUE rr_reflect_v8_object_as(v8::Handle<v8::Value> object, VALUE ruby_class);
+#endif

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_script.cpp

@@ -0,0 +1,36 @@
+#include "v8.h"
+#include "v8_handle.h"
+#include "v8_script.h"
+
+using namespace v8;
+
+namespace {
+
+  VALUE New(VALUE self, VALUE source, VALUE source_name) {
+    HandleScope scope;
+    Local<String> src(rr_rb2v8(source)->ToString());
+    Local<String> src_name(rr_rb2v8(source_name)->ToString());
+    return rr_v8_handle_new(self, Script::Compile(src, src_name));
+  }
+
+  VALUE Compile(VALUE self, VALUE source, VALUE source_name) {
+    HandleScope scope;
+    Local<String> src(rr_rb2v8(source)->ToString());
+    Local<String> src_name(rr_rb2v8(source_name)->ToString());
+    return rr_v8_handle_new(self, Script::Compile(src, src_name));
+  }
+
+  VALUE Run(VALUE self) {
+    HandleScope scope;
+    Persistent<Script> script(rr_v8_handle<Script>(self));
+    Local<Value> result(script->Run());
+    return result.IsEmpty() ? Qnil : rr_v82rb(result);
+  }
+}
+
+void rr_init_script() {
+  VALUE ScriptClass = rr_define_class("Script", rr_v8_handle_class());
+  rr_define_singleton_method(ScriptClass, "New", New, 2);
+  rr_define_singleton_method(ScriptClass, "Compile", Compile, 2);
+  rr_define_method(ScriptClass, "Run", Run, 0);
+}

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_script.h

@@ -0,0 +1,8 @@
+#ifndef _RUBY_V8_SCRIPT_
+#define _RUBY_V8_SCRIPT_ 
+
+#include "rr.h"
+
+void rr_init_script();
+
+#endif

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_string.cpp

@@ -0,0 +1,52 @@
+
+#include "v8.h"
+#include "v8_handle.h"
+#include "v8_value.h"
+#include "v8_string.h"
+
+using namespace v8;
+
+namespace {  
+  VALUE StringClass;
+  
+  Persistent<String>& unwrap(VALUE value) {
+    return rr_v8_handle<String>(value);
+  }
+  VALUE New(VALUE string_class, VALUE data) {
+    HandleScope handles;
+    VALUE str = rb_funcall(data, rb_intern("to_s"), 0);
+    return rr_v8_handle_new(string_class, String::New(RSTRING_PTR(str), RSTRING_LEN(str)));
+  }
+  VALUE NewSymbol(VALUE string_class, VALUE data) {
+    HandleScope scope;
+    VALUE str = rb_funcall(data, rb_intern("to_s"), 0);
+    return rr_v8_handle_new(string_class, String::NewSymbol(RSTRING_PTR(str), RSTRING_LEN(str)));
+  }
+  VALUE Utf8Value(VALUE self) {
+    HandleScope handles;
+    Handle<String> str = unwrap(self);
+    return rb_str_new(*String::Utf8Value(str), str->Utf8Length());
+  }
+  VALUE Utf16Value(VALUE self) {
+    //How are UTF16 strings represented in ruby 1.8, 1.9
+    return Qnil;
+  }
+  VALUE AsciiValue(VALUE self) {
+    HandleScope handles;
+    Handle<String> str = unwrap(self);
+    return rb_str_new(*String::AsciiValue(str), str->Length());
+  }
+}
+
+VALUE rr_reflect_v8_string(Handle<Value> value) {
+  return rr_v8_handle_new(StringClass, Handle<String>::Cast(value));
+}
+
+void rr_init_string() {
+  StringClass = rr_define_class("String", rr_v8_value_class());
+  rr_define_singleton_method(StringClass, "New", New, 1);
+  rr_define_singleton_method(StringClass, "NewSymbol", NewSymbol, 1);
+  rr_define_method(StringClass, "Utf8Value", Utf8Value, 0);
+  rr_define_method(StringClass, "Utf16Value", Utf16Value, 0);
+  rr_define_method(StringClass, "AsciiValue", AsciiValue, 0);
+}