quickjs 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fa772eb6185fa2bc744d7bb7b0cdb2024ccaf2d2ce34cb221139aaf2e819371
-  data.tar.gz: de4b5651b61eaaafe975ba56ae24b954c28efc9ea0ba2a6fb34f149b62d4aa58
+  metadata.gz: 558b76a18b29f977c09990bec267141fb9feae1f04ddd4265971c7c24e823b9b
+  data.tar.gz: b2dbe1a4a121e92e7f1792690fe755ce021091a4ff402a773b9853c885256dcc
 SHA512:
-  metadata.gz: 1095f8d04c0c90756506b8bd16a519b207b3b2a0eda64abecec8fb541a0a5a5c0e11240abce18b03e4ee4d7b4c3a53138513218f12afa4d7e46462f3a93680ef
-  data.tar.gz: 3237ad5b23217199900665605629c5b69c0333ea5951f3a43cf2e26ac65d6a718ff94f262fdaeb5bf0c3b132e60cb0561d60a121045a26bb201bbfd63e8e3a9c
+  metadata.gz: 338bc63e7590c7043cf86c7045f3e93c8269110d3daf49be87ef6477cd99086700a6c0a26dcdc8cf7eb2ce43acc025c419812eeb23ab0b155b59ddd335454db5
+  data.tar.gz: cb075876cdc10e081b95c40882acbe7ed272dacca56050564888a8df5a68c058c31fa61d9151bddf794d6846c1f00052ae74e3d439c493761bf47154f6fcfdc2

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,7 @@ $srcs = [
   'cutils.c',
   'quickjs.c',
   'quickjs-libc.c',
-  'quickjsrb-runtime-state.c',
+  'procs.c',
   'quickjsrb.c',
 ]
 

data/ext/quickjsrb/{quickjsrb-runtime-state.c → procs.c}

