quickjs 0.8.1 → 0.10.0

data/ext/quickjsrb/quickjs/quickjs.h

@@ -27,6 +27,7 @@
 
 #include <stdio.h>
 #include <stdint.h>
+#include <string.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,7 +49,6 @@ extern "C" {
 
 typedef struct JSRuntime JSRuntime;
 typedef struct JSContext JSContext;
-typedef struct JSObject JSObject;
 typedef struct JSClass JSClass;
 typedef uint32_t JSClassID;
 typedef uint32_t JSAtom;
@@ -64,14 +64,21 @@ typedef uint32_t JSAtom;
 #define JS_NAN_BOXING
 #endif
 
+#if defined(__SIZEOF_INT128__) && (INTPTR_MAX >= INT64_MAX)
+#define JS_LIMB_BITS 64
+#else
+#define JS_LIMB_BITS 32
+#endif
+
+#define JS_SHORT_BIG_INT_BITS JS_LIMB_BITS
+    
 enum {
     /* all tags with a reference count are negative */
-    JS_TAG_FIRST       = -11, /* first negative tag */
-    JS_TAG_BIG_DECIMAL = -11,
-    JS_TAG_BIG_INT     = -10,
-    JS_TAG_BIG_FLOAT   = -9,
+    JS_TAG_FIRST       = -9, /* first negative tag */
+    JS_TAG_BIG_INT     = -9,
     JS_TAG_SYMBOL      = -8,
     JS_TAG_STRING      = -7,
+    JS_TAG_STRING_ROPE = -6,
     JS_TAG_MODULE      = -3, /* used internally */
     JS_TAG_FUNCTION_BYTECODE = -2, /* used internally */
     JS_TAG_OBJECT      = -1,
@@ -83,7 +90,8 @@ enum {
     JS_TAG_UNINITIALIZED = 4,
     JS_TAG_CATCH_OFFSET = 5,
     JS_TAG_EXCEPTION   = 6,
-    JS_TAG_FLOAT64     = 7,
+    JS_TAG_SHORT_BIG_INT = 7,
+    JS_TAG_FLOAT64     = 8,
     /* any larger tag is FLOAT64 if JS_NAN_BOXING */
 };
 
@@ -108,6 +116,7 @@ typedef const struct __JSValue *JSValueConst;
 #define JS_VALUE_GET_INT(v) (int)((intptr_t)(v) >> 4)
 #define JS_VALUE_GET_BOOL(v) JS_VALUE_GET_INT(v)
 #define JS_VALUE_GET_FLOAT64(v) (double)JS_VALUE_GET_INT(v)
+#define JS_VALUE_GET_SHORT_BIG_INT(v) JS_VALUE_GET_INT(v)
 #define JS_VALUE_GET_PTR(v) (void *)((intptr_t)(v) & ~0xf)
 
 #define JS_MKVAL(tag, val) (JSValue)(intptr_t)(((val) << 4) | (tag))
@@ -127,6 +136,11 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
     return 0;
 }
 
+static inline JSValue __JS_NewShortBigInt(JSContext *ctx, int32_t d)
+{
+    return JS_MKVAL(JS_TAG_SHORT_BIG_INT, d);
+}
+
 #elif defined(JS_NAN_BOXING)
 
 typedef uint64_t JSValue;
@@ -136,6 +150,7 @@ typedef uint64_t JSValue;
 #define JS_VALUE_GET_TAG(v) (int)((v) >> 32)
 #define JS_VALUE_GET_INT(v) (int)(v)
 #define JS_VALUE_GET_BOOL(v) (int)(v)
+#define JS_VALUE_GET_SHORT_BIG_INT(v) (int)(v)
 #define JS_VALUE_GET_PTR(v) (void *)(intptr_t)(v)
 
 #define JS_MKVAL(tag, val) (((uint64_t)(tag) << 32) | (uint32_t)(val))
@@ -192,12 +207,22 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
     return tag == (JS_NAN >> 32);
 }
 
