mini_racer 0.17.0.pre5 → 0.17.0.pre7

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -1,1942 +0,0 @@
-#include <stdio.h>
-#include <ruby.h>
-#include <ruby/thread.h>
-#include <ruby/io.h>
-#include <ruby/version.h>
-#include <v8.h>
-#include <v8-profiler.h>
-#include <libplatform/libplatform.h>
-#include <ruby/encoding.h>
-#include <pthread.h>
-#include <unistd.h>
-#include <mutex>
-#include <atomic>
-#include <math.h>
-#include <errno.h>
-
-/* workaround C Ruby <= 2.x problems w/ clang in C++ mode */
-#if defined(ENGINE_IS_CRUBY) && \
-	RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR <= 6
-#  define MR_METHOD_FUNC(fn) RUBY_METHOD_FUNC(fn)
-#else
-#  define MR_METHOD_FUNC(fn) fn
-#endif
-
-using namespace v8;
-
-typedef struct {
-    const char* data;
-    int raw_size;
-} SnapshotInfo;
-
-class IsolateInfo {
-public:
-    Isolate* isolate;
-    ArrayBuffer::Allocator* allocator;
-    StartupData* startup_data;
-    bool interrupted;
-    bool added_gc_cb;
-    pid_t pid;
-    VALUE mutex;
-
-    class Lock {
-        VALUE &mutex;
-
-    public:
-        Lock(VALUE &mutex) : mutex(mutex) {
-            rb_mutex_lock(mutex);
-        }
-        ~Lock() {
-            rb_mutex_unlock(mutex);
-        }
-    };
-
-
-    IsolateInfo() : isolate(nullptr), allocator(nullptr), startup_data(nullptr),
-        interrupted(false), added_gc_cb(false), pid(getpid()), refs_count(0) {
-        VALUE cMutex = rb_const_get(rb_cThread, rb_intern("Mutex"));
-        mutex = rb_class_new_instance(0, nullptr, cMutex);
-    }
-
-    ~IsolateInfo();
-
-    void init(SnapshotInfo* snapshot_info = nullptr);
-
-    void mark() {
-        rb_gc_mark(mutex);
-    }
-
-    Lock createLock() {
-        Lock lock(mutex);
-        return lock;
-    }
-
-    void hold() {
-        refs_count++;
-    }
-    void release() {
-        if (--refs_count <= 0) {
-            delete this;
-        }
-    }
-
-    int refs() {
-        return refs_count;
-    }
-
-    static void* operator new(size_t size) {
-        return ruby_xmalloc(size);
-    }
-
-    static void operator delete(void *block) {
-        xfree(block);
-    }
-private:
-    // how many references to this isolate exist
-    // we can't rely on Ruby's GC for this, because Ruby could destroy the
-    // isolate before destroying the contexts that depend on them. We'd need to
-    // keep a list of linked contexts in the isolate to destroy those first when
-    // isolate destruction was requested. Keeping such a list would require
-    // notification from the context VALUEs when they are constructed and
-    // destroyed. With a ref count, those notifications are still needed, but
-    // we keep a simple int rather than a list of pointers.
-    std::atomic_int refs_count;
-};
-
-typedef struct {
-    IsolateInfo* isolate_info;
-    Persistent<Context>* context;
-} ContextInfo;
-
-typedef struct {
-    bool parsed;
-    bool executed;
-    bool terminated;
-    bool json;
-    Persistent<Value>* value;
-    Persistent<Value>* message;
-    Persistent<Value>* backtrace;
-} EvalResult;
-
-typedef struct {
-    ContextInfo* context_info;
-    Local<String>* eval;
-    Local<String>* filename;
-    useconds_t timeout;
-    EvalResult* result;
-    size_t max_memory;
-    size_t marshal_stackdepth;
-} EvalParams;
-
-typedef struct {
-    ContextInfo *context_info;
-    char *function_name;
-    int argc;
-    bool error;
-    Local<Function> fun;
-    Local<Value> *argv;
-    EvalResult result;
-    size_t max_memory;
-    size_t marshal_stackdepth;
-} FunctionCall;
-
-class IsolateData {
-public:
-    enum Flag {
-        // first flags are bitfield
-        //  max count: sizeof(uintptr_t) * 8
-        IN_GVL, // whether we are inside of ruby gvl or not
-        DO_TERMINATE, // terminate as soon as possible
-        MEM_SOFTLIMIT_REACHED, // we've hit the memory soft limit
-        MEM_SOFTLIMIT_MAX, // maximum memory value
-        MARSHAL_STACKDEPTH_REACHED, // we've hit our max stack depth
-        MARSHAL_STACKDEPTH_VALUE, // current stackdepth
-        MARSHAL_STACKDEPTH_MAX, // maximum stack depth during marshal
-    };
-
-    static void Init(Isolate *isolate) {
-        // zero out all fields in the bitfield
-        isolate->SetData(0, 0);
-    }
-
-    static uintptr_t Get(Isolate *isolate, Flag flag) {
-        Bitfield u = { reinterpret_cast<uint64_t>(isolate->GetData(0)) };
-        switch (flag) {
-            case IN_GVL: return u.IN_GVL;
-            case DO_TERMINATE: return u.DO_TERMINATE;
-            case MEM_SOFTLIMIT_REACHED: return u.MEM_SOFTLIMIT_REACHED;
-            case MEM_SOFTLIMIT_MAX: return static_cast<uintptr_t>(u.MEM_SOFTLIMIT_MAX) << 10;
-            case MARSHAL_STACKDEPTH_REACHED: return u.MARSHAL_STACKDEPTH_REACHED;
-            case MARSHAL_STACKDEPTH_VALUE: return u.MARSHAL_STACKDEPTH_VALUE;
-            case MARSHAL_STACKDEPTH_MAX: return u.MARSHAL_STACKDEPTH_MAX;
-        }
-
-	// avoid compiler warning
-	return u.IN_GVL;
-    }
-
-    static void Set(Isolate *isolate, Flag flag, uintptr_t value) {
-        Bitfield u = { reinterpret_cast<uint64_t>(isolate->GetData(0)) };
-        switch (flag) {
-            case IN_GVL: u.IN_GVL = value; break;
-            case DO_TERMINATE: u.DO_TERMINATE = value; break;
-            case MEM_SOFTLIMIT_REACHED: u.MEM_SOFTLIMIT_REACHED = value; break;
-            // drop least significant 10 bits 'store memory amount in kb'
-            case MEM_SOFTLIMIT_MAX: u.MEM_SOFTLIMIT_MAX = value >> 10; break;
-            case MARSHAL_STACKDEPTH_REACHED: u.MARSHAL_STACKDEPTH_REACHED = value; break;
-            case MARSHAL_STACKDEPTH_VALUE: u.MARSHAL_STACKDEPTH_VALUE = value; break;
-            case MARSHAL_STACKDEPTH_MAX: u.MARSHAL_STACKDEPTH_MAX = value; break;
-        }
-        isolate->SetData(0, reinterpret_cast<void*>(u.dataPtr));
-    }
-
-private:
-    struct Bitfield {
-        // WARNING: this would explode on platforms below 64 bit ptrs
-        //  compiler will fail here, making it clear for them.
-        //  Additionally, using the other part of the union to reinterpret the
-        //  memory is undefined behavior according to spec, but is / has been stable
-        //  across major compilers for decades.
-        static_assert(sizeof(uintptr_t) >= sizeof(uint64_t), "mini_racer not supported on this platform. ptr size must be at least 64 bit.");
-        union {
-            uint64_t dataPtr: 64;
-            // order in this struct matters. For cpu performance keep larger subobjects
-            //  aligned on their boundaries (8 16 32), try not to straddle
-            struct {
-                size_t MEM_SOFTLIMIT_MAX:22;
-                bool IN_GVL:1;
-                bool DO_TERMINATE:1;
-                bool MEM_SOFTLIMIT_REACHED:1;
-                bool MARSHAL_STACKDEPTH_REACHED:1;
-                uint8_t :0; // align to next 8bit bound
-                size_t MARSHAL_STACKDEPTH_VALUE:10;
-                uint8_t :0; // align to next 8bit bound
-                size_t MARSHAL_STACKDEPTH_MAX:10;
-            };
-        };
-    };
-};
-
-struct StackCounter {
-    static void Reset(Isolate* isolate) {
-        if (IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX) > 0) {
-            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, 0);
-            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, false);
-        }
-    }
-
-    static void SetMax(Isolate* isolate, size_t marshalMaxStackDepth) {
-        if (marshalMaxStackDepth > 0) {
-            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX, marshalMaxStackDepth);
-            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, 0);
-            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, false);
-        }
-    }
-
-    StackCounter(Isolate* isolate) {
-        this->isActive = IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX) > 0;
-
-        if (this->isActive) {
-            this->isolate = isolate;
-            this->IncDepth(1);
-        }
-    }
-
-    bool IsTooDeep() {
-        if (!this->IsActive()) {
-            return false;
-        }
-
-        size_t depth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE);
-        size_t maxDepth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_MAX);
-        if (depth > maxDepth) {
-            IsolateData::Set(this->isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, true);
-            return true;
-        }
-
-        return false;
-    }
-
-    bool IsActive() {
-        return this->isActive && !IsolateData::Get(this->isolate, IsolateData::DO_TERMINATE);
-    }
-
-    ~StackCounter() {
-        if (this->IsActive()) {
-            this->IncDepth(-1);
-        }
-    }
-
-private: 
-    Isolate* isolate;
-    bool isActive;
-
-    void IncDepth(int direction) {
-        int inc = direction > 0 ? 1 : -1;
-
-        size_t depth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE);
-
-        // don't decrement past 0
-        if (inc > 0 || depth > 0) {
-            depth += inc;
-        }
-
-        IsolateData::Set(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, depth);
-    }
-};
-
-static VALUE rb_cContext;
-static VALUE rb_cSnapshot;
-static VALUE rb_cIsolate;
-
-static VALUE rb_eScriptTerminatedError;
-static VALUE rb_eV8OutOfMemoryError;
-static VALUE rb_eParseError;
-static VALUE rb_eScriptRuntimeError;
-static VALUE rb_cJavaScriptFunction;
-static VALUE rb_eSnapshotError;
-static VALUE rb_ePlatformAlreadyInitializedError;
-static VALUE rb_mJSON;
-
-static VALUE rb_cFailedV8Conversion;
-static VALUE rb_cDateTime = Qnil;
-
-static std::unique_ptr<Platform> current_platform = NULL;
-static std::mutex platform_lock;
-
-static pthread_attr_t *thread_attr_p;
-static std::atomic_int ruby_exiting(0);
-static bool single_threaded = false;
-
-static void mark_context(void *);
-static void deallocate(void *);
-static size_t context_memsize(const void *);
-static const rb_data_type_t context_type = {
-    "mini_racer/context_info",
-    { mark_context, deallocate, context_memsize }
-};
-
-static void deallocate_snapshot(void *);
-static size_t snapshot_memsize(const void *);
-static const rb_data_type_t snapshot_type = {
-    "mini_racer/snapshot_info",
-    { NULL, deallocate_snapshot, snapshot_memsize }
-};
-
-static void mark_isolate(void *);
-static void deallocate_isolate(void *);
-static size_t isolate_memsize(const void *);
-static const rb_data_type_t isolate_type = {
-    "mini_racer/isolate_info",
-    { mark_isolate, deallocate_isolate, isolate_memsize }
-};
-
-static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
-    bool platform_already_initialized = false;
-
-    Check_Type(flag_as_str, T_STRING);
-
-    platform_lock.lock();
-
-    if (current_platform == NULL) {
-	if (!strcmp(RSTRING_PTR(flag_as_str), "--single_threaded")) {
-	   single_threaded = true;
-	}
-        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), RSTRING_LENINT(flag_as_str));
-    } else {
-        platform_already_initialized = true;
-    }
-
-    platform_lock.unlock();
-
-    // important to raise outside of the lock
-    if (platform_already_initialized) {
-        rb_raise(rb_ePlatformAlreadyInitializedError, "The V8 platform is already initialized");
-    }
-
-    return Qnil;
-}
-
-static void init_v8() {
-    // no need to wait for the lock if already initialized
-    if (current_platform != NULL) return;
-
-    platform_lock.lock();
-
-    if (current_platform == NULL) {
-        V8::InitializeICU();
-	if (single_threaded) {
-	    current_platform = platform::NewSingleThreadedDefaultPlatform();
-	} else {
-	    current_platform = platform::NewDefaultPlatform();
-	}
-        V8::InitializePlatform(current_platform.get());
-        V8::Initialize();
-    }
-
-    platform_lock.unlock();
-}
-
-static void gc_callback(Isolate *isolate, GCType type, GCCallbackFlags flags) {
-    if (IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED)) {
-        return;
-    }
-
-    size_t softlimit = IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_MAX);
-
-    HeapStatistics stats;
-    isolate->GetHeapStatistics(&stats);
-    size_t used = stats.used_heap_size();
-
-    if(used > softlimit) {
-        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, true);
-        isolate->TerminateExecution();
-    }
-}
-
-// to be called with active lock and scope
-static void prepare_result(MaybeLocal<Value> v8res,
-                           TryCatch& trycatch,
-                           Isolate* isolate,
-                           Local<Context> context,
-                           EvalResult& evalRes /* out */) {
-
-    // just don't touch .parsed
-    evalRes.terminated = false;
-    evalRes.json = false;
-    evalRes.value = nullptr;
-    evalRes.message = nullptr;
-    evalRes.backtrace = nullptr;
-    evalRes.executed = !v8res.IsEmpty();
-
-    if (evalRes.executed) {
-        // arrays and objects get converted to json
-        Local<Value> local_value = v8res.ToLocalChecked();
-        if ((local_value->IsObject() || local_value->IsArray()) &&
-                !local_value->IsDate() && !local_value->IsFunction()) {
-            MaybeLocal<v8::Value> ml = context->Global()->Get(
-                        context, String::NewFromUtf8Literal(isolate, "JSON"));
-
-            if (ml.IsEmpty()) { // exception
-                evalRes.executed = false;
-            } else {
-                Local<Object> JSON = ml.ToLocalChecked().As<Object>();
-
-                Local<Function> stringify = JSON->Get(
-                            context, v8::String::NewFromUtf8Literal(isolate, "stringify"))
-                        .ToLocalChecked().As<Function>();
-
-                Local<Object> object = local_value->ToObject(context).ToLocalChecked();
-                const unsigned argc = 1;
-                Local<Value> argv[argc] = { object };
-                MaybeLocal<Value> maybe_json = stringify->Call(context, JSON, argc, argv);
-                Local<Value> json;
-
-                if (!maybe_json.ToLocal(&json)) {
-                    evalRes.executed = false;
-                } else {
-                    // JSON.stringify() returns undefined for inputs that
-                    // are exotic objects, like WASM function or string refs
-                    evalRes.json = !json->IsUndefined();
-                    Persistent<Value>* persistent = new Persistent<Value>();
-                    persistent->Reset(isolate, json);
-                    evalRes.value = persistent;
-                }
-            }
-        } else {
-            Persistent<Value>* persistent = new Persistent<Value>();
-            persistent->Reset(isolate, local_value);
-            evalRes.value = persistent;
-        }
-    }
-
-    if (!evalRes.executed || !evalRes.parsed) {
-        if (trycatch.HasCaught()) {
-            if (!trycatch.Exception()->IsNull()) {
-                evalRes.message = new Persistent<Value>();
-                Local<Message> message = trycatch.Message();
-                char buf[1000];
-                int len, line, column;
-
-                if (!message->GetLineNumber(context).To(&line)) {
-                  line = 0;
-                }
-
-                if (!message->GetStartColumn(context).To(&column)) {
-                  column = 0;
-                }
-
-                len = snprintf(buf, sizeof(buf), "%s at %s:%i:%i", *String::Utf8Value(isolate, message->Get()),
-                               *String::Utf8Value(isolate, message->GetScriptResourceName()->ToString(context).ToLocalChecked()),
-                               line,
-                               column);
-
-                if ((size_t) len >= sizeof(buf)) {
-                    len = sizeof(buf) - 1;
-                    buf[len] = '\0';
-                }
-
-                Local<String> v8_message = String::NewFromUtf8(isolate, buf, NewStringType::kNormal, len).ToLocalChecked();
-                evalRes.message->Reset(isolate, v8_message);
-            } else if(trycatch.HasTerminated()) {
-                evalRes.terminated = true;
-                evalRes.message = new Persistent<Value>();
-                Local<String> tmp = String::NewFromUtf8Literal(isolate, "JavaScript was terminated (either by timeout or explicitly)");
-                evalRes.message->Reset(isolate, tmp);
-            }
-            if (!trycatch.StackTrace(context).IsEmpty()) {
-                evalRes.backtrace = new Persistent<Value>();
-                evalRes.backtrace->Reset(isolate,
-                                         trycatch.StackTrace(context).ToLocalChecked()->ToString(context).ToLocalChecked());
-            }
-        }
-    }
-}
-
-static void*
-nogvl_context_eval(void* arg) {
-
-    EvalParams* eval_params = (EvalParams*)arg;
-    EvalResult* result = eval_params->result;
-    IsolateInfo* isolate_info = eval_params->context_info->isolate_info;
-    Isolate* isolate = isolate_info->isolate;
-
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-    TryCatch trycatch(isolate);
-    Local<Context> context = eval_params->context_info->context->Get(isolate);
-    Context::Scope context_scope(context);
-    v8::ScriptOrigin *origin = NULL;
-
-    IsolateData::Init(isolate);
-
-    if (eval_params->max_memory > 0) {
-        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_MAX, eval_params->max_memory);
-        if (!isolate_info->added_gc_cb) {
-            isolate->AddGCEpilogueCallback(gc_callback);
-            isolate_info->added_gc_cb = true;
-        }
-    }
-
-    MaybeLocal<Script> parsed_script;
-
-    if (eval_params->filename) {
-        origin = new v8::ScriptOrigin(isolate, *eval_params->filename);
-    }
-
-    parsed_script = Script::Compile(context, *eval_params->eval, origin);
-
-    if (origin) {
-        delete origin;
-    }
-
-    result->parsed = !parsed_script.IsEmpty();
-    result->executed = false;
-    result->terminated = false;
-    result->json = false;
-    result->value = NULL;
-
-    MaybeLocal<Value> maybe_value;
-    if (!result->parsed) {
-        result->message = new Persistent<Value>();
-        result->message->Reset(isolate, trycatch.Exception());
-    } else {
-        // parsing successful
-        if (eval_params->marshal_stackdepth > 0) {
-            StackCounter::SetMax(isolate, eval_params->marshal_stackdepth);
-        }
-
-        maybe_value = parsed_script.ToLocalChecked()->Run(context);
-    }
-
-    prepare_result(maybe_value, trycatch, isolate, context, *result);
-
-    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
-
-    return NULL;
-}
-
-static VALUE new_empty_failed_conv_obj() {
-    // TODO isolate code that translates execption to ruby
-    // exception so we can properly return it
-    return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
-}
-
-// assumes isolate locking is in place
-static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
-                                Local<Value> value) {
-
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope scope(isolate);
-    Context::Scope context_scope(context);
-
-    StackCounter stackCounter(isolate);
-
-    if (IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED)) {
-        return Qnil;
-    }
-
-    if (stackCounter.IsTooDeep()) {
-        IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
-        isolate->TerminateExecution();
-        return Qnil;
-    }
-
-    if (value->IsNull() || value->IsUndefined()){
-        return Qnil;
-    }
-
-    if (value->IsInt32()) {
-        return INT2FIX(value->Int32Value(context).ToChecked());
-    }
-
-    if (value->IsTrue()) {
-        return Qtrue;
-    }
-
-    if (value->IsFalse()) {
-        return Qfalse;
-    }
-
-    struct State {
-        Isolate* isolate;
-        Local<Value> value;
-        Local<Context> context;
-    } state = {isolate, value, context};
-
-    // calls to rb_*() functions can raise exceptions and longjmp,
-    // and therefore must be inside this protected block
-    auto can_raise = [](VALUE arg) -> VALUE {
-        State* state =
-            reinterpret_cast<State*>(static_cast<uintptr_t>(RB_NUM2ULL(arg)));
-        Isolate* isolate = state->isolate;
-        Local<Value> value = state->value;
-        Local<Context> context = state->context;
-
-        if (value->IsNumber()) {
-            return rb_float_new(value->NumberValue(context).ToChecked());
-        }
-
-        if (value->IsArray()) {
-            VALUE rb_array = rb_ary_new();
-            Local<Array> arr = Local<Array>::Cast(value);
-            for(uint32_t i = 0; i < arr->Length(); i++) {
-                MaybeLocal<Value> element = arr->Get(context, i);
-                if (element.IsEmpty()) {
-                    continue;
-                }
-                VALUE rb_elem = convert_v8_to_ruby(isolate, context, element.ToLocalChecked());
-                if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
-                    return rb_elem;
-                }
-                rb_ary_push(rb_array, rb_elem);
-            }
-            return rb_array;
-        }
-
-        if (value->IsFunction()){
-            return rb_funcall(rb_cJavaScriptFunction, rb_intern("new"), 0);
-        }
-
-        if (value->IsDate()){
-            double ts = Local<Date>::Cast(value)->ValueOf();
-            double secs = ts/1000;
-            long nanos = round((secs - floor(secs)) * 1000000);
-
-            return rb_time_new(secs, nanos);
-        }
-
-        if (value->IsObject()) {
-            VALUE rb_hash = rb_hash_new();
-            TryCatch trycatch(isolate);
-
-            Local<Object> object = value->ToObject(context).ToLocalChecked();
-            auto maybe_props = object->GetOwnPropertyNames(context);
-            if (!maybe_props.IsEmpty()) {
-                Local<Array> props = maybe_props.ToLocalChecked();
-                for (uint32_t i = 0; i < props->Length(); i++) {
-                    MaybeLocal<Value> key = props->Get(context, i);
-                    if (key.IsEmpty()) {
-                        return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
-                    }
-                    VALUE rb_key = convert_v8_to_ruby(isolate, context, key.ToLocalChecked());
-
-                    MaybeLocal<Value> prop_value = object->Get(context, key.ToLocalChecked());
-                    // this may have failed due to Get raising
-                    if (prop_value.IsEmpty() || trycatch.HasCaught()) {
-                        return new_empty_failed_conv_obj();
-                    }
-
-                    VALUE rb_value = convert_v8_to_ruby(
-                             isolate, context, prop_value.ToLocalChecked());
-                    rb_hash_aset(rb_hash, rb_key, rb_value);
-                }
-            }
-            return rb_hash;
-        }
-
-        if (value->IsSymbol()) {
-            Local<Symbol> symbol = Local<Symbol>::Cast(value);
-            Local<Value> description = symbol->Description(isolate);
-            v8::String::Utf8Value symbol_name(isolate, description);
-
-            VALUE str_symbol = rb_utf8_str_new(*symbol_name, symbol_name.length());
-
-            return rb_str_intern(str_symbol);
-        }
-
-        MaybeLocal<String> rstr_maybe = value->ToString(context);
-
-        if (rstr_maybe.IsEmpty()) {
-            return Qnil;
-        } else {
-            Local<String> rstr = rstr_maybe.ToLocalChecked();
-            return rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
-        }
-    };
-
-    // this is kind of slow because RB_ULL2NUM allocs when the pointer
-    // doesn't fit in a fixnum but yolo'ing and reinterpret_casting the
-    // pointer to a VALUE is probably not very sound
-    VALUE arg = RB_ULL2NUM(reinterpret_cast<uintptr_t>(&state));
-    return rb_protect(can_raise, arg, nullptr);
-}
-
-static VALUE convert_v8_to_ruby(Isolate* isolate,
-                                const Persistent<Context>& context,
-                                Local<Value> value) {
-    HandleScope scope(isolate);
-    return convert_v8_to_ruby(isolate,
-                              Local<Context>::New(isolate, context),
-                              value);
-}
-
-static VALUE convert_v8_to_ruby(Isolate* isolate,
-                                const Persistent<Context>& context,
-                                const Persistent<Value>& value) {
-    HandleScope scope(isolate);
-    return convert_v8_to_ruby(isolate,
-                              Local<Context>::New(isolate, context),
-                              Local<Value>::New(isolate, value));
-}
-
-static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context, VALUE value) {
-    EscapableHandleScope scope(isolate);
-
-    Local<Array> array;
-    Local<Object> object;
-    VALUE hash_as_array;
-    VALUE pair;
-    int i;
-    long length;
-    long fixnum;
-    VALUE klass;
-
-    switch (TYPE(value)) {
-    case T_FIXNUM:
-        fixnum = NUM2LONG(value);
-        if (fixnum > INT_MAX)
-        {
-            return scope.Escape(Number::New(isolate, (double)fixnum));
-        }
-        return scope.Escape(Integer::New(isolate, (int)fixnum));
-    case T_FLOAT:
-	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
-    case T_STRING:
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, RSTRING_LENINT(value)).ToLocalChecked());
-    case T_NIL:
-	return scope.Escape(Null(isolate));
-    case T_TRUE:
-	return scope.Escape(True(isolate));
-    case T_FALSE:
-	return scope.Escape(False(isolate));
-    case T_ARRAY:
-	length = RARRAY_LEN(value);
-	array = Array::New(isolate, (int)length);
-	for(i=0; i<length; i++) {
-            Maybe<bool> success = array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
-	    (void)(success);
-	}
-	return scope.Escape(array);
-    case T_HASH:
-	object = Object::New(isolate);
-	hash_as_array = rb_funcall(value, rb_intern("to_a"), 0);
-	length = RARRAY_LEN(hash_as_array);
-	for(i=0; i<length; i++) {
-	    pair = rb_ary_entry(hash_as_array, i);
-            Maybe<bool> success = object->Set(context, convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
-                  convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 1)));
-	    (void)(success);
-	}
-	return scope.Escape(object);
-    case T_SYMBOL:
-	value = rb_funcall(value, rb_intern("to_s"), 0);
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, RSTRING_LENINT(value)).ToLocalChecked());
-    case T_DATA:
-        klass = rb_funcall(value, rb_intern("class"), 0);
-        if (klass == rb_cTime || klass == rb_cDateTime)
-        {
-            if (klass == rb_cDateTime)
-            {
-                value = rb_funcall(value, rb_intern("to_time"), 0);
-            }
-            value = rb_funcall(value, rb_intern("to_f"), 0);
-            return scope.Escape(Date::New(context, NUM2DBL(value) * 1000).ToLocalChecked());
-        }
-    case T_OBJECT:
-    case T_CLASS:
-    case T_ICLASS:
-    case T_MODULE:
-    case T_REGEXP:
-    case T_MATCH:
-    case T_STRUCT:
-    case T_BIGNUM:
-    case T_FILE:
-    case T_UNDEF:
-    case T_NODE:
-    default:
-      return scope.Escape(String::NewFromUtf8Literal(isolate, "Undefined Conversion"));
-    }
-    }
-
-static void unblock_eval(void *ptr) {
-    EvalParams* eval = (EvalParams*)ptr;
-    eval->context_info->isolate_info->interrupted = true;
-}
-
-/*
- * The implementations of the run_extra_code(), create_snapshot_data_blob() and
- * warm_up_snapshot_data_blob() functions have been derived from V8's test suite.
- */
-static bool run_extra_code(Isolate *isolate, Local<v8::Context> context,
-                    const char *utf8_source, const char *name) {
-    Context::Scope context_scope(context);
-    TryCatch try_catch(isolate);
-    Local<String> source_string;
-    if (!String::NewFromUtf8(isolate, utf8_source).ToLocal(&source_string)) {
-        return false;
-    }
-    Local<String> resource_name =
-            String::NewFromUtf8(isolate, name).ToLocalChecked();
-    ScriptOrigin origin(isolate, resource_name);
-    ScriptCompiler::Source source(source_string, origin);
-    Local<Script> script;
-    if (!ScriptCompiler::Compile(context, &source).ToLocal(&script))
-        return false;
-    if (script->Run(context).IsEmpty()) return false;
-    return true;
-}
-
-static StartupData
-create_snapshot_data_blob(const char *embedded_source = nullptr) {
-    Isolate *isolate = Isolate::Allocate();
-
-    // Optionally run a script to embed, and serialize to create a snapshot blob.
-    SnapshotCreator snapshot_creator(isolate);
-        {
-            HandleScope scope(isolate);
-        Local<v8::Context> context = v8::Context::New(isolate);
-            if (embedded_source != nullptr &&
-                !run_extra_code(isolate, context, embedded_source, "<embedded>")) {
-           return {};
-            }
-            snapshot_creator.SetDefaultContext(context);
-        }
-    return snapshot_creator.CreateBlob(
-            SnapshotCreator::FunctionCodeHandling::kClear);
-    }
-
-static
-StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
-                                       const char *warmup_source) {
-    // Use following steps to create a warmed up snapshot blob from a cold one:
-    //  - Create a new isolate from the cold snapshot.
-    //  - Create a new context to run the warmup script. This will trigger
-    //    compilation of executed functions.
-    //  - Create a new context. This context will be unpolluted.
-    //  - Serialize the isolate and the second context into a new snapshot blob.
-    StartupData result = {nullptr, 0};
-
-    if (cold_snapshot_blob.raw_size > 0 && cold_snapshot_blob.data != nullptr &&
-        warmup_source != NULL) {
-        SnapshotCreator snapshot_creator(nullptr, &cold_snapshot_blob);
-        Isolate *isolate = snapshot_creator.GetIsolate();
-        {
-            HandleScope scope(isolate);
-            Local<Context> context = Context::New(isolate);
-            if (!run_extra_code(isolate, context, warmup_source, "<warm-up>")) {
-                return result;
-            }
-        }
-        {
-            HandleScope handle_scope(isolate);
-            isolate->ContextDisposedNotification(false);
-            Local<Context> context = Context::New(isolate);
-            snapshot_creator.SetDefaultContext(context);
-        }
-        result = snapshot_creator.CreateBlob(
-            SnapshotCreator::FunctionCodeHandling::kKeep);
-    }
-    return result;
-}
-
-static VALUE rb_snapshot_size(VALUE self) {
-    SnapshotInfo* snapshot_info;
-    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
-
-    return INT2NUM(snapshot_info->raw_size);
-}
-
-static VALUE rb_snapshot_load(VALUE self, VALUE str) {
-    SnapshotInfo* snapshot_info;
-    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
-
-    Check_Type(str, T_STRING);
-
-    init_v8();
-
-    StartupData startup_data = create_snapshot_data_blob(RSTRING_PTR(str));
-
-    if (startup_data.data == NULL && startup_data.raw_size == 0) {
-        rb_raise(rb_eSnapshotError, "Could not create snapshot, most likely the source is incorrect");
-    }
-
-    snapshot_info->data = startup_data.data;
-    snapshot_info->raw_size = startup_data.raw_size;
-
-    return Qnil;
-}
-
-static VALUE rb_snapshot_dump(VALUE self) {
-    SnapshotInfo* snapshot_info;
-    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
-
-    return rb_str_new(snapshot_info->data, snapshot_info->raw_size);
-}
-
-static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
-    SnapshotInfo* snapshot_info;
-    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
-
-    Check_Type(str, T_STRING);
-
-    init_v8();
-
-    StartupData cold_startup_data = {snapshot_info->data, snapshot_info->raw_size};
-    StartupData warm_startup_data = warm_up_snapshot_data_blob(cold_startup_data, RSTRING_PTR(str));
-
-    if (warm_startup_data.data == NULL && warm_startup_data.raw_size == 0) {
-        rb_raise(rb_eSnapshotError, "Could not warm up snapshot, most likely the source is incorrect");
-    } else {
-        delete[] snapshot_info->data;
-
-        snapshot_info->data = warm_startup_data.data;
-        snapshot_info->raw_size = warm_startup_data.raw_size;
-    }
-
-    return self;
-}
-
-void IsolateInfo::init(SnapshotInfo* snapshot_info) {
-    allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
-
-    Isolate::CreateParams create_params;
-    create_params.array_buffer_allocator = allocator;
-
-    if (snapshot_info) {
-        int raw_size = snapshot_info->raw_size;
-        char* data = new char[raw_size];
-        memcpy(data, snapshot_info->data, raw_size);
-
-        startup_data = new StartupData;
-        startup_data->data = data;
-        startup_data->raw_size = raw_size;
-
-        create_params.snapshot_blob = startup_data;
-    }
-
-    isolate = Isolate::New(create_params);
-}
-
-static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
-    IsolateInfo* isolate_info;
-    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
-
-    init_v8();
-
-    SnapshotInfo* snapshot_info = nullptr;
-    if (!NIL_P(snapshot)) {
-        TypedData_Get_Struct(snapshot, SnapshotInfo, &snapshot_type, snapshot_info);
-    }
-
-    isolate_info->init(snapshot_info);
-    isolate_info->hold();
-
-    return Qnil;
-}
-
-static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
-    IsolateInfo* isolate_info;
-    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
-
-    if (current_platform == NULL) return Qfalse;
-
-    double duration = NUM2DBL(idle_time_in_ms) / 1000.0;
-    double now = current_platform->MonotonicallyIncreasingTime();
-    return isolate_info->isolate->IdleNotificationDeadline(now + duration) ? Qtrue : Qfalse;
-}
-
-static VALUE rb_isolate_low_memory_notification(VALUE self) {
-    IsolateInfo* isolate_info;
-    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
-
-    if (current_platform == NULL) return Qfalse;
-
-    Locker guard { isolate_info->isolate };
-
-    isolate_info->isolate->LowMemoryNotification();
-    return Qnil;
-}
-
-static VALUE rb_isolate_pump_message_loop(VALUE self) {
-    IsolateInfo* isolate_info;
-    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
-
-    if (current_platform == NULL) return Qfalse;
-
-    Locker guard { isolate_info->isolate };
-
-    if (platform::PumpMessageLoop(current_platform.get(), isolate_info->isolate)){
-	return Qtrue;
-    } else {
-	return Qfalse;
-    }
-}
-
-static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-
-    init_v8();
-
-    IsolateInfo* isolate_info;
-
-    if (NIL_P(isolate) || !rb_obj_is_kind_of(isolate, rb_cIsolate)) {
-        isolate_info = new IsolateInfo();
-
-        SnapshotInfo *snapshot_info = nullptr;
-        if (!NIL_P(snap) && rb_obj_is_kind_of(snap, rb_cSnapshot)) {
-            TypedData_Get_Struct(snap, SnapshotInfo, &snapshot_type, snapshot_info);
-        }
-        isolate_info->init(snapshot_info);
-    } else { // given isolate or snapshot
-        TypedData_Get_Struct(isolate, IsolateInfo, &isolate_type, isolate_info);
-    }
-
-    context_info->isolate_info = isolate_info;
-    isolate_info->hold();
-
-    {
-        // the ruby lock is needed if this isn't a new isolate
-        IsolateInfo::Lock ruby_lock(isolate_info->mutex);
-        Locker lock(isolate_info->isolate);
-        Isolate::Scope isolate_scope(isolate_info->isolate);
-        HandleScope handle_scope(isolate_info->isolate);
-
-        Local<Context> context = Context::New(isolate_info->isolate);
-
-        context_info->context = new Persistent<Context>();
-        context_info->context->Reset(isolate_info->isolate, context);
-    }
-
-    if (Qnil == rb_cDateTime && rb_funcall(rb_cObject, rb_intern("const_defined?"), 1, rb_str_new2("DateTime")) == Qtrue)
-    {
-        rb_cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
-    }
-
-    return Qnil;
-}
-
-static VALUE convert_result_to_ruby(VALUE self /* context */,
-                                    EvalResult& result) {
-    ContextInfo *context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-
-    Isolate *isolate = context_info->isolate_info->isolate;
-    Persistent<Context> *p_ctx = context_info->context;
-
-    VALUE message = Qnil;
-    VALUE backtrace = Qnil;
-    {
-        Locker lock(isolate);
-        if (result.message) {
-            message = convert_v8_to_ruby(isolate, *p_ctx, *result.message);
-            result.message->Reset();
-            delete result.message;
-            result.message = nullptr;
-        }
-
-        if (result.backtrace) {
-            backtrace = convert_v8_to_ruby(isolate, *p_ctx, *result.backtrace);
-            result.backtrace->Reset();
-            delete result.backtrace;
-        }
-    }
-
-    // NOTE: this is very important, we can not do an rb_raise from within
-    // a v8 scope, if we do the scope is never cleaned up properly and we leak
-    if (!result.parsed) {
-        if(TYPE(message) == T_STRING) {
-            rb_raise(rb_eParseError, "%" PRIsVALUE, message);
-        } else {
-            rb_raise(rb_eParseError, "Unknown JavaScript Error during parse");
-        }
-    }
-
-    if (!result.executed) {
-        VALUE ruby_exception = rb_iv_get(self, "@current_exception");
-        if (ruby_exception == Qnil) {
-            bool mem_softlimit_reached = IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED);
-            bool marshal_stack_maxdepth_reached = IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED);
-            // If we were terminated or have the memory softlimit flag set
-            if (marshal_stack_maxdepth_reached) {
-                ruby_exception = rb_eScriptRuntimeError;
-                message = rb_utf8_str_new_literal("Marshal object depth too deep. Script terminated.");
-            } else if (result.terminated || mem_softlimit_reached) {
-                ruby_exception = mem_softlimit_reached ? rb_eV8OutOfMemoryError : rb_eScriptTerminatedError;
-            } else {
-                ruby_exception = rb_eScriptRuntimeError;
-            }
-
-            // exception report about what happened
-            if (TYPE(backtrace) == T_STRING) {
-                rb_raise(ruby_exception, "%" PRIsVALUE, backtrace);
-            } else if(TYPE(message) == T_STRING) {
-                rb_raise(ruby_exception, "%" PRIsVALUE, message);
-            } else {
-                rb_raise(ruby_exception, "Unknown JavaScript Error during execution");
-            }
-        } else if (rb_obj_is_kind_of(ruby_exception, rb_eException)) {
-            rb_exc_raise(ruby_exception);
-        } else {
-            VALUE rb_str = rb_funcall(ruby_exception, rb_intern("to_s"), 0);
-            rb_raise(CLASS_OF(ruby_exception), "%" PRIsVALUE, rb_str);
-        }
-    }
-
-    VALUE ret = Qnil;
-
-    // New scope for return value
-    {
-        Locker lock(isolate);
-        Isolate::Scope isolate_scope(isolate);
-        HandleScope handle_scope(isolate);
-
-        Local<Value> tmp = Local<Value>::New(isolate, *result.value);
-
-        if (result.json) {
-            Local<String> rstr = tmp->ToString(p_ctx->Get(isolate)).ToLocalChecked();
-            VALUE json_string = rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
-            ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
-        } else {
-            StackCounter::Reset(isolate);
-            ret = convert_v8_to_ruby(isolate, *p_ctx, tmp);
-        }
-
-        result.value->Reset();
-        delete result.value;
-    }
-
-    if (rb_funcall(ret, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
-        // TODO try to recover stack trace from the conversion error
-        rb_raise(rb_eScriptRuntimeError, "Error converting JS object to Ruby object");
-    }
-
-
-    return ret;
-}
-
-static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
-
-    EvalParams eval_params;
-    EvalResult eval_result;
-    ContextInfo* context_info;
-
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-    Check_Type(str, T_STRING);
-
-    if (!NIL_P(filename)) {
-        Check_Type(filename, T_STRING);
-    }
-
-    {
-        Locker lock(isolate);
-        Isolate::Scope isolate_scope(isolate);
-        HandleScope handle_scope(isolate);
-
-        Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
-                    NewStringType::kNormal, RSTRING_LENINT(str)).ToLocalChecked();
-
-        Local<String> local_filename;
-
-        if (filename != Qnil) {
-            local_filename = String::NewFromUtf8(isolate, RSTRING_PTR(filename),
-                NewStringType::kNormal, RSTRING_LENINT(filename)).ToLocalChecked();
-            eval_params.filename = &local_filename;
-        } else {
-            eval_params.filename = NULL;
-        }
-
-        eval_params.context_info = context_info;
-        eval_params.eval = &eval;
-        eval_params.result = &eval_result;
-        eval_params.timeout = 0;
-        eval_params.max_memory = 0;
-        eval_params.marshal_stackdepth = 0;
-        VALUE timeout = rb_iv_get(self, "@timeout");
-        if (timeout != Qnil) {
-            eval_params.timeout = (useconds_t)NUM2LONG(timeout);
-        }
-
-        VALUE mem_softlimit = rb_iv_get(self, "@max_memory");
-        if (mem_softlimit != Qnil) {
-            eval_params.max_memory = (size_t)NUM2ULONG(mem_softlimit);
-        }
-
-        VALUE stack_depth = rb_iv_get(self, "@marshal_stack_depth");
-        if (stack_depth != Qnil) {
-            eval_params.marshal_stackdepth = (size_t)NUM2ULONG(stack_depth);
-        }
-
-        eval_result.message = NULL;
-        eval_result.backtrace = NULL;
-
-        rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
-    }
-
-    return convert_result_to_ruby(self, eval_result);
-}
-
-typedef struct {
-    VALUE callback;
-    int length;
-    VALUE ruby_args;
-    bool failed;
-} protected_callback_data;
-
-static VALUE protected_callback(VALUE rdata) {
-    protected_callback_data* data = (protected_callback_data*)rdata;
-    VALUE result;
-
-    if (data->length > 0) {
-        result = rb_funcall2(data->callback, rb_intern("call"), data->length,
-                     RARRAY_PTR(data->ruby_args));
-        RB_GC_GUARD(data->ruby_args);
-    } else {
-        result = rb_funcall(data->callback, rb_intern("call"), 0);
-    }
-    return result;
-}
-
-static
-VALUE rescue_callback(VALUE rdata, VALUE exception) {
-    protected_callback_data* data = (protected_callback_data*)rdata;
-    data->failed = true;
-    return exception;
-}
-
-static void*
-gvl_ruby_callback(void* data) {
-
-    FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
-    VALUE ruby_args = Qnil;
-    int length = args->Length();
-    VALUE callback;
-    VALUE result;
-    VALUE self;
-    VALUE parent;
-    ContextInfo* context_info;
-
-    {
-        HandleScope scope(args->GetIsolate());
-        Local<External> external = Local<External>::Cast(args->Data());
-
-        self = (VALUE)(external->Value());
-        callback = rb_iv_get(self, "@callback");
-
-        parent = rb_iv_get(self, "@parent");
-        if (NIL_P(parent) || !rb_obj_is_kind_of(parent, rb_cContext)) {
-            return NULL;
-        }
-
-        TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
-
-        if (length > 0) {
-            ruby_args = rb_ary_tmp_new(length);
-        }
-
-        for (int i = 0; i < length; i++) {
-            Local<Value> value = ((*args)[i]).As<Value>();
-            StackCounter::Reset(args->GetIsolate());
-            VALUE tmp = convert_v8_to_ruby(args->GetIsolate(),
-                                           *context_info->context, value);
-            rb_ary_push(ruby_args, tmp);
-        }
-    }
-
-    // may raise exception stay clear of handle scope
-    protected_callback_data callback_data;
-    callback_data.length = length;
-    callback_data.callback = callback;
-    callback_data.ruby_args = ruby_args;
-    callback_data.failed = false;
-
-    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
-        args->GetIsolate()->ThrowException(
-                    String::NewFromUtf8Literal(args->GetIsolate(),
-                                               "Terminated execution during transition from Ruby to JS"));
-        args->GetIsolate()->TerminateExecution();
-        if (length > 0) {
-            rb_ary_clear(ruby_args);
-        }
-        return NULL;
-    }
-
-    VALUE callback_data_value = (VALUE)&callback_data;
-
-    // TODO: use rb_vrescue2 in Ruby 2.7 and above
-    result = rb_rescue2(MR_METHOD_FUNC(protected_callback), callback_data_value,
-            MR_METHOD_FUNC(rescue_callback), callback_data_value, rb_eException, (VALUE)0);
-
-    if(callback_data.failed) {
-        rb_iv_set(parent, "@current_exception", result);
-        args->GetIsolate()->ThrowException(String::NewFromUtf8Literal(args->GetIsolate(), "Ruby exception"));
-    }
-    else {
-        HandleScope scope(args->GetIsolate());
-        Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), context_info->context->Get(args->GetIsolate()), result);
-        args->GetReturnValue().Set(v8_result);
-    }
-
-    if (length > 0) {
-        rb_ary_clear(ruby_args);
-    }
-
-    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
-      args->GetIsolate()->TerminateExecution();
-    }
-
-    return NULL;
-}
-
-static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-    bool has_gvl = IsolateData::Get(args.GetIsolate(), IsolateData::IN_GVL);
-
-    if(has_gvl) {
-        gvl_ruby_callback((void*)&args);
-    } else {
-        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, true);
-        rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
-        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, false);
-    }
-}
-
-
-static VALUE rb_external_function_notify_v8(VALUE self) {
-
-    ContextInfo* context_info;
-
-    VALUE parent = rb_iv_get(self, "@parent");
-    VALUE name = rb_iv_get(self, "@name");
-    VALUE parent_object = rb_iv_get(self, "@parent_object");
-    VALUE parent_object_eval = rb_iv_get(self, "@parent_object_eval");
-
-    bool parse_error = false;
-    bool attach_error = false;
-
-    TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-    {
-        Locker lock(isolate);
-        Isolate::Scope isolate_scope(isolate);
-        HandleScope handle_scope(isolate);
-
-        Local<Context> context = context_info->context->Get(isolate);
-        Context::Scope context_scope(context);
-
-        Local<String> v8_str =
-            String::NewFromUtf8(isolate, RSTRING_PTR(name),
-                                NewStringType::kNormal, RSTRING_LENINT(name))
-                .ToLocalChecked();
-
-        // Note that self (rb_cExternalFunction) is a pure Ruby T_OBJECT,
-        // not a T_DATA type like most other classes in this file
-        Local<Value> external = External::New(isolate, (void *)self);
-
-        if (parent_object == Qnil) {
-            Maybe<bool> success = context->Global()->Set(
-                        context,
-                        v8_str,
-                        FunctionTemplate::New(isolate, ruby_callback, external)
-                            ->GetFunction(context)
-                            .ToLocalChecked());
-	    (void)success;
-
-        } else {
-            Local<String> eval =
-                String::NewFromUtf8(isolate, RSTRING_PTR(parent_object_eval),
-                                    NewStringType::kNormal,
-                                    RSTRING_LENINT(parent_object_eval))
-                    .ToLocalChecked();
-
-            MaybeLocal<Script> parsed_script = Script::Compile(context, eval);
-            if (parsed_script.IsEmpty()) {
-            parse_error = true;
-            } else {
-                MaybeLocal<Value> maybe_value =
-                    parsed_script.ToLocalChecked()->Run(context);
-                attach_error = true;
-
-                if (!maybe_value.IsEmpty()) {
-                    Local<Value> value = maybe_value.ToLocalChecked();
-                    if (value->IsObject()) {
-                        Maybe<bool> success = value.As<Object>()->Set(
-                                    context,
-                                    v8_str,
-                                    FunctionTemplate::New(isolate, ruby_callback, external)
-                                        ->GetFunction(context)
-                                        .ToLocalChecked());
-			(void)success;
-                    attach_error = false;
-                    }
-                }
-            }
-        }
-    }
-
-    // always raise out of V8 context
-    if (parse_error) {
-        rb_raise(rb_eParseError, "Invalid object %" PRIsVALUE, parent_object);
-    }
-
-    if (attach_error) {
-        rb_raise(rb_eParseError, "Was expecting %" PRIsVALUE" to be an object", parent_object);
-    }
-
-    return Qnil;
-}
-
-static VALUE rb_context_isolate_mutex(VALUE self) {
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-
-    if (!context_info->isolate_info) {
-        rb_raise(rb_eScriptRuntimeError, "Context has no Isolate available anymore");
-    }
-
-    return context_info->isolate_info->mutex;
-}
-
-IsolateInfo::~IsolateInfo() {
-    if (isolate) {
-        if (this->interrupted) {
-            fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, "
-                            "it can not be disposed and memory will not be "
-                            "reclaimed till the Ruby process exits.\n");
-        } else {
-            if (this->pid != getpid() && !single_threaded) {
-                fprintf(stderr, "WARNING: V8 isolate was forked, "
-                                "it can not be disposed and "
-                                "memory will not be reclaimed "
-                                "till the Ruby process exits.\n"
-				"It is VERY likely your process will hang.\n"
-				"If you wish to use v8 in forked environment "
-				"please ensure the platform is initialized with:\n"
-				"MiniRacer::Platform.set_flags! :single_threaded\n"
-				);
-            } else {
-                isolate->Dispose();
-            }
-        }
-        isolate = nullptr;
-    }
-
-    if (startup_data) {
-        delete[] startup_data->data;
-        delete startup_data;
-    }
-
-    delete allocator;
-}
-
-static void free_context_raw(void *arg) {
-    ContextInfo* context_info = (ContextInfo*)arg;
-    IsolateInfo* isolate_info = context_info->isolate_info;
-    Persistent<Context>* context = context_info->context;
-
-    if (context && isolate_info && isolate_info->isolate) {
-        Locker lock(isolate_info->isolate);
-        v8::Isolate::Scope isolate_scope(isolate_info->isolate);
-        context->Reset();
-        delete context;
-    }
-
-    if (isolate_info) {
-        isolate_info->release();
-    }
-}
-
-static void *free_context_thr(void* arg) {
-    if (ruby_exiting.load() == 0) {
-        free_context_raw(arg);
-        xfree(arg);
-    }
-    return NULL;
-}
-
-// destroys everything except freeing the ContextInfo struct (see deallocate())
-static void free_context(ContextInfo* context_info) {
-    IsolateInfo* isolate_info = context_info->isolate_info;
-
-    if (isolate_info && isolate_info->refs() > 1) {
-        pthread_t free_context_thread;
-        ContextInfo* context_info_copy = ALLOC(ContextInfo);
-
-        context_info_copy->isolate_info = context_info->isolate_info;
-        context_info_copy->context = context_info->context;
-        if (pthread_create(&free_context_thread, thread_attr_p,
-                           free_context_thr, (void*)context_info_copy)) {
-            fprintf(stderr, "WARNING failed to release memory in MiniRacer, thread to release could not be created, process will leak memory\n");
-            xfree(context_info_copy);
-        }
-    } else {
-        free_context_raw(context_info);
-    }
-
-    context_info->context = NULL;
-    context_info->isolate_info = NULL;
-}
-
-static void deallocate_isolate(void* data) {
-
-    IsolateInfo* isolate_info = (IsolateInfo*) data;
-
-    isolate_info->release();
-}
-
-static void mark_isolate(void* data) {
-    IsolateInfo* isolate_info = (IsolateInfo*) data;
-    isolate_info->mark();
-}
-
-static size_t isolate_memsize(const void *ptr) {
-     const IsolateInfo *isolate_info = (const IsolateInfo *)ptr;
-     return sizeof(*isolate_info);
-}
-
-static void deallocate(void* data) {
-    ContextInfo* context_info = (ContextInfo*)data;
-
-    free_context(context_info);
-
-    xfree(data);
-}
-
-static size_t context_memsize(const void *ptr)
-{
-    return sizeof(ContextInfo);
-}
-
-static void mark_context(void* data) {
-    ContextInfo* context_info = (ContextInfo*)data;
-    if (context_info->isolate_info) {
-        context_info->isolate_info->mark();
-    }
-}
-
-static void deallocate_snapshot(void * data) {
-    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
-    delete[] snapshot_info->data;
-    xfree(snapshot_info);
-}
-
-static size_t snapshot_memsize(const void *data) {
-    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
-    return sizeof(*snapshot_info) + snapshot_info->raw_size;
-}
-
-static VALUE allocate(VALUE klass) {
-    ContextInfo* context_info;
-    return TypedData_Make_Struct(klass, ContextInfo, &context_type, context_info);
-}
-
-static VALUE allocate_snapshot(VALUE klass) {
-    SnapshotInfo* snapshot_info;
-
-    return TypedData_Make_Struct(klass, SnapshotInfo, &snapshot_type, snapshot_info);
-}
-
-static VALUE allocate_isolate(VALUE klass) {
-    IsolateInfo* isolate_info = new IsolateInfo();
-
-    return TypedData_Wrap_Struct(klass, &isolate_type, isolate_info);
-}
-
-static VALUE
-rb_heap_stats(VALUE self) {
-
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-    Isolate* isolate;
-    v8::HeapStatistics stats;
-
-    isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
-
-    VALUE rval = rb_hash_new();
-
-    if (!isolate) {
-
-        rb_hash_aset(rval, ID2SYM(rb_intern("total_physical_size")), ULONG2NUM(0));
-        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size_executable")), ULONG2NUM(0));
-        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size")), ULONG2NUM(0));
-        rb_hash_aset(rval, ID2SYM(rb_intern("used_heap_size")), ULONG2NUM(0));
-        rb_hash_aset(rval, ID2SYM(rb_intern("heap_size_limit")), ULONG2NUM(0));
-
-    } else {
-        isolate->GetHeapStatistics(&stats);
-
-        rb_hash_aset(rval, ID2SYM(rb_intern("total_physical_size")), ULONG2NUM(stats.total_physical_size()));
-        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size_executable")), ULONG2NUM(stats.total_heap_size_executable()));
-        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size")), ULONG2NUM(stats.total_heap_size()));
-        rb_hash_aset(rval, ID2SYM(rb_intern("used_heap_size")), ULONG2NUM(stats.used_heap_size()));
-        rb_hash_aset(rval, ID2SYM(rb_intern("heap_size_limit")), ULONG2NUM(stats.heap_size_limit()));
-    }
-
-    return rval;
-}
-
-// https://github.com/bnoordhuis/node-heapdump/blob/master/src/heapdump.cc
-class FileOutputStream : public OutputStream {
- public:
-  int err;
-
-  FileOutputStream(int fd) : fd(fd) { err = 0; }
-
-  virtual int GetChunkSize() {
-    return 65536;
-  }
-
-  virtual void EndOfStream() {}
-
-  virtual WriteResult WriteAsciiChunk(char* data, int size) {
-    size_t len = static_cast<size_t>(size);
-
-    while (len) {
-        ssize_t w = write(fd, data, len);
-
-        if (w > 0) {
-            data += w;
-            len -= w;
-        } else if (w < 0) {
-            err = errno;
-            return kAbort;
-        } else { /* w == 0, could be out-of-space */
-            err = -1;
-            return kAbort;
-        }
-    }
-    return kContinue;
-  }
-
- private:
-  int fd;
-};
-
-
-static VALUE
-rb_heap_snapshot(VALUE self, VALUE file) {
-
-    rb_io_t *fptr;
-
-    fptr = RFILE(file)->fptr;
-
-    if (!fptr) return Qfalse;
-
-    // prepare for unbuffered write(2) below:
-    rb_funcall(file, rb_intern("flush"), 0);
-
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-    Isolate* isolate;
-    isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
-
-    if (!isolate) return Qfalse;
-
-    Locker lock(isolate);
-    Isolate::Scope isolate_scope(isolate);
-    HandleScope handle_scope(isolate);
-
-    HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
-
-    const HeapSnapshot* const snap = heap_profiler->TakeHeapSnapshot();
-
-    FileOutputStream stream(fptr->fd);
-    snap->Serialize(&stream, HeapSnapshot::kJSON);
-
-    const_cast<HeapSnapshot*>(snap)->Delete();
-
-    /* TODO: perhaps rb_sys_fail here */
-    if (stream.err) return Qfalse;
-
-    return Qtrue;
-}
-
-static VALUE
-rb_context_stop(VALUE self) {
-
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-    // flag for termination
-    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
-
-    isolate->TerminateExecution();
-    rb_funcall(self, rb_intern("stop_attached"), 0);
-
-    return Qnil;
-}
-
-static VALUE
-rb_context_dispose(VALUE self) {
-
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-
-    free_context(context_info);
-
-    return Qnil;
-}
-
-static void*
-nogvl_context_call(void *args) {
-
-    FunctionCall *call = (FunctionCall *) args;
-    if (!call) {
-        return NULL;
-    }
-    IsolateInfo *isolate_info = call->context_info->isolate_info;
-    Isolate* isolate = isolate_info->isolate;
-
-    IsolateData::Set(isolate, IsolateData::IN_GVL, false);
-    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, false);
-
-    if (call->max_memory > 0) {
-        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_MAX, call->max_memory);
-        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, false);
-        if (!isolate_info->added_gc_cb) {
-            isolate->AddGCEpilogueCallback(gc_callback);
-            isolate_info->added_gc_cb = true;
-        }
-    }
- 
-    if (call->marshal_stackdepth > 0) {
-        StackCounter::SetMax(isolate, call->marshal_stackdepth);
-    }
-
-    Isolate::Scope isolate_scope(isolate);
-    EscapableHandleScope handle_scope(isolate);
-    TryCatch trycatch(isolate);
-
-    Local<Context> context = call->context_info->context->Get(isolate);
-    Context::Scope context_scope(context);
-
-    Local<Function> fun = call->fun;
-
-    EvalResult& eval_res = call->result;
-    eval_res.parsed = true;
-
-    MaybeLocal<v8::Value> res = fun->Call(context, context->Global(), call->argc, call->argv);
-    prepare_result(res, trycatch, isolate, context, eval_res);
-
-    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
-
-    return NULL;
-}
-
-static void unblock_function(void *args) {
-    FunctionCall *call = (FunctionCall *) args;
-    call->context_info->isolate_info->interrupted = true;
-}
-
-static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
-    ContextInfo* context_info;
-    FunctionCall call;
-    VALUE *call_argv = NULL;
-
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-    Isolate* isolate = context_info->isolate_info->isolate;
-
-    if (argc < 1) {
-        rb_raise(rb_eArgError, "need at least one argument %d", argc);
-    }
-
-    VALUE function_name = argv[0];
-    Check_Type(function_name, T_STRING);
-
-    char *fname = RSTRING_PTR(function_name);
-    if (!fname) {
-        return Qnil;
-    }
-
-    call.context_info = context_info;
-    call.error = false;
-    call.function_name = fname;
-    call.argc = argc - 1;
-    call.argv = NULL;
-    if (call.argc > 0) {
-        // skip first argument which is the function name
-        call_argv = argv + 1;
-    }
-
-    call.max_memory = 0;
-    VALUE mem_softlimit = rb_iv_get(self, "@max_memory");
-    if (mem_softlimit != Qnil) {
-        unsigned long sl_int = NUM2ULONG(mem_softlimit);
-        call.max_memory = (size_t)sl_int;
-    }
- 
-    call.marshal_stackdepth = 0;
-    VALUE marshal_stackdepth = rb_iv_get(self, "@marshal_stack_depth");
-    if (marshal_stackdepth != Qnil) {
-        unsigned long sl_int = NUM2ULONG(marshal_stackdepth);
-        call.marshal_stackdepth = (size_t)sl_int;
-    }
-
-    bool missingFunction = false;
-    {
-        Locker lock(isolate);
-        Isolate::Scope isolate_scope(isolate);
-        HandleScope handle_scope(isolate);
-
-        Local<Context> context = context_info->context->Get(isolate);
-        Context::Scope context_scope(context);
-
-        // examples of such usage can be found in
-        // https://github.com/v8/v8/blob/36b32aa28db5e993312f4588d60aad5c8330c8a5/test/cctest/test-api.cc#L15711
-        MaybeLocal<String> fname = String::NewFromUtf8(isolate, call.function_name);
-        MaybeLocal<v8::Value> val;
-        if (!fname.IsEmpty()) {
-            val = context->Global()->Get(context, fname.ToLocalChecked());
-        }
-
-        if (val.IsEmpty() || !val.ToLocalChecked()->IsFunction()) {
-            missingFunction = true;
-        } else {
-            Local<v8::Function> fun = Local<v8::Function>::Cast(val.ToLocalChecked());
-            VALUE tmp;
-            call.fun = fun;
-            call.argv = (v8::Local<Value> *)RB_ALLOCV_N(void *, tmp, call.argc);
-            for(int i=0; i < call.argc; i++) {
-                call.argv[i] = convert_ruby_to_v8(isolate, context, call_argv[i]);
-            }
-            rb_thread_call_without_gvl(nogvl_context_call, &call, unblock_function, &call);
-            RB_ALLOCV_END(tmp);
-        }
-    }
-
-    if (missingFunction) {
-    rb_raise(rb_eScriptRuntimeError, "Unknown JavaScript method invoked");
-    }
-
-    return convert_result_to_ruby(self, call.result);
-}
-
-static VALUE rb_context_create_isolate_value(VALUE self) {
-    ContextInfo* context_info;
-    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
-    IsolateInfo *isolate_info = context_info->isolate_info;
-
-    if (!isolate_info) {
-        return Qnil;
-    }
-
-    isolate_info->hold();
-    return TypedData_Wrap_Struct(rb_cIsolate, &isolate_type, isolate_info);
-}
-
-static void set_ruby_exiting(VALUE value) {
-    (void)value;
-
-    ruby_exiting.store(1);
-}
-
-extern "C" {
-
-    __attribute__((visibility("default"))) void Init_mini_racer_extension ( void )
-    {
-        VALUE rb_mMiniRacer = rb_define_module("MiniRacer");
-        rb_cContext = rb_define_class_under(rb_mMiniRacer, "Context", rb_cObject);
-        rb_cSnapshot = rb_define_class_under(rb_mMiniRacer, "Snapshot", rb_cObject);
-        rb_cIsolate = rb_define_class_under(rb_mMiniRacer, "Isolate", rb_cObject);
-        VALUE rb_cPlatform = rb_define_class_under(rb_mMiniRacer, "Platform", rb_cObject);
-
-        VALUE rb_eError = rb_define_class_under(rb_mMiniRacer, "Error", rb_eStandardError);
-
-        VALUE rb_eEvalError = rb_define_class_under(rb_mMiniRacer, "EvalError", rb_eError);
-        rb_eScriptTerminatedError = rb_define_class_under(rb_mMiniRacer, "ScriptTerminatedError", rb_eEvalError);
-        rb_eV8OutOfMemoryError = rb_define_class_under(rb_mMiniRacer, "V8OutOfMemoryError", rb_eEvalError);
-        rb_eParseError = rb_define_class_under(rb_mMiniRacer, "ParseError", rb_eEvalError);
-        rb_eScriptRuntimeError = rb_define_class_under(rb_mMiniRacer, "RuntimeError", rb_eEvalError);
-
-        rb_cJavaScriptFunction = rb_define_class_under(rb_mMiniRacer, "JavaScriptFunction", rb_cObject);
-        rb_eSnapshotError = rb_define_class_under(rb_mMiniRacer, "SnapshotError", rb_eError);
-        rb_ePlatformAlreadyInitializedError = rb_define_class_under(rb_mMiniRacer, "PlatformAlreadyInitialized", rb_eError);
-        rb_cFailedV8Conversion = rb_define_class_under(rb_mMiniRacer, "FailedV8Conversion", rb_cObject);
-        rb_mJSON = rb_define_module("JSON");
-
-        VALUE rb_cExternalFunction = rb_define_class_under(rb_cContext, "ExternalFunction", rb_cObject);
-
-        rb_define_method(rb_cContext, "stop", (VALUE(*)(...))&rb_context_stop, 0);
-        rb_define_method(rb_cContext, "dispose_unsafe", (VALUE(*)(...))&rb_context_dispose, 0);
-        rb_define_method(rb_cContext, "heap_stats", (VALUE(*)(...))&rb_heap_stats, 0);
-	rb_define_method(rb_cContext, "write_heap_snapshot_unsafe", (VALUE(*)(...))&rb_heap_snapshot, 1);
-
-        rb_define_private_method(rb_cContext, "create_isolate_value",(VALUE(*)(...))&rb_context_create_isolate_value, 0);
-        rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 2);
-        rb_define_private_method(rb_cContext, "call_unsafe", (VALUE(*)(...))&rb_context_call_unsafe, -1);
-        rb_define_private_method(rb_cContext, "isolate_mutex", (VALUE(*)(...))&rb_context_isolate_mutex, 0);
-        rb_define_private_method(rb_cContext, "init_unsafe",(VALUE(*)(...))&rb_context_init_unsafe, 2);
-
-        rb_define_alloc_func(rb_cContext, allocate);
-        rb_define_alloc_func(rb_cSnapshot, allocate_snapshot);
-        rb_define_alloc_func(rb_cIsolate, allocate_isolate);
-
-        rb_define_private_method(rb_cExternalFunction, "notify_v8", (VALUE(*)(...))&rb_external_function_notify_v8, 0);
-
-        rb_define_method(rb_cSnapshot, "size", (VALUE(*)(...))&rb_snapshot_size, 0);
-        rb_define_method(rb_cSnapshot, "dump", (VALUE(*)(...))&rb_snapshot_dump, 0);
-        rb_define_method(rb_cSnapshot, "warmup_unsafe!", (VALUE(*)(...))&rb_snapshot_warmup_unsafe, 1);
-        rb_define_private_method(rb_cSnapshot, "load", (VALUE(*)(...))&rb_snapshot_load, 1);
-
-        rb_define_method(rb_cIsolate, "idle_notification", (VALUE(*)(...))&rb_isolate_idle_notification, 1);
-        rb_define_method(rb_cIsolate, "low_memory_notification", (VALUE(*)(...))&rb_isolate_low_memory_notification, 0);
-        rb_define_method(rb_cIsolate, "pump_message_loop", (VALUE(*)(...))&rb_isolate_pump_message_loop, 0);
-        rb_define_private_method(rb_cIsolate, "init_with_snapshot",(VALUE(*)(...))&rb_isolate_init_with_snapshot, 1);
-
-        rb_define_singleton_method(rb_cPlatform, "set_flag_as_str!", (VALUE(*)(...))&rb_platform_set_flag_as_str, 1);
-
-        rb_set_end_proc(set_ruby_exiting, Qnil);
-
-        static pthread_attr_t attr;
-        if (pthread_attr_init(&attr) == 0) {
-            if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0) {
-                thread_attr_p = &attr;
-            }
-        }
-    }
-}