@@ -1,4 +1,4 @@
-#include "quickjsrb-runtime-state.h"
+#include "procs.h"
 
 unsigned int hash(const char *key) {
   unsigned long int value = 0;
@@ -8,7 +8,7 @@ unsigned int hash(const char *key) {
   for (; i < key_len; ++i) {
     value = value * 37 + key[i];
   }
-  return value % MAX_NUM_OF_PROC;
+  return value % MAX_NUM_OF_PROCS;
 }
 
 ProcEntry *create_proc_entry(const char *key, VALUE proc) {
@@ -21,8 +21,8 @@ ProcEntry *create_proc_entry(const char *key, VALUE proc) {
 
 ProcEntryMap *create_proc_entries() {
   ProcEntryMap *entryMap = malloc(sizeof(ProcEntryMap));
-  entryMap->entries = malloc(sizeof(ProcEntry *) * MAX_NUM_OF_PROC);
-  for (int i = 0; i < MAX_NUM_OF_PROC; ++i) {
+  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;
@@ -66,7 +66,7 @@ VALUE get_proc(ProcEntryMap *entryMap, const char *key) {
 }
 
 void free_proc_entry_map(ProcEntryMap *entryMap) {
-  for (int i = 0; i < MAX_NUM_OF_PROC; ++i) {
+  for (int i = 0; i < MAX_NUM_OF_PROCS; ++i) {
     ProcEntry *entry = entryMap->entries[i];
     while (entry != NULL) {
       ProcEntry *temp = entry;
@@ -78,15 +78,3 @@ void free_proc_entry_map(ProcEntryMap *entryMap) {
   free(entryMap->entries);
   free(entryMap);
 }
-
-QuickjsrbRuntimeState *create_quickjsrb_runtime_state() {
-  QuickjsrbRuntimeState *state = malloc(sizeof(QuickjsrbRuntimeState));
-  state->procs = create_proc_entries();
-
-  return state;
-}
-
-void free_quickjsrb_runtime_state(QuickjsrbRuntimeState *state) {
-  free_proc_entry_map(state->procs);
-  free(state);
-}

data/ext/quickjsrb/{quickjsrb-runtime-state.h → procs.h}

@@ -1,6 +1,6 @@
 #include "ruby.h"
 
-#define MAX_NUM_OF_PROC 100
+#define MAX_NUM_OF_PROCS 100
 
 typedef struct ProcEntry {
   char *key;
@@ -12,11 +12,7 @@ typedef struct ProcEntryMap {
   ProcEntry **entries;
 } ProcEntryMap;
 
-typedef struct QuickjsrbRuntimeState {
-  ProcEntryMap *procs;
-} QuickjsrbRuntimeState;
-
-QuickjsrbRuntimeState *create_quickjsrb_runtime_state();
-VALUE get_proc(ProcEntryMap *entryMap, const char *key);
+ProcEntryMap *create_proc_entries();
 void set_proc(ProcEntryMap *entryMap, const char *key, VALUE proc);
-void free_quickjsrb_runtime_state(QuickjsrbRuntimeState *state);
+VALUE get_proc(ProcEntryMap *entryMap, const char *key);
+void free_proc_entry_map(ProcEntryMap *entryMap);

data/ext/quickjsrb/quickjsrb.c

@@ -1,64 +1,42 @@
 #include "quickjsrb.h"
-#include "quickjsrb-runtime-state.h"
 
-struct qvmdata {
+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;
+  struct EvalTime *eval_time;
+} VMData;
 
-void qvm_free(void* data)
+void vm_free(void* data)
 {
   free(data);
 }
 
-size_t qvm_size(const void* data)
+size_t vm_size(const void* data)
 {
   return sizeof(data);
 }
 
-static const rb_data_type_t qvm_type = {
-  .wrap_struct_name = "qvm",
+static const rb_data_type_t vm_type = {
+  .wrap_struct_name = "vm",
   .function = {
     .dmark = NULL,
-    .dfree = qvm_free,
-    .dsize = qvm_size,
+    .dfree = vm_free,
+    .dsize = vm_size,
   },
   .data = NULL,
   .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE qvm_alloc(VALUE self)
+VALUE vm_alloc(VALUE self)
 {
-  struct qvmdata *data;
-
-  return TypedData_Make_Struct(self, struct qvmdata, &qvm_type, data);
-}
-
-static JSValue js_quickjsrb_call_global (JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-  struct qvmdata *data = JS_GetContextOpaque(ctx);
-  JSValue maybeFuncName = JS_ToString(ctx, argv[0]);
-  const char *funcName = JS_ToCString(ctx, maybeFuncName);
-
-  VALUE proc = get_proc(data->state->procs, funcName);
-  if (proc == Qnil) {
-    return JS_NewString(ctx, "missing");
-  }
-  JS_FreeValue(ctx, maybeFuncName);
-
-  // TODO: support multiple args
-  JSValue maybeString;
-  VALUE r_array = rb_ary_new2(argc);
-  for (int i = 1; i < argc; ++i) {
-    maybeString = JS_ToString(ctx, argv[i]);
-    const char *msg = JS_ToCString(ctx, maybeString);
-    rb_ary_push(r_array, rb_str_new2(msg));
-  }
-  JS_FreeValue(ctx, maybeString);
-
-  VALUE r_result = rb_funcall(proc, rb_intern("call"), argc - 1, r_array);
-  char *result = StringValueCStr(r_result);
-  return JS_NewString(ctx, result);
+  VMData *data;
+  return TypedData_Make_Struct(self, VMData, &vm_type, data);
 }
 
 VALUE rb_mQuickjs;
@@ -68,7 +46,63 @@ const char *nanId = "NaN";
 const char *featureStdId = "feature_std";
 const char *featureOsId = "feature_os";
 
-VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
+JSValue to_js_value(JSContext *ctx, VALUE r_value) {
+  switch (TYPE(r_value)) {
+    case T_NIL:
+      return JS_NULL;
+    case T_FIXNUM:
+    case T_FLOAT: {
+      VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0, NULL);
+      char *str = StringValueCStr(r_str);
+      JSValue global = JS_GetGlobalObject(ctx);
+      JSValue numberClass = JS_GetPropertyStr(ctx, global, "Number");
+      JSValue j_str = JS_NewString(ctx, str);
+      JSValue stringified = JS_Call(ctx, numberClass, JS_UNDEFINED, 1, &j_str);
+      JS_FreeValue(ctx, global);
+      JS_FreeValue(ctx, numberClass);
+
+      return stringified;
+    }
+    case T_STRING: {
+      char *str = StringValueCStr(r_value);
+
+      return JS_NewString(ctx, str);
+    }
+    case T_SYMBOL: {
+      VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0, NULL);
+      char *str = StringValueCStr(r_str);
+
+      return JS_NewString(ctx, str);
+    }
+    case T_TRUE:
+      return JS_TRUE;
+    case T_FALSE:
+      return JS_FALSE;
+    case T_HASH:
+    case T_ARRAY: {
+      VALUE r_json_str = rb_funcall(r_value, rb_intern("to_json"), 0, NULL);
+      char *str = StringValueCStr(r_json_str);
+      JSValue global = JS_GetGlobalObject(ctx);
+      JSValue jsonClass = JS_GetPropertyStr(ctx, global, "JSON");
+      JSValue parseFunc = JS_GetPropertyStr(ctx, jsonClass, "parse");
+      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);
+
+      return stringified;
+    }
+    default: {
+      VALUE r_inspect_str = rb_funcall(r_value, rb_intern("inspect"), 0, NULL);
+      char *str = StringValueCStr(r_inspect_str);
+
+      return JS_NewString(ctx, str);
+    }
+  }
+}
+
+VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
   switch(JS_VALUE_GET_NORM_TAG(jsv)) {
   case JS_TAG_INT: {
     int int_res = 0;
@@ -94,7 +128,7 @@ VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
   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);
+      return to_rb_value(js_std_await(ctx, jsv), ctx); // should have timeout
     } else if (promiseState == JS_PROMISE_REJECTED) {
       return to_rb_value(JS_Throw(ctx, JS_PromiseResult(ctx, jsv)), ctx);
     }
@@ -159,7 +193,22 @@ VALUE to_rb_value (JSValue jsv, JSContext *ctx) {
   }
 }
 
-VALUE qvm_m_initialize(int argc, VALUE* argv, VALUE self)
+static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int _argc, JSValueConst *argv) {
+  VMData *data = JS_GetContextOpaque(ctx);
+  JSValue maybeFuncName = JS_ToString(ctx, argv[0]);
+  const char *funcName = JS_ToCString(ctx, maybeFuncName);
+  JS_FreeValue(ctx, maybeFuncName);
+
+  VALUE proc = get_proc(data->procs, funcName);
+  if (proc == Qnil) { // Shouldn't happen
+    return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName);
+  }
+
+  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)
 {
   VALUE r_opts;
   rb_scan_args(argc, argv, ":", &r_opts);
@@ -171,14 +220,19 @@ VALUE qvm_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);
 
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
 
-  QuickjsrbRuntimeState *state= create_quickjsrb_runtime_state();
   JSRuntime *runtime = JS_NewRuntime();
   data->context = JS_NewContext(runtime);
-  data->state = state;
+  data->procs = create_proc_entries();
+
+  EvalTime *eval_time = malloc(sizeof(EvalTime));
+  data->eval_time = eval_time;
+  data->eval_time->limit = (clock_t)(CLOCKS_PER_SEC * NUM2UINT(r_timeout_msec) / 1000);
   data->alive = 1;
   JS_SetContextOpaque(data->context, data);
 
@@ -222,15 +276,24 @@ VALUE qvm_m_initialize(int argc, VALUE* argv, VALUE self)
   return self;
 }
 
-VALUE qvm_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;
+}
+
+VALUE vm_m_evalCode(VALUE self, VALUE r_code)
 {
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
 
   if (data->alive < 1) {
     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);
@@ -239,19 +302,19 @@ VALUE qvm_m_evalCode(VALUE self, VALUE r_code)
   return result;
 }
 
-VALUE qvm_m_defineGlobalFunction(VALUE self, VALUE r_name)
+VALUE vm_m_defineGlobalFunction(VALUE self, VALUE r_name)
 {
   rb_need_block();
 
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  VMData *data;
+  TypedData_Get_Struct(self, VMData, &vm_type, data);
 
   if (rb_block_given_p()) {
     VALUE proc = rb_block_proc();
 
     char *funcName = StringValueCStr(r_name);
 
-    set_proc(data->state->procs, funcName, proc);
+    set_proc(data->procs, funcName, 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);
@@ -268,14 +331,15 @@ VALUE qvm_m_defineGlobalFunction(VALUE self, VALUE r_name)
   return Qnil;
 }
 
-VALUE qvm_m_dispose(VALUE self)
+VALUE vm_m_dispose(VALUE self)
 {
-  struct qvmdata *data;
-  TypedData_Get_Struct(self, struct qvmdata, &qvm_type, data);
+  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_quickjsrb_runtime_state(data->state);
+  free_proc_entry_map(data->procs);
   JS_FreeContext(data->context);
   JS_FreeRuntime(runtime);
   data->alive = 0;
@@ -295,9 +359,9 @@ Init_quickjsrb(void)
   rb_define_const(valueClass, "NAN", ID2SYM(rb_intern(nanId)));
 
   VALUE vmClass = rb_define_class_under(rb_mQuickjs, "VM", rb_cObject);
-  rb_define_alloc_func(vmClass, qvm_alloc);
-  rb_define_method(vmClass, "initialize", qvm_m_initialize, -1);
-  rb_define_method(vmClass, "eval_code", qvm_m_evalCode, 1);
-  rb_define_method(vmClass, "define_function", qvm_m_defineGlobalFunction, 1);
-  rb_define_method(vmClass, "dispose!", qvm_m_dispose, 0);
+  rb_define_alloc_func(vmClass, vm_alloc);
+  rb_define_method(vmClass, "initialize", vm_m_initialize, -1);
+  rb_define_method(vmClass, "eval_code", vm_m_evalCode, 1);
+  rb_define_method(vmClass, "define_function", vm_m_defineGlobalFunction, 1);
+  rb_define_method(vmClass, "dispose!", vm_m_dispose, 0);
 }

data/ext/quickjsrb/quickjsrb.h

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

data/lib/quickjs/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-08 00:00:00.000000000 Z
+date: 2024-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -37,6 +37,8 @@ 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
@@ -62,8 +64,6 @@ files:
 - ext/quickjsrb/quickjs/run-test262.c
 - ext/quickjsrb/quickjs/unicode_gen.c
 - ext/quickjsrb/quickjs/unicode_gen_def.h
-- ext/quickjsrb/quickjsrb-runtime-state.c
-- ext/quickjsrb/quickjsrb-runtime-state.h
 - ext/quickjsrb/quickjsrb.c
 - ext/quickjsrb/quickjsrb.h
 - lib/quickjs.rb