+static inline JSValue __JS_NewShortBigInt(JSContext *ctx, int32_t d)
+{
+    return JS_MKVAL(JS_TAG_SHORT_BIG_INT, d);
+}
+
 #else /* !JS_NAN_BOXING */
 
 typedef union JSValueUnion {
     int32_t int32;
     double float64;
     void *ptr;
+#if JS_SHORT_BIG_INT_BITS == 32
+    int32_t short_big_int;
+#else
+    int64_t short_big_int;
+#endif
 } JSValueUnion;
 
 typedef struct JSValue {
@@ -213,6 +238,7 @@ typedef struct JSValue {
 #define JS_VALUE_GET_INT(v) ((v).u.int32)
 #define JS_VALUE_GET_BOOL(v) ((v).u.int32)
 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
+#define JS_VALUE_GET_SHORT_BIG_INT(v) ((v).u.short_big_int)
 #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
 
 #define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
@@ -242,13 +268,19 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
     return (u.u64 & 0x7fffffffffffffff) > 0x7ff0000000000000;
 }
 
+static inline JSValue __JS_NewShortBigInt(JSContext *ctx, int64_t d)
+{
+    JSValue v;
+    v.tag = JS_TAG_SHORT_BIG_INT;
+    v.u.short_big_int = d;
+    return v;
+}
+
 #endif /* !JS_NAN_BOXING */
 
 #define JS_VALUE_IS_BOTH_INT(v1, v2) ((JS_VALUE_GET_TAG(v1) | JS_VALUE_GET_TAG(v2)) == 0)
 #define JS_VALUE_IS_BOTH_FLOAT(v1, v2) (JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v1)) && JS_TAG_IS_FLOAT64(JS_VALUE_GET_TAG(v2)))
 
-#define JS_VALUE_GET_OBJ(v) ((JSObject *)JS_VALUE_GET_PTR(v))
-#define JS_VALUE_GET_STRING(v) ((JSString *)JS_VALUE_GET_PTR(v))
 #define JS_VALUE_HAS_REF_COUNT(v) ((unsigned)JS_VALUE_GET_TAG(v) >= (unsigned)JS_TAG_FIRST)
 
 /* special values */
@@ -290,7 +322,9 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 #define JS_PROP_NO_ADD           (1 << 16) /* internal use */
 #define JS_PROP_NO_EXOTIC        (1 << 17) /* internal use */
 
-#define JS_DEFAULT_STACK_SIZE (256 * 1024)
+#ifndef JS_DEFAULT_STACK_SIZE
+#define JS_DEFAULT_STACK_SIZE (1024 * 1024)
+#endif
 
 /* JS_Eval() flags */
 #define JS_EVAL_TYPE_GLOBAL   (0 << 0) /* global code (default) */
@@ -300,7 +334,6 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 #define JS_EVAL_TYPE_MASK     (3 << 0)
 
 #define JS_EVAL_FLAG_STRICT   (1 << 3) /* force 'strict' mode */
-#define JS_EVAL_FLAG_STRIP    (1 << 4) /* force 'strip' mode */
 /* compile but do not run. The result is an object with a
    JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
    with JS_EvalFunction(). */
@@ -373,13 +406,7 @@ void JS_AddIntrinsicProxy(JSContext *ctx);
 void JS_AddIntrinsicMapSet(JSContext *ctx);
 void JS_AddIntrinsicTypedArrays(JSContext *ctx);
 void JS_AddIntrinsicPromise(JSContext *ctx);
-void JS_AddIntrinsicBigInt(JSContext *ctx);
-void JS_AddIntrinsicBigFloat(JSContext *ctx);
-void JS_AddIntrinsicBigDecimal(JSContext *ctx);
-/* enable operator overloading */
-void JS_AddIntrinsicOperators(JSContext *ctx);
-/* enable "use math" */
-void JS_EnableBignumExt(JSContext *ctx, JS_BOOL enable);
+void JS_AddIntrinsicWeakRef(JSContext *ctx);
 
 JSValue js_string_codePointRange(JSContext *ctx, JSValueConst this_val,
                                  int argc, JSValueConst *argv);
@@ -474,6 +501,17 @@ typedef struct JSClassExoticMethods {
     /* return < 0 if exception or TRUE/FALSE */
     int (*set_property)(JSContext *ctx, JSValueConst obj, JSAtom atom,
                         JSValueConst value, JSValueConst receiver, int flags);
+
+    /* To get a consistent object behavior when get_prototype != NULL,
+       get_property, set_property and set_prototype must be != NULL
+       and the object must be created with a JS_NULL prototype. */
+    JSValue (*get_prototype)(JSContext *ctx, JSValueConst obj);
+    /* return < 0 if exception or TRUE/FALSE */
+    int (*set_prototype)(JSContext *ctx, JSValueConst obj, JSValueConst proto_val);
+    /* return < 0 if exception or TRUE/FALSE */
+    int (*is_extensible)(JSContext *ctx, JSValueConst obj);
+    /* return < 0 if exception or TRUE/FALSE */
+    int (*prevent_extensions)(JSContext *ctx, JSValueConst obj);
 } JSClassExoticMethods;
 
 typedef void JSClassFinalizer(JSRuntime *rt, JSValue val);
@@ -576,19 +614,7 @@ static inline JS_BOOL JS_IsNumber(JSValueConst v)
 static inline JS_BOOL JS_IsBigInt(JSContext *ctx, JSValueConst v)
 {
     int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_BIG_INT;
-}
-
-static inline JS_BOOL JS_IsBigFloat(JSValueConst v)
-{
-    int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_BIG_FLOAT;
-}
-
-static inline JS_BOOL JS_IsBigDecimal(JSValueConst v)
-{
-    int tag = JS_VALUE_GET_TAG(v);
-    return tag == JS_TAG_BIG_DECIMAL;
+    return tag == JS_TAG_BIG_INT || tag == JS_TAG_SHORT_BIG_INT;
 }
 
 static inline JS_BOOL JS_IsBool(JSValueConst v)
@@ -618,7 +644,8 @@ static inline JS_BOOL JS_IsUninitialized(JSValueConst v)
 
 static inline JS_BOOL JS_IsString(JSValueConst v)
 {
-    return JS_VALUE_GET_TAG(v) == JS_TAG_STRING;
+    return JS_VALUE_GET_TAG(v) == JS_TAG_STRING ||
+        JS_VALUE_GET_TAG(v) == JS_TAG_STRING_ROPE;
 }
 
 static inline JS_BOOL JS_IsSymbol(JSValueConst v)
@@ -703,7 +730,10 @@ int JS_ToBigInt64(JSContext *ctx, int64_t *pres, JSValueConst val);
 int JS_ToInt64Ext(JSContext *ctx, int64_t *pres, JSValueConst val);
 
 JSValue JS_NewStringLen(JSContext *ctx, const char *str1, size_t len1);
-JSValue JS_NewString(JSContext *ctx, const char *str);
+static inline JSValue JS_NewString(JSContext *ctx, const char *str)
+{
+    return JS_NewStringLen(ctx, str, strlen(str));
+}
 JSValue JS_NewAtomString(JSContext *ctx, const char *str);
 JSValue JS_ToString(JSContext *ctx, JSValueConst val);
 JSValue JS_ToPropertyKey(JSContext *ctx, JSValueConst val);
@@ -813,6 +843,7 @@ int JS_DefinePropertyGetSet(JSContext *ctx, JSValueConst this_obj,
 void JS_SetOpaque(JSValue obj, void *opaque);
 void *JS_GetOpaque(JSValueConst obj, JSClassID class_id);
 void *JS_GetOpaque2(JSContext *ctx, JSValueConst obj, JSClassID class_id);
+void *JS_GetAnyOpaque(JSValueConst obj, JSClassID *class_id);
 
 /* 'buf' must be zero terminated i.e. buf[buf_len] = '\0'. */
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
@@ -881,6 +912,12 @@ typedef int JSInterruptHandler(JSRuntime *rt, void *opaque);
 void JS_SetInterruptHandler(JSRuntime *rt, JSInterruptHandler *cb, void *opaque);
 /* if can_block is TRUE, Atomics.wait() can be used */
 void JS_SetCanBlock(JSRuntime *rt, JS_BOOL can_block);
+/* select which debug info is stripped from the compiled code */
+#define JS_STRIP_SOURCE (1 << 0) /* strip source code */
+#define JS_STRIP_DEBUG  (1 << 1) /* strip all debug info including source code */
+void JS_SetStripInfo(JSRuntime *rt, int flags);
+int JS_GetStripInfo(JSRuntime *rt);
+
 /* set the [IsHTMLDDA] internal slot */
 void JS_SetIsHTMLDDA(JSContext *ctx, JSValueConst obj);
 

data/ext/quickjsrb/quickjs/run-test262.c

@@ -757,6 +757,13 @@ static JSValue js_IsHTMLDDA(JSContext *ctx, JSValue this_val,
     return JS_NULL;
 }
 
+static JSValue js_gc(JSContext *ctx, JSValueConst this_val,
+                     int argc, JSValueConst *argv)
+{
+    JS_RunGC(JS_GetRuntime(ctx));
+    return JS_UNDEFINED;
+}
+
 static JSValue add_helpers1(JSContext *ctx)
 {
     JSValue global_obj;
@@ -790,6 +797,8 @@ static JSValue add_helpers1(JSContext *ctx)
     obj = JS_NewCFunction(ctx, js_IsHTMLDDA, "IsHTMLDDA", 0);
     JS_SetIsHTMLDDA(ctx, obj);
     JS_SetPropertyStr(ctx, obj262, "IsHTMLDDA", obj);
+    JS_SetPropertyStr(ctx, obj262, "gc",
+                      JS_NewCFunction(ctx, js_gc, "gc", 0));
 
     JS_SetPropertyStr(ctx, global_obj, "$262", JS_DupValue(ctx, obj262));
 
@@ -1571,7 +1580,7 @@ int run_test_buf(const char *filename, const char *harness, namelist_t *ip,
 
     for (i = 0; i < ip->count; i++) {
         if (eval_file(ctx, harness, ip->array[i],
-                      JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_STRIP)) {
+                      JS_EVAL_TYPE_GLOBAL)) {
             fatal(1, "error including %s for %s", ip->array[i], filename);
         }
     }

data/ext/quickjsrb/quickjs/unicode_gen.c

@@ -625,7 +625,7 @@ void parse_derived_core_properties(const char *filename)
             p++;
             p += strspn(p, " \t");
             q = buf;
-            while (*p != '\0' && *p != ' ' && *p != '#' && *p != '\t') {
+            while (*p != '\0' && *p != ' ' && *p != '#' && *p != '\t' && *p != ';') {
                 if ((q - buf) < sizeof(buf) - 1)
                     *q++ = *p;
                 p++;
@@ -1117,6 +1117,24 @@ void find_run_type(TableEntry *te, CCInfo *tab, int code)
             te->ext_data[1] = ci->u_data[1];
             te->ext_data[2] = ci->u_data[2];
             te->ext_len = 3;
+        } else if (ci->u_len == 2 && ci->l_len == 0 && ci->f_len == 1) {
+            // U+FB05 LATIN SMALL LIGATURE LONG S T
+            assert(code == 0xFB05);
+            te->len = 1;
+            te->type = RUN_TYPE_UF_EXT2;
+            te->ext_data[0] = ci->u_data[0];
+            te->ext_data[1] = ci->u_data[1];
+            te->ext_len = 2;
+        } else if (ci->u_len == 3 && ci->l_len == 0 && ci->f_len == 1) {
+            // U+1FD3 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA or
+            // U+1FE3 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+            assert(code == 0x1FD3 || code == 0x1FE3);
+            te->len = 1;
+            te->type = RUN_TYPE_UF_EXT3;
+            te->ext_data[0] = ci->u_data[0];
+            te->ext_data[1] = ci->u_data[1];
+            te->ext_data[2] = ci->u_data[2];
+            te->ext_len = 3;
         } else {
             printf("unsupported encoding case:\n");
             dump_cc_info(ci, code);

data/ext/quickjsrb/quickjs/unicode_gen_def.h

@@ -82,6 +82,7 @@ DEF(Egyptian_Hieroglyphs, "Egyp")
 DEF(Elbasan, "Elba")
 DEF(Elymaic, "Elym")
 DEF(Ethiopic, "Ethi")
+DEF(Garay, "Gara")
 DEF(Georgian, "Geor")
 DEF(Glagolitic, "Glag")
 DEF(Gothic, "Goth")
@@ -90,6 +91,7 @@ DEF(Greek, "Grek")
 DEF(Gujarati, "Gujr")
 DEF(Gunjala_Gondi, "Gong")
 DEF(Gurmukhi, "Guru")
+DEF(Gurung_Khema, "Gukh")
 DEF(Han, "Hani")
 DEF(Hangul, "Hang")
 DEF(Hanifi_Rohingya, "Rohg")
@@ -112,6 +114,7 @@ DEF(Khmer, "Khmr")
 DEF(Khojki, "Khoj")
 DEF(Khitan_Small_Script, "Kits")
 DEF(Khudawadi, "Sind")
+DEF(Kirat_Rai, "Krai")
 DEF(Lao, "Laoo")
 DEF(Latin, "Latn")
 DEF(Lepcha, "Lepc")
@@ -149,6 +152,7 @@ DEF(Nushu, "Nshu")
 DEF(Nyiakeng_Puachue_Hmong, "Hmnp")
 DEF(Ogham, "Ogam")
 DEF(Ol_Chiki, "Olck")
+DEF(Ol_Onal, "Onao")
 DEF(Old_Hungarian, "Hung")
 DEF(Old_Italic, "Ital")
 DEF(Old_North_Arabian, "Narb")
@@ -180,6 +184,7 @@ DEF(Sogdian, "Sogd")
 DEF(Sora_Sompeng, "Sora")
 DEF(Soyombo, "Soyo")
 DEF(Sundanese, "Sund")
+DEF(Sunuwar, "Sunu")
 DEF(Syloti_Nagri, "Sylo")
 DEF(Syriac, "Syrc")
 DEF(Tagalog, "Tglg")
@@ -197,7 +202,9 @@ DEF(Tibetan, "Tibt")
 DEF(Tifinagh, "Tfng")
 DEF(Tirhuta, "Tirh")
 DEF(Tangsa, "Tnsa")
+DEF(Todhri, "Todr")
 DEF(Toto, "Toto")
+DEF(Tulu_Tigalari, "Tutg")
 DEF(Ugaritic, "Ugar")
 DEF(Vai, "Vaii")
 DEF(Vithkuqi, "Vith")
@@ -236,11 +243,13 @@ DEF(Deprecated, "Dep")
 DEF(Diacritic, "Dia")
 DEF(Extender, "Ext")
 DEF(Hex_Digit, "Hex")
+DEF(IDS_Unary_Operator, "IDSU")
 DEF(IDS_Binary_Operator, "IDSB")
 DEF(IDS_Trinary_Operator, "IDST")
 DEF(Ideographic, "Ideo")
 DEF(Join_Control, "Join_C")
 DEF(Logical_Order_Exception, "LOE")
+DEF(Modifier_Combining_Mark, "MCM")
 DEF(Noncharacter_Code_Point, "NChar")
 DEF(Pattern_Syntax, "Pat_Syn")
 DEF(Pattern_White_Space, "Pat_WS")
@@ -279,6 +288,9 @@ DEF(Changes_When_Uppercased, "CWU")
 DEF(Grapheme_Base, "Gr_Base")
 DEF(Grapheme_Extend, "Gr_Ext")
 DEF(ID_Continue, "IDC")
+DEF(ID_Compat_Math_Start, "")
+DEF(ID_Compat_Math_Continue, "")
+DEF(InCB, "")
 DEF(Lowercase, "Lower")
 DEF(Math, "")
 DEF(Uppercase, "Upper")

data/ext/quickjsrb/quickjsrb.c

@@ -274,6 +274,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
     return Qnil;
   }
   case JS_TAG_BIG_INT:
+  case JS_TAG_SHORT_BIG_INT:
   {
     JSValue j_toStringFunc = JS_GetPropertyStr(ctx, j_val, "toString");
     JSValue j_strigified = JS_Call(ctx, j_toStringFunc, j_val, 0, NULL);
@@ -286,8 +287,6 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
     return rb_funcall(r_str, rb_intern("to_i"), 0);
   }
-  case JS_TAG_BIG_FLOAT:
-  case JS_TAG_BIG_DECIMAL:
   case JS_TAG_SYMBOL:
   default:
     return Qnil;
@@ -515,11 +514,6 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
   JS_SetMemoryLimit(runtime, NUM2UINT(r_memory_limit));
   JS_SetMaxStackSize(runtime, NUM2UINT(r_max_stack_size));
 
-  JS_AddIntrinsicBigFloat(data->context);
-  JS_AddIntrinsicBigDecimal(data->context);
-  JS_AddIntrinsicOperators(data->context);
-  JS_EnableBignumExt(data->context, TRUE);
-
   JS_SetModuleLoaderFunc(runtime, NULL, js_module_loader, NULL);
   js_std_init_handlers(runtime);
 
@@ -677,9 +671,14 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
 
   char *filename = random_string();
   char *source = StringValueCStr(r_from);
-  JSValue func = JS_Eval(data->context, source, strlen(source), filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
-  js_module_set_import_meta(data->context, func, TRUE, FALSE);
-  JS_FreeValue(data->context, func);
+  JSValue module = JS_Eval(data->context, source, strlen(source), filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+  if (JS_IsException(module))
+  {
+    JS_FreeValue(data->context, module);
+    return to_rb_value(data->context, module);
+  }
+  js_module_set_import_meta(data->context, module, TRUE, FALSE);
+  JS_FreeValue(data->context, module);
 
   VALUE r_import_settings = rb_funcall(
       rb_const_get(rb_cClass, rb_intern("Quickjs")),

data/lib/quickjs/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.10.0
 platform: ruby
 authors:
 - hmsk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-18 00:00:00.000000000 Z
+date: 2025-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -54,8 +54,8 @@ files:
 - ext/quickjsrb/quickjs/LICENSE
 - ext/quickjsrb/quickjs/cutils.c
 - ext/quickjsrb/quickjs/cutils.h
-- ext/quickjsrb/quickjs/libbf.c
-- ext/quickjsrb/quickjs/libbf.h
+- ext/quickjsrb/quickjs/dtoa.c
+- ext/quickjsrb/quickjs/dtoa.h
 - ext/quickjsrb/quickjs/libregexp-opcode.h
 - ext/quickjsrb/quickjs/libregexp.c
 - ext/quickjsrb/quickjs/libregexp.h