quickjs 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 558b76a18b29f977c09990bec267141fb9feae1f04ddd4265971c7c24e823b9b
-  data.tar.gz: b2dbe1a4a121e92e7f1792690fe755ce021091a4ff402a773b9853c885256dcc
+  metadata.gz: 8eba12c1c34fab81270517de72da6a8b3c9b561d521a42b80c14411c23555684
+  data.tar.gz: 4bced848c986a41c787306e799b40622d97dff999994b64e615cd3b1c79e586e
 SHA512:
-  metadata.gz: 338bc63e7590c7043cf86c7045f3e93c8269110d3daf49be87ef6477cd99086700a6c0a26dcdc8cf7eb2ce43acc025c419812eeb23ab0b155b59ddd335454db5
-  data.tar.gz: cb075876cdc10e081b95c40882acbe7ed272dacca56050564888a8df5a68c058c31fa61d9151bddf794d6846c1f00052ae74e3d439c493761bf47154f6fcfdc2
+  metadata.gz: 3598ef1f8b5bcbeedf916c101387477b8318e6550a1aa52b6fa4ddb269e261447768428eb4b644e2a0a9cc64ae084830c511cb077b7e25e292eb5d8e84a96460
+  data.tar.gz: 686a93a0a00d747c99d8a0a0f0072a2d0451cc6bfdeeeb512f02817288636d7192a2e2dda52d0e9bf05b92ebb1930f503ca7ce2251c8419ca568c66f825bca1f

data/README.md

@@ -96,12 +96,6 @@ vm = Quickjs::VM.new(
 )
 ```
 
-#### Dispose VM explicitly
-
-```rb
-vm.dispose!
-```
-
 #### Define a global function for JS
 
 ```rb

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,42 +1,66 @@
 #include "quickjsrb.h"
 
-typedef struct EvalTime {
+typedef struct EvalTime
+{
   clock_t limit;
   clock_t started_at;
 } EvalTime;
 
-typedef struct VMData {
-  char alive;
+typedef struct VMData
+{
   struct JSContext *context;
-  struct ProcEntryMap *procs;
+  VALUE defined_functions;
   struct EvalTime *eval_time;
 } VMData;
 
-void vm_free(void* data)
+static void vm_free(void *ptr)
+{
+  VMData *data = (VMData *)ptr;
+  free(data->eval_time);
+
+  JSRuntime *runtime = JS_GetRuntime(data->context);
+  JS_SetInterruptHandler(runtime, NULL, NULL);
+  js_std_free_handlers(runtime);
+  JS_FreeContext(data->context);
+  JS_FreeRuntime(runtime);
+
+  xfree(ptr);
+}
+
+size_t vm_size(const void *data)
 {
-  free(data);
+  return sizeof(VMData);
 }
 
-size_t vm_size(const void* data)
+static void vm_mark(void *ptr)
 {
-  return sizeof(data);
+  VMData *data = (VMData *)ptr;
+  rb_gc_mark_movable(data->defined_functions);
 }
 
 static const rb_data_type_t vm_type = {
-  .wrap_struct_name = "vm",
-  .function = {
-    .dmark = NULL,
-    .dfree = vm_free,
-    .dsize = vm_size,
-  },
-  .data = NULL,
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .wrap_struct_name = "quickjsvm",
+    .function = {
+        .dmark = vm_mark,
+        .dfree = vm_free,
+        .dsize = vm_size,
+    },
+    .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;
+
+  JSRuntime *runtime = JS_NewRuntime();
+  data->context = JS_NewContext(runtime);
+
+  return obj;
 }
 
 VALUE rb_mQuickjs;
@@ -46,91 +70,121 @@ const char *nanId = "NaN";
 const char *featureStdId = "feature_std";
 const char *featureOsId = "feature_os";
 
-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);
+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);
+    JS_FreeValue(ctx, j_str);
 
