quickjs 0.9.0 → 0.11.0

data/ext/quickjsrb/quickjs/qjsc.c

@@ -76,6 +76,7 @@ static const FeatureEntry feature_list[] = {
     { "promise", "Promise" },
 #define FE_MODULE_LOADER 9
     { "module-loader", NULL },
+    { "weakref", "WeakRef" },
 };
 
 void namelist_add(namelist_t *lp, const char *name, const char *short_name,
@@ -169,14 +170,24 @@ static void dump_hex(FILE *f, const uint8_t *buf, size_t len)
         fprintf(f, "\n");
 }
 
+typedef enum {
+    CNAME_TYPE_SCRIPT,
+    CNAME_TYPE_MODULE,
+    CNAME_TYPE_JSON_MODULE,
+} CNameTypeEnum;
+
 static void output_object_code(JSContext *ctx,
                                FILE *fo, JSValueConst obj, const char *c_name,
-                               BOOL load_only)
+                               CNameTypeEnum c_name_type)
 {
     uint8_t *out_buf;
     size_t out_buf_len;
     int flags;
-    flags = JS_WRITE_OBJ_BYTECODE;
+
+    if (c_name_type == CNAME_TYPE_JSON_MODULE)
+        flags = 0;
+    else
+        flags = JS_WRITE_OBJ_BYTECODE;
     if (byte_swap)
         flags |= JS_WRITE_OBJ_BSWAP;
     out_buf = JS_WriteObject(ctx, &out_buf_len, obj, flags);
@@ -185,7 +196,7 @@ static void output_object_code(JSContext *ctx,
         exit(1);
     }
 
-    namelist_add(&cname_list, c_name, NULL, load_only);
+    namelist_add(&cname_list, c_name, NULL, c_name_type);
 
     fprintf(fo, "const uint32_t %s_size = %u;\n\n",
             c_name, (unsigned int)out_buf_len);
@@ -226,7 +237,8 @@ static void find_unique_cname(char *cname, size_t cname_size)
 }
 
 JSModuleDef *jsc_module_loader(JSContext *ctx,
-                              const char *module_name, void *opaque)
+                               const char *module_name, void *opaque,
+                               JSValueConst attributes)
 {
     JSModuleDef *m;
     namelist_entry_t *e;
@@ -248,9 +260,9 @@ JSModuleDef *jsc_module_loader(JSContext *ctx,
     } else {
         size_t buf_len;
         uint8_t *buf;
-        JSValue func_val;
         char cname[1024];
-
+        int res;
+        
         buf = js_load_file(ctx, &buf_len, module_name);
         if (!buf) {
             JS_ThrowReferenceError(ctx, "could not load module filename '%s'",
@@ -258,21 +270,59 @@ JSModuleDef *jsc_module_loader(JSContext *ctx,
             return NULL;
         }
 
-        /* compile the module */
-        func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
-                           JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
-        js_free(ctx, buf);
-        if (JS_IsException(func_val))
-            return NULL;
-        get_c_name(cname, sizeof(cname), module_name);
-        if (namelist_find(&cname_list, cname)) {
-            find_unique_cname(cname, sizeof(cname));
-        }
-        output_object_code(ctx, outfile, func_val, cname, TRUE);
+        res = js_module_test_json(ctx, attributes);
+        if (has_suffix(module_name, ".json") || res > 0) {
+            /* compile as JSON or JSON5 depending on "type" */
+            JSValue val;
+            int flags;
+
+            if (res == 2)
+                flags = JS_PARSE_JSON_EXT;
+            else
+                flags = 0;
+            val = JS_ParseJSON2(ctx, (char *)buf, buf_len, module_name, flags);
+            js_free(ctx, buf);
+            if (JS_IsException(val))
+                return NULL;
+            /* create a dummy module */
+            m = JS_NewCModule(ctx, module_name, js_module_dummy_init);
+            if (!m) {
+                JS_FreeValue(ctx, val);
+                return NULL;
+            }
 
-        /* the module is already referenced, so we must free it */
-        m = JS_VALUE_GET_PTR(func_val);
-        JS_FreeValue(ctx, func_val);
+            get_c_name(cname, sizeof(cname), module_name);
+            if (namelist_find(&cname_list, cname)) {
+                find_unique_cname(cname, sizeof(cname));
+            }
+
+            /* output the module name */
+            fprintf(outfile, "static const uint8_t %s_module_name[] = {\n",
+                    cname);
+            dump_hex(outfile, (const uint8_t *)module_name, strlen(module_name) + 1);
+            fprintf(outfile, "};\n\n");
+
+            output_object_code(ctx, outfile, val, cname, CNAME_TYPE_JSON_MODULE);
+            JS_FreeValue(ctx, val);
+        } else {
+            JSValue func_val;
+
+            /* compile the module */
+            func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
+                               JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+            js_free(ctx, buf);
+            if (JS_IsException(func_val))
+                return NULL;
+            get_c_name(cname, sizeof(cname), module_name);
+            if (namelist_find(&cname_list, cname)) {
+                find_unique_cname(cname, sizeof(cname));
+            }
+            output_object_code(ctx, outfile, func_val, cname, CNAME_TYPE_MODULE);
+            
+            /* the module is already referenced, so we must free it */
+            m = JS_VALUE_GET_PTR(func_val);
+            JS_FreeValue(ctx, func_val);
+        }
     }
     return m;
 }
@@ -312,8 +362,11 @@ static void compile_file(JSContext *ctx, FILE *fo,
         pstrcpy(c_name, sizeof(c_name), c_name1);
     } else {
         get_c_name(c_name, sizeof(c_name), filename);
+        if (namelist_find(&cname_list, c_name)) {
+            find_unique_cname(c_name, sizeof(c_name));
+        }
     }
-    output_object_code(ctx, fo, obj, c_name, FALSE);
+    output_object_code(ctx, fo, obj, c_name, CNAME_TYPE_SCRIPT);
     JS_FreeValue(ctx, obj);
 }
 
@@ -352,7 +405,9 @@ void help(void)
            "-M module_name[,cname] add initialization code for an external C module\n"
            "-x          byte swapped output\n"
            "-p prefix   set the prefix of the generated C names\n"
-           "-S n        set the maximum stack size to 'n' bytes (default=%d)\n",
+           "-S n        set the maximum stack size to 'n' bytes (default=%d)\n"
+           "-s            strip all the debug info\n"
+           "--keep-source keep the source code\n",
            JS_DEFAULT_STACK_SIZE);
 #ifdef CONFIG_LTO
     {
@@ -471,6 +526,31 @@ static int output_executable(const char *out_filename, const char *cfilename,
 }
 #endif
 
+static size_t get_suffixed_size(const char *str)
+{
+    char *p;
+    size_t v;
+    v = (size_t)strtod(str, &p);
+    switch(*p) {
+    case 'G':
+        v <<= 30;
+        break;
+    case 'M':
+        v <<= 20;
+        break;
+    case 'k':
+    case 'K':
+        v <<= 10;
+        break;
+    default:
+        if (*p != '\0') {
+            fprintf(stderr, "qjs: invalid suffix: %s\n", p);
+            exit(1);
+        }
+        break;
+    }
+    return v;
+}
 
 typedef enum {
     OUTPUT_C,
@@ -478,9 +558,24 @@ typedef enum {
     OUTPUT_EXECUTABLE,
 } OutputTypeEnum;
 
+static const char *get_short_optarg(int *poptind, int opt,
+                                    const char *arg, int argc, char **argv)
+{
+    const char *optarg;
+    if (*arg) {
+        optarg = arg;
+    } else if (*poptind < argc) {
+        optarg = argv[(*poptind)++];
+    } else {
+        fprintf(stderr, "qjsc: expecting parameter for -%c\n", opt);
+        exit(1);
+    }
+    return optarg;
+}
+
 int main(int argc, char **argv)
 {
-    int c, i, verbose;
+    int i, verbose, strip_flags;
     const char *out_filename, *cname;
     char cfilename[1024];
     FILE *fo;
@@ -499,6 +594,7 @@ int main(int argc, char **argv)
     module = -1;
     byte_swap = FALSE;
     verbose = 0;
+    strip_flags = JS_STRIP_SOURCE;
     use_lto = FALSE;
     stack_size = 0;
     memset(&dynamic_module_list, 0, sizeof(dynamic_module_list));
@@ -507,30 +603,51 @@ int main(int argc, char **argv)
     namelist_add(&cmodule_list, "std", "std", 0);
     namelist_add(&cmodule_list, "os", "os", 0);
 
-    for(;;) {
-        c = getopt(argc, argv, "ho:cN:f:mxevM:p:S:D:");
-        if (c == -1)
-            break;
-        switch(c) {
-        case 'h':
-            help();
-        case 'o':
-            out_filename = optarg;
-            break;
-        case 'c':
-            output_type = OUTPUT_C;
+    optind = 1;
+    while (optind < argc && *argv[optind] == '-') {
+        char *arg = argv[optind] + 1;
+        const char *longopt = "";
+        const char *optarg;
+        /* a single - is not an option, it also stops argument scanning */
+        if (!*arg)
             break;
-        case 'e':
-            output_type = OUTPUT_C_MAIN;
-            break;
-        case 'N':
-            cname = optarg;
-            break;
-        case 'f':
-            {
+        optind++;
+        if (*arg == '-') {
+            longopt = arg + 1;
+            arg += strlen(arg);
+            /* -- stops argument scanning */
+            if (!*longopt)
+                break;
+        }
+        for (; *arg || *longopt; longopt = "") {
+            char opt = *arg;
+            if (opt)
+                arg++;
+            if (opt == 'h' || opt == '?' || !strcmp(longopt, "help")) {
+                help();
+                continue;
+            }
+            if (opt == 'o') {
+                out_filename = get_short_optarg(&optind, opt, arg, argc, argv);
+                break;
+            }
+            if (opt == 'c') {
+                output_type = OUTPUT_C;
+                continue;
+            }
+            if (opt == 'e') {
+                output_type = OUTPUT_C_MAIN;
+                continue;
+            }
+            if (opt == 'N') {
+                cname = get_short_optarg(&optind, opt, arg, argc, argv);
+                break;
+            }
+            if (opt == 'f') {
                 const char *p;
+                optarg = get_short_optarg(&optind, opt, arg, argc, argv);
                 p = optarg;
-                if (!strcmp(optarg, "lto")) {
+                if (!strcmp(p, "lto")) {
                     use_lto = TRUE;
                 } else if (strstart(p, "no-", &p)) {
                     use_lto = TRUE;
@@ -547,16 +664,18 @@ int main(int argc, char **argv)
                     fprintf(stderr, "unsupported feature: %s\n", optarg);
                     exit(1);
                 }
+                break;
             }
-            break;
-        case 'm':
-            module = 1;
-            break;
-        case 'M':
-            {
+            if (opt == 'm') {
+                module = 1;
+                continue;
+            }
+            if (opt == 'M') {
                 char *p;
                 char path[1024];
                 char cname[1024];
+
+                optarg = get_short_optarg(&optind, opt, arg, argc, argv);
                 pstrcpy(path, sizeof(path), optarg);
                 p = strchr(path, ',');
                 if (p) {
@@ -566,25 +685,44 @@ int main(int argc, char **argv)
                     get_c_name(cname, sizeof(cname), path);
                 }
                 namelist_add(&cmodule_list, path, cname, 0);
+                break;
             }
-            break;
-        case 'D':
-            namelist_add(&dynamic_module_list, optarg, NULL, 0);
-            break;
-        case 'x':
-            byte_swap = TRUE;
-            break;
-        case 'v':
-            verbose++;
-            break;
-        case 'p':
-            c_ident_prefix = optarg;
-            break;
-        case 'S':
-            stack_size = (size_t)strtod(optarg, NULL);
-            break;
-        default:
-            break;
+            if (opt == 'D') {
+                optarg = get_short_optarg(&optind, opt, arg, argc, argv);
+                namelist_add(&dynamic_module_list, optarg, NULL, 0);
+                break;
+            }
+            if (opt == 'x') {
+                byte_swap = 1;
+                continue;
+            }
+            if (opt == 'v') {
+                verbose++;
+                continue;
+            }
+            if (opt == 'p') {
+                c_ident_prefix = get_short_optarg(&optind, opt, arg, argc, argv);
+                break;
+            }
+            if (opt == 'S') {
+                optarg = get_short_optarg(&optind, opt, arg, argc, argv);
+                stack_size = get_suffixed_size(optarg);
+                break;
+            }
+            if (opt == 's') {
+                strip_flags = JS_STRIP_DEBUG;
+                continue;
+            }
+            if (!strcmp(longopt, "keep-source")) {
+                strip_flags = 0;
+                continue;
+            }
+            if (opt) {
+                fprintf(stderr, "qjsc: unknown option '-%c'\n", opt);
+            } else {
+                fprintf(stderr, "qjsc: unknown option '--%s'\n", longopt);
+            }
+            help();
         }
     }
 
@@ -620,8 +758,10 @@ int main(int argc, char **argv)
     rt = JS_NewRuntime();
     ctx = JS_NewContext(rt);
 
+    JS_SetStripInfo(rt, strip_flags);
+
     /* loader for ES6 modules */
-    JS_SetModuleLoaderFunc(rt, NULL, jsc_module_loader, NULL);
+    JS_SetModuleLoaderFunc2(rt, NULL, jsc_module_loader, NULL, NULL);
 
     fprintf(fo, "/* File generated automatically by the QuickJS compiler. */\n"
             "\n"
@@ -644,7 +784,7 @@ int main(int argc, char **argv)
     }
 
     for(i = 0; i < dynamic_module_list.count; i++) {
-        if (!jsc_module_loader(ctx, dynamic_module_list.array[i].name, NULL)) {
+        if (!jsc_module_loader(ctx, dynamic_module_list.array[i].name, NULL, JS_UNDEFINED)) {
             fprintf(stderr, "Could not load dynamic module '%s'\n",
                     dynamic_module_list.array[i].name);
             exit(1);
@@ -682,9 +822,12 @@ int main(int argc, char **argv)
         }
         for(i = 0; i < cname_list.count; i++) {
             namelist_entry_t *e = &cname_list.array[i];
-            if (e->flags) {
+            if (e->flags == CNAME_TYPE_MODULE) {
                 fprintf(fo, "  js_std_eval_binary(ctx, %s, %s_size, 1);\n",
                         e->name, e->name);
+            } else if (e->flags == CNAME_TYPE_JSON_MODULE) {
+                fprintf(fo, "  js_std_eval_binary_json_module(ctx, %s, %s_size, (const char *)%s_module_name);\n",
+                        e->name, e->name, e->name);
             }
         }
         fprintf(fo,
@@ -700,7 +843,7 @@ int main(int argc, char **argv)
 
         /* add the module loader if necessary */
         if (feature_bitmap & (1 << FE_MODULE_LOADER)) {
-            fprintf(fo, "  JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);\n");
+            fprintf(fo, "  JS_SetModuleLoaderFunc2(rt, NULL, js_module_loader, js_module_check_attributes, NULL);\n");
         }
 
         fprintf(fo,
@@ -709,7 +852,7 @@ int main(int argc, char **argv)
 
         for(i = 0; i < cname_list.count; i++) {
             namelist_entry_t *e = &cname_list.array[i];
-            if (!e->flags) {
+            if (e->flags == CNAME_TYPE_SCRIPT) {
                 fprintf(fo, "  js_std_eval_binary(ctx, %s, %s_size, 0);\n",
                         e->name, e->name);
             }

data/ext/quickjsrb/quickjs/quickjs-atom.h

@@ -81,6 +81,7 @@ DEF(empty_string, "")
 DEF(length, "length")
 DEF(fileName, "fileName")
 DEF(lineNumber, "lineNumber")
+DEF(columnNumber, "columnNumber")
 DEF(message, "message")
 DEF(cause, "cause")
 DEF(errors, "errors")
@@ -172,6 +173,16 @@ DEF(status, "status")
 DEF(reason, "reason")
 DEF(globalThis, "globalThis")
 DEF(bigint, "bigint")
+DEF(minus_zero, "-0")
+DEF(Infinity, "Infinity")
+DEF(minus_Infinity, "-Infinity")
+DEF(NaN, "NaN")
+DEF(hasIndices, "hasIndices")
+DEF(ignoreCase, "ignoreCase")
+DEF(multiline, "multiline")
+DEF(dotAll, "dotAll")
+DEF(sticky, "sticky")
+DEF(unicodeSets, "unicodeSets")
 /* the following 3 atoms are only used with CONFIG_ATOMICS */
 DEF(not_equal, "not-equal")
 DEF(timed_out, "timed-out")
@@ -206,10 +217,13 @@ DEF(Int32Array, "Int32Array")
 DEF(Uint32Array, "Uint32Array")
 DEF(BigInt64Array, "BigInt64Array")
 DEF(BigUint64Array, "BigUint64Array")
+DEF(Float16Array, "Float16Array")
 DEF(Float32Array, "Float32Array")
 DEF(Float64Array, "Float64Array")
 DEF(DataView, "DataView")
 DEF(BigInt, "BigInt")
+DEF(WeakRef, "WeakRef")
+DEF(FinalizationRegistry, "FinalizationRegistry")
 DEF(Map, "Map")
 DEF(Set, "Set") /* Map + 1 */
 DEF(WeakMap, "WeakMap") /* Map + 2 */