quickjs 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a639b7afafb5c155725cba8d7927b7f4e146e21369a65a3902e8fe23ef1e3dd
-  data.tar.gz: b0e098ae6c193e761f456642cdcaf5396251785d5bc56b5e807fd540a0615f87
+  metadata.gz: f0461f98dbe3171e88609b060aa9fb414ba881b0977d983d6ec7897726a0559c
+  data.tar.gz: 84ed4cf19c1d5191e9cd57b789cc3138691f7ad2059b515a2ce4280051105c46
 SHA512:
-  metadata.gz: 9ad93ee1c056d68409daeba63515b8afa8555150044e0543a97bb2f3cb64abf5b8f5a5b1fce75e952721b0277a7807ce521289b70b63157cc489032da7da8f7c
-  data.tar.gz: b36a5f2e7402156e94403c5110ec1acc6141d657b236562b18b57c63c68fd966d4ef25096e3b515f9633093bee2e2a89f65578b4426e0c4184197078c9c2c578
+  metadata.gz: c98d7daf116e5513a19b99e4ef387f3b1b60389c3bb9f91822cc1d437bf87cc72041cd97c7cdf2a8a8cb55a86df93a3cf7fe472733017ae4a315831397a56cd5
+  data.tar.gz: f177d0e31b8d6499fcf922bd85dc594aa2acd0bf8d93d696256c4a3a7a1595eeb874df7e14e8447694a3045b3f2b9d8279633550e535fc8f257311c613c043b6

data/README.md

@@ -89,6 +89,11 @@ vm = Quickjs::VM.new(
 vm = Quickjs::VM.new(
   features: [::Quickjs::MODULE_OS],
 )
+
+# `eval_code` will be interrupted after 1 sec (default: 100 msec)
+vm = Quickjs::VM.new(
+  timeout_msec: 1_000,
+)
 ```
 
 #### Dispose VM explicitly

data/ext/quickjsrb/extconf.rb

@@ -11,7 +11,6 @@ $srcs = [
   'cutils.c',
   'quickjs.c',
   'quickjs-libc.c',
-  'procs.c',
   'quickjsrb.c',
 ]
 

data/ext/quickjsrb/quickjsrb.c

@@ -1,15 +1,22 @@
 #include "quickjsrb.h"
 
+typedef struct EvalTime {
+  clock_t limit;
+  clock_t started_at;
+} EvalTime;
+
 typedef struct VMData {
   char alive;
   struct JSContext *context;
-  struct QuickjsrbRuntimeState *state;
-  struct ProcEntryMap *procs;
+  VALUE defined_functions;
+  struct EvalTime *eval_time;
 } VMData;
 
-void vm_free(void* data)
+static void vm_free(void* ptr)
 {
-  free(data);
+  VMData *data = (VMData *)ptr;
+  free(data->eval_time);
+  xfree(ptr);
 }
 
 size_t vm_size(const void* data)
@@ -17,10 +24,16 @@ size_t vm_size(const void* data)
   return sizeof(data);
 }
 
+static void vm_mark(void *ptr)
+{
+  VMData *data = (VMData *)ptr;
+  rb_gc_mark_movable(data->defined_functions);
+}
+
 static const rb_data_type_t vm_type = {
-  .wrap_struct_name = "vm",
+  .wrap_struct_name = "quickjsvm",
   .function = {
-    .dmark = NULL,
+    .dmark = vm_mark,
     .dfree = vm_free,
     .dsize = vm_size,
   },
@@ -28,10 +41,16 @@ static const rb_data_type_t vm_type = {
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE vm_alloc(VALUE self)
+static VALUE vm_alloc(VALUE self)
 {
   VMData *data;
-  return TypedData_Make_Struct(self, VMData, &vm_type, data);
+  VALUE obj = TypedData_Make_Struct(self, VMData, &vm_type, data);
+  data->defined_functions = rb_hash_new();
+
+  EvalTime *eval_time = malloc(sizeof(EvalTime));
+  data->eval_time = eval_time;
+
+  return obj;
 }
 
 VALUE rb_mQuickjs;
@@ -55,6 +74,7 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value) {
       JSValue stringified = JS_Call(ctx, numberClass, JS_UNDEFINED, 1, &j_str);
       JS_FreeValue(ctx, global);
       JS_FreeValue(ctx, numberClass);
+      JS_FreeValue(ctx, j_str);
 
       return stringified;
     }
@@ -83,8 +103,9 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value) {
       JSValue j_str = JS_NewString(ctx, str);
       JSValue stringified = JS_Call(ctx, parseFunc, jsonClass, 1, &j_str);
       JS_FreeValue(ctx, global);
-      JS_FreeValue(ctx, parseFunc);
       JS_FreeValue(ctx, jsonClass);
+      JS_FreeValue(ctx, parseFunc);
+      JS_FreeValue(ctx, j_str);
 
       return stringified;
     }
@@ -118,14 +139,23 @@ VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
   case JS_TAG_STRING: {
     JSValue maybeString = JS_ToString(ctx, jsv);
     const char *msg = JS_ToCString(ctx, maybeString);
+    JS_FreeValue(ctx, maybeString);
     return rb_str_new2(msg);
   }
   case JS_TAG_OBJECT: {
     int promiseState = JS_PromiseState(ctx, jsv);
     if (promiseState == JS_PROMISE_FULFILLED || promiseState == JS_PROMISE_PENDING) {
-      return to_rb_value(js_std_await(ctx, jsv), ctx);
+      JSValue awaited = js_std_await(ctx, jsv);
+      VALUE rb_awaited = to_rb_value(awaited, ctx); // TODO: should have timeout
+      JS_FreeValue(ctx, awaited);
+      return rb_awaited;
     } else if (promiseState == JS_PROMISE_REJECTED) {
-      return to_rb_value(JS_Throw(ctx, JS_PromiseResult(ctx, jsv)), ctx);
+      JSValue promiseResult = JS_PromiseResult(ctx, jsv);
+      JSValue throw = JS_Throw(ctx, promiseResult);
+      JS_FreeValue(ctx, promiseResult);
+      VALUE rb_errored = to_rb_value(throw, ctx);
+      JS_FreeValue(ctx, throw);
+      return rb_errored;
     }
 
     JSValue global = JS_GetGlobalObject(ctx);
@@ -194,16 +224,17 @@ static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int
   const char *funcName = JS_ToCString(ctx, maybeFuncName);
   JS_FreeValue(ctx, maybeFuncName);
 
-  VALUE proc = get_proc(data->procs, funcName);
+  VALUE proc = rb_hash_aref(data->defined_functions, rb_str_new2(funcName));
   if (proc == Qnil) { // Shouldn't happen
     return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName);
   }
 
+  // TODO: cover timeout for calling proc
   VALUE r_result = rb_apply(proc, rb_intern("call"), to_rb_value(argv[1], ctx));
   return to_js_value(ctx, r_result);
 }
 
-VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
+static VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
 {
   VALUE r_opts;
   rb_scan_args(argc, argv, ":", &r_opts);
@@ -215,13 +246,15 @@ VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
   if (NIL_P(r_maxStackSize)) r_maxStackSize = UINT2NUM(1024 * 1024 * 4);
   VALUE r_features = rb_hash_aref(r_opts, ID2SYM(rb_intern("features")));
   if (NIL_P(r_features)) r_features = rb_ary_new();
+  VALUE r_timeout_msec = rb_hash_aref(r_opts, ID2SYM(rb_intern("timeout_msec")));
+  if (NIL_P(r_timeout_msec)) r_timeout_msec= UINT2NUM(100);
 
   VMData *data;
   TypedData_Get_Struct(self, VMData, &vm_type, data);
 
   JSRuntime *runtime = JS_NewRuntime();
   data->context = JS_NewContext(runtime);
-  data->procs = create_proc_entries();
+  data->eval_time->limit = (clock_t)(CLOCKS_PER_SEC * NUM2UINT(r_timeout_msec) / 1000);
   data->alive = 1;
   JS_SetContextOpaque(data->context, data);
 
@@ -265,7 +298,12 @@ VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
   return self;
 }
 
-VALUE vm_m_evalCode(VALUE self, VALUE r_code)
+static int interrupt_handler(JSRuntime *runtime, void *opaque) {
+	EvalTime *eval_time = opaque;
+	return clock() >= eval_time->started_at + eval_time->limit ? 1 : 0;
+}
+
+static VALUE vm_m_evalCode(VALUE self, VALUE r_code)
 {
   VMData *data;
   TypedData_Get_Struct(self, VMData, &vm_type, data);
@@ -274,6 +312,10 @@ VALUE vm_m_evalCode(VALUE self, VALUE r_code)
     rb_raise(rb_eRuntimeError, "Quickjs::VM was disposed");
     return Qnil;
   }
+
+  data->eval_time->started_at = clock();
+  JS_SetInterruptHandler(JS_GetRuntime(data->context), interrupt_handler, data->eval_time);
+
   char *code = StringValueCStr(r_code);
   JSValue codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL);
   VALUE result = to_rb_value(codeResult, data->context);
@@ -282,7 +324,7 @@ VALUE vm_m_evalCode(VALUE self, VALUE r_code)
   return result;
 }
 
-VALUE vm_m_defineGlobalFunction(VALUE self, VALUE r_name)
+static VALUE vm_m_defineGlobalFunction(VALUE self, VALUE r_name)
 {
   rb_need_block();
 
@@ -294,7 +336,7 @@ VALUE vm_m_defineGlobalFunction(VALUE self, VALUE r_name)
 
     char *funcName = StringValueCStr(r_name);
 
-    set_proc(data->procs, funcName, proc);
+    rb_hash_aset(data->defined_functions, r_name, proc);
 
     const char* template = "globalThis.__ruby['%s'] = (...args) => rubyGlobal('%s', args);\nglobalThis['%s'] = globalThis.__ruby['%s'];\n";
     int length = snprintf(NULL, 0, template, funcName, funcName, funcName, funcName);
@@ -311,14 +353,14 @@ VALUE vm_m_defineGlobalFunction(VALUE self, VALUE r_name)
   return Qnil;
 }
 
-VALUE vm_m_dispose(VALUE self)
+static VALUE vm_m_dispose(VALUE self)
 {
   VMData *data;
   TypedData_Get_Struct(self, VMData, &vm_type, data);
 
   JSRuntime *runtime = JS_GetRuntime(data->context);
+  JS_SetInterruptHandler(runtime, NULL, NULL);
   js_std_free_handlers(runtime);
-  free_proc_entry_map(data->procs);
   JS_FreeContext(data->context);
   JS_FreeRuntime(runtime);
   data->alive = 0;

data/ext/quickjsrb/quickjsrb.h

@@ -10,7 +10,6 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
-
-#include "procs.h"
+#include <time.h>
 
 #endif /* QUICKJSRB_H */

data/lib/quickjs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quickjs
-  VERSION = "0.1.7"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-09 00:00:00.000000000 Z
+date: 2024-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -37,8 +37,6 @@ files:
 - README.md
 - Rakefile
 - ext/quickjsrb/extconf.rb
-- ext/quickjsrb/procs.c
-- ext/quickjsrb/procs.h
 - ext/quickjsrb/quickjs/LICENSE
 - ext/quickjsrb/quickjs/cutils.c
 - ext/quickjsrb/quickjs/cutils.h

data/ext/quickjsrb/procs.c

@@ -1,80 +0,0 @@
-#include "procs.h"
-
-unsigned int hash(const char *key) {
-  unsigned long int value = 0;
-  unsigned int i = 0;
-  unsigned int key_len = strlen(key);
-
-  for (; i < key_len; ++i) {
-    value = value * 37 + key[i];
-  }
-  return value % MAX_NUM_OF_PROCS;
-}
-
-ProcEntry *create_proc_entry(const char *key, VALUE proc) {
-  ProcEntry *entry = malloc(sizeof(ProcEntry));
-  entry->key = strdup(key);
-  entry->proc = proc;
-  entry->next = NULL;
-  return entry;
-}
-
-ProcEntryMap *create_proc_entries() {
-  ProcEntryMap *entryMap = malloc(sizeof(ProcEntryMap));
-  entryMap->entries = malloc(sizeof(ProcEntry *) * MAX_NUM_OF_PROCS);
-  for (int i = 0; i < MAX_NUM_OF_PROCS; ++i) {
-    entryMap->entries[i] = NULL;
-  }
-  return entryMap;
-}
-
-void set_proc(ProcEntryMap *entryMap, const char *key, VALUE proc) {
-  unsigned int slot = hash(key);
-  ProcEntry *entry = entryMap->entries[slot];
-
-  if (entry == NULL) {
-    entryMap->entries[slot] = create_proc_entry(key, proc);
-    return;
-  }
-
-  ProcEntry *prev;
-  while (entry != NULL) {
-    if (strcmp(entry->key, key) == 0) {
-      entry->proc = proc;
-      return;
-    }
-    prev = entry;
-    entry = prev->next;
-  }
-
-  prev->next = create_proc_entry(key, proc);
-}
-
-VALUE get_proc(ProcEntryMap *entryMap, const char *key) {
-  unsigned int slot = hash(key);
-
-  ProcEntry *entry = entryMap->entries[slot];
-
-  while (entry != NULL) {
-    if (strcmp(entry->key, key) == 0) {
-      return entry->proc;
-    }
-    entry = entry->next;
-  }
-
-  return Qnil;
-}
-
-void free_proc_entry_map(ProcEntryMap *entryMap) {
-  for (int i = 0; i < MAX_NUM_OF_PROCS; ++i) {
-    ProcEntry *entry = entryMap->entries[i];
-    while (entry != NULL) {
-      ProcEntry *temp = entry;
-      entry = entry->next;
-      free(temp->key);
-      free(temp);
-    }
-  }
-  free(entryMap->entries);
-  free(entryMap);
-}

data/ext/quickjsrb/procs.h

@@ -1,18 +0,0 @@
-#include "ruby.h"
-
-#define MAX_NUM_OF_PROCS 100
-
-typedef struct ProcEntry {
-  char *key;
-  VALUE proc;
-  struct ProcEntry *next;
-} ProcEntry;
-
-typedef struct ProcEntryMap {
-  ProcEntry **entries;
-} ProcEntryMap;
-
-ProcEntryMap *create_proc_entries();
-void set_proc(ProcEntryMap *entryMap, const char *key, VALUE proc);
-VALUE get_proc(ProcEntryMap *entryMap, const char *key);
-void free_proc_entry_map(ProcEntryMap *entryMap);