-      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 stringified;
+  }
+  case T_STRING:
+  {
+    char *str = StringValueCStr(r_value);
 
-      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);
+  }
+  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);
-    }
+    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, jsonClass);
+    JS_FreeValue(ctx, parseFunc);
+    JS_FreeValue(ctx, j_str);
+
+    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: {
+VALUE to_rb_value(JSValue jsv, JSContext *ctx)
+{
+  switch (JS_VALUE_GET_NORM_TAG(jsv))
+  {
+  case JS_TAG_INT:
+  {
     int int_res = 0;
     JS_ToInt32(ctx, &int_res, jsv);
     return INT2NUM(int_res);
   }
-  case JS_TAG_FLOAT64: {
-    if (JS_VALUE_IS_NAN(jsv)) {
+  case JS_TAG_FLOAT64:
+  {
+    if (JS_VALUE_IS_NAN(jsv))
+    {
       return ID2SYM(rb_intern(nanId));
     }
     double double_res;
     JS_ToFloat64(ctx, &double_res, jsv);
     return DBL2NUM(double_res);
   }
-  case JS_TAG_BOOL: {
+  case JS_TAG_BOOL:
+  {
     return JS_ToBool(ctx, jsv) > 0 ? Qtrue : Qfalse;
   }
-  case JS_TAG_STRING: {
+  case JS_TAG_STRING:
+  {
     JSValue maybeString = JS_ToString(ctx, jsv);
     const char *msg = JS_ToCString(ctx, maybeString);
+    JS_FreeValue(ctx, maybeString);
+    JS_FreeCString(ctx, msg);
     return rb_str_new2(msg);
   }
-  case JS_TAG_OBJECT: {
+  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); // should have timeout
-    } else if (promiseState == JS_PROMISE_REJECTED) {
-      return to_rb_value(JS_Throw(ctx, JS_PromiseResult(ctx, jsv)), ctx);
+    if (promiseState == JS_PROMISE_FULFILLED || promiseState == JS_PROMISE_PENDING)
+    {
+      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)
+    {
+      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);
@@ -140,6 +194,7 @@ VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
 
     const char *msg = JS_ToCString(ctx, strigified);
     VALUE rbString = rb_str_new2(msg);
+    JS_FreeCString(ctx, msg);
 
     JS_FreeValue(ctx, global);
     JS_FreeValue(ctx, strigified);
@@ -152,9 +207,11 @@ VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
     return Qnil;
   case JS_TAG_UNDEFINED:
     return ID2SYM(rb_intern(undefinedId));
-  case JS_TAG_EXCEPTION: {
+  case JS_TAG_EXCEPTION:
+  {
     JSValue exceptionVal = JS_GetException(ctx);
-    if (JS_IsError(ctx, exceptionVal)) {
+    if (JS_IsError(ctx, exceptionVal))
+    {
       JSValue jsErrorClassName = JS_GetPropertyStr(ctx, exceptionVal, "name");
       const char *errorClassName = JS_ToCString(ctx, jsErrorClassName);
 
@@ -164,24 +221,33 @@ VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
       JS_FreeValue(ctx, jsErrorClassMessage);
       JS_FreeValue(ctx, jsErrorClassName);
 
-      rb_raise(rb_eRuntimeError, "%s: %s", errorClassName, errorClassMessage);
-    } else {
+      VALUE rb_errorMessage = rb_sprintf("%s: %s", errorClassName, errorClassMessage);
+      JS_FreeCString(ctx, errorClassName);
+      JS_FreeCString(ctx, errorClassMessage);
+      JS_FreeValue(ctx, exceptionVal);
+      rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, rb_errorMessage));
+    }
+    else
+    {
       const char *errorMessage = JS_ToCString(ctx, exceptionVal);
 
-      rb_raise(rb_eRuntimeError, "%s", errorMessage);
+      VALUE rb_errorMessage = rb_sprintf("%s", errorMessage);
+      JS_FreeCString(ctx, errorMessage);
+      JS_FreeValue(ctx, exceptionVal);
+      rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, rb_errorMessage));
     }
-
-    JS_FreeValue(ctx, exceptionVal);
     return Qnil;
   }
-  case JS_TAG_BIG_INT: {
+  case JS_TAG_BIG_INT:
+  {
     JSValue toStringFunc = JS_GetPropertyStr(ctx, jsv, "toString");
     JSValue strigified = JS_Call(ctx, toStringFunc, jsv, 0, NULL);
 
     const char *msg = JS_ToCString(ctx, strigified);
     VALUE rbString = rb_str_new2(msg);
-    JS_FreeValue(ctx, strigified);
     JS_FreeValue(ctx, toStringFunc);
+    JS_FreeValue(ctx, strigified);
+    JS_FreeCString(ctx, msg);
 
     return rb_funcall(rbString, rb_intern("to_i"), 0, NULL);
   }
@@ -193,48 +259,51 @@ VALUE to_rb_value(JSValue jsv, JSContext *ctx) {
   }
 }
 
-static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int _argc, JSValueConst *argv) {
+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
+  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);
   }
+  JS_FreeCString(ctx, 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);
-  if (NIL_P(r_opts)) r_opts = rb_hash_new();
+  if (NIL_P(r_opts))
+    r_opts = rb_hash_new();
 
   VALUE r_memoryLimit = rb_hash_aref(r_opts, ID2SYM(rb_intern("memory_limit")));
-  if (NIL_P(r_memoryLimit)) r_memoryLimit = UINT2NUM(1024 * 1024 * 128);
+  if (NIL_P(r_memoryLimit))
+    r_memoryLimit = UINT2NUM(1024 * 1024 * 128);
   VALUE r_maxStackSize = rb_hash_aref(r_opts, ID2SYM(rb_intern("max_stack_size")));
-  if (NIL_P(r_maxStackSize)) r_maxStackSize = UINT2NUM(1024 * 1024 * 4);
+  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();
+  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);
+  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();
-
-  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);
+  JSRuntime *runtime = JS_GetRuntime(data->context);
 
   JS_SetMemoryLimit(runtime, NUM2UINT(r_memoryLimit));
   JS_SetMaxStackSize(runtime, NUM2UINT(r_maxStackSize));
@@ -248,18 +317,20 @@ VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
   JS_SetModuleLoaderFunc(runtime, NULL, js_module_loader, NULL);
   js_std_init_handlers(runtime);
 
-  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureStdId))))) {
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureStdId)))))
+  {
     js_init_module_std(data->context, "std");
     const char *enableStd = "import * as std from 'std';\n"
-        "globalThis.std = std;\n";
+                            "globalThis.std = std;\n";
     JSValue stdEval = JS_Eval(data->context, enableStd, strlen(enableStd), "<vm>", JS_EVAL_TYPE_MODULE);
     JS_FreeValue(data->context, stdEval);
   }
 
-  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureOsId))))) {
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, ID2SYM(rb_intern(featureOsId)))))
+  {
     js_init_module_os(data->context, "os");
     const char *enableOs = "import * as os from 'os';\n"
-        "globalThis.os = os;\n";
+                           "globalThis.os = os;\n";
     JSValue osEval = JS_Eval(data->context, enableOs, strlen(enableOs), "<vm>", JS_EVAL_TYPE_MODULE);
     JS_FreeValue(data->context, osEval);
   }
@@ -276,21 +347,17 @@ VALUE vm_m_initialize(int argc, VALUE* argv, VALUE self)
   return self;
 }
 
-static int interrupt_handler(JSRuntime *runtime, void *opaque) {
-	EvalTime *eval_time = opaque;
-	return clock() >= eval_time->started_at + eval_time->limit ? 1 : 0;
+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)
+static VALUE vm_m_evalCode(VALUE self, VALUE r_code)
 {
   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);
 
@@ -302,51 +369,36 @@ 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();
 
   VMData *data;
   TypedData_Get_Struct(self, VMData, &vm_type, data);
 
-  if (rb_block_given_p()) {
+  if (rb_block_given_p())
+  {
     VALUE proc = rb_block_proc();
 
     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";
+    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);
-    char* result = (char*)malloc(length + 1);
+    char *result = (char *)malloc(length + 1);
     snprintf(result, length + 1, template, funcName, funcName, funcName, funcName);
 
     JSValue codeResult = JS_Eval(data->context, result, strlen(result), "<vm>", JS_EVAL_TYPE_MODULE);
 
-    JS_FreeValue(data->context, codeResult);
     free(result);
+    JS_FreeValue(data->context, codeResult);
     return rb_funcall(r_name, rb_intern("to_sym"), 0, NULL);
   }
 
   return Qnil;
 }
 
-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;
-
-  return Qnil;
-}
-
 RUBY_FUNC_EXPORTED void
 Init_quickjsrb(void)
 {
@@ -363,5 +415,4 @@ Init_quickjsrb(void)
   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

@@ -12,6 +12,4 @@
 #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.8"
+  VERSION = "0.1.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-07-17 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);