Refactor reactor to reuse shared initialization from qjs.c

paralin · paralin · commit aa950c099246 · 2026-01-07T22:42:37.000-08:00
Extract common initialization logic from qjs.c into reusable functions that
can be shared with the WASI reactor build. This eliminates code duplication
between main() and qjs_init_argv(), reducing the reactor file by 45%.

Add qjs-common.h with public API:
- QJSConfig struct for initialization options
- qjs_config_init() / qjs_config_parse_args() for CLI parsing
- qjs_setup_runtime() for module loader and promise tracker setup
- qjs_apply_config() for loading std modules, includes, and eval
- qjs_new_context() (formerly static JS_NewCustomContext)
- qjs_eval_buf() / qjs_eval_file() / qjs_parse_limit()

Changes to qjs.c:
- Make eval_buf, eval_file, parse_limit, JS_NewCustomContext non-static
- Add shared helper functions for runtime/context initialization
- Guard main() with #ifndef QJS_NO_MAIN for reactor builds

The reactor now uses these shared functions instead of duplicating the
argument parsing and initialization code. This also removes the #include
"qjs.c" hack that was used to access static functions.

Signed-off-by: Christian Stewart &lt;christian@aperture.us&gt;
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -344,13 +344,14 @@ if(CMAKE_SYSTEM_NAME STREQUAL "WASI")
     if(QJS_WASI_REACTOR)
         add_executable(qjs_wasi
             quickjs-libc.c
+            qjs.c
             qjs-wasi-reactor.c
         )
         set_target_properties(qjs_wasi PROPERTIES
             OUTPUT_NAME "qjs"
             SUFFIX ".wasm"
         )
-        target_compile_definitions(qjs_wasi PRIVATE ${qjs_defines})
+        target_compile_definitions(qjs_wasi PRIVATE ${qjs_defines} QJS_NO_MAIN)
         target_link_libraries(qjs_wasi qjs)
         target_link_options(qjs_wasi PRIVATE
             -mexec-model=reactor
diff --git a/qjs-common.h b/qjs-common.h
@@ -0,0 +1,90 @@
+/*
+ * QuickJS shared initialization types and functions
+ *
+ * Copyright (c) 2017-2021 Fabrice Bellard
+ * Copyright (c) 2017-2021 Charlie Gordon
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef QJS_COMMON_H
+#define QJS_COMMON_H
+
+#include "quickjs.h"
+
+#define QJS_INCLUDE_MAX 32
+
+/* Return values for qjs_config_parse_args() */
+#define QJS_PARSE_OK        0
+#define QJS_PARSE_ERROR    -1
+#define QJS_PARSE_HELP     -2  /* Help requested, caller should display help and exit */
+
+/* Configuration for QJS initialization */
+typedef struct {
+    char *expr;
+    int module;           /* -1 = auto, 0 = script, 1 = module */
+    int load_std;
+    char *include_list[QJS_INCLUDE_MAX];
+    int include_count;
+    int64_t memory_limit; /* -1 = default */
+    int64_t stack_size;   /* -1 = default */
+#ifndef QJS_NO_MAIN
+    /* Main-specific options (not used in reactor builds) */
+    int interactive;
+    int dump_memory;
+    int dump_flags;
+    int trace_memory;
+    int empty_run;
+    char *compile_file;
+    char *out;
+    char *exe;
+#endif
+} QJSConfig;
+
+/* Initialize config with defaults */
+void qjs_config_init(QJSConfig *cfg);
+
+/* Parse command line arguments into config. Updates *poptind.
+ * Returns 0 on success, -1 on error. */
+int qjs_config_parse_args(QJSConfig *cfg, int argc, char **argv, int *poptind);
+
+/* Parse a size limit string (e.g., "256m", "1g"). Returns -1 on error. */
+int64_t qjs_parse_limit(const char *arg);
+
+/* Create a new custom context with std/os/bjson modules */
+JSContext *qjs_new_context(JSRuntime *rt);
+
+/* Set argc/argv for use by qjs_new_context (for execArgv global) */
+void qjs_set_argv(int argc, char **argv);
+
+/* Set up runtime with config (memory limit, stack size, module loader, etc.) */
+void qjs_setup_runtime(JSRuntime *rt);
+
+/* Apply config to context: load std modules, includes, eval expr/file.
+ * Returns 0 on success, -1 on error. */
+int qjs_apply_config(JSContext *ctx, const QJSConfig *cfg, int argc, char **argv);
+
+/* Evaluate a buffer */
+int qjs_eval_buf(JSContext *ctx, const void *buf, int buf_len,
+                 const char *filename, int eval_flags);
+
+/* Evaluate a file */
+int qjs_eval_file(JSContext *ctx, const char *filename, int module);
+
+#endif /* QJS_COMMON_H */
diff --git a/qjs-wasi-reactor.c b/qjs-wasi-reactor.c
@@ -26,9 +26,9 @@
  * THE SOFTWARE.
  */
 
-/* Include qjs.c to get access to static functions like eval_buf, eval_file,
- * parse_limit, and JS_NewCustomContext */
-#include "qjs.c"
+#include "quickjs.h"
+#include "quickjs-libc.h"
+#include "qjs-common.h"
 
 static JSRuntime *reactor_rt = NULL;
 static JSContext *reactor_ctx = NULL;
@@ -45,145 +45,52 @@ int qjs_init(void)
 __attribute__((export_name("qjs_init_argv")))
 int qjs_init_argv(int argc, char **argv)
 {
+    QJSConfig cfg;
     int optind = 1;
-    char *expr = NULL;
-    int module = -1;
-    int load_std = 0;
-    char *include_list[32];
-    int i, include_count = 0;
-    int64_t memory_limit = -1;
-    int64_t stack_size = -1;
 
     if (reactor_rt)
         return -1; /* already initialized */
 
-    /* Parse options (subset of main()) */
-    while (optind < argc && *argv[optind] == '-') {
-        char *arg = argv[optind] + 1;
-        const char *longopt = "";
-        char *optarg = NULL;
-        if (!*arg)
-            break;
-        optind++;
-        if (*arg == '-') {
-            longopt = arg + 1;
-            optarg = strchr(longopt, '=');
-            if (optarg)
-                *optarg++ = '\0';
-            arg += strlen(arg);
-            if (!*longopt)
-                break;
-        }
-        for (; *arg || *longopt; longopt = "") {
-            char opt = *arg;
-            if (opt) {
-                arg++;
-                if (!optarg && *arg)
-                    optarg = arg;
-            }
-            if (opt == 'e' || !strcmp(longopt, "eval")) {
-                if (!optarg) {
-                    if (optind >= argc)
-                        return -1;
-                    optarg = argv[optind++];
-                }
-                expr = optarg;
-                break;
-            }
-            if (opt == 'I' || !strcmp(longopt, "include")) {
-                if (optind >= argc || include_count >= countof(include_list))
-                    return -1;
-                include_list[include_count++] = argv[optind++];
-                continue;
-            }
-            if (opt == 'm' || !strcmp(longopt, "module")) {
-                module = 1;
-                continue;
-            }
-            if (!strcmp(longopt, "std")) {
-                load_std = 1;
-                continue;
-            }
-            if (!strcmp(longopt, "memory-limit")) {
-                if (!optarg) {
-                    if (optind >= argc)
-                        return -1;
-                    optarg = argv[optind++];
-                }
-                memory_limit = parse_limit(optarg);
-                break;
-            }
-            if (!strcmp(longopt, "stack-size")) {
-                if (!optarg) {
-                    if (optind >= argc)
-                        return -1;
-                    optarg = argv[optind++];
-                }
-                stack_size = parse_limit(optarg);
-                break;
-            }
-            break; /* ignore unknown options */
-        }
-    }
+    qjs_config_init(&cfg);
+    if (qjs_config_parse_args(&cfg, argc, argv, &optind) < 0)
+        return -1;
+
+    qjs_set_argv(argc, argv);
 
     reactor_rt = JS_NewRuntime();
     if (!reactor_rt)
         return -1;
-    if (memory_limit >= 0)
-        JS_SetMemoryLimit(reactor_rt, (size_t)memory_limit);
-    if (stack_size >= 0)
-        JS_SetMaxStackSize(reactor_rt, (size_t)stack_size);
 
-    js_std_set_worker_new_context_func(JS_NewCustomContext);
-    js_std_init_handlers(reactor_rt);
+    if (cfg.memory_limit >= 0)
+        JS_SetMemoryLimit(reactor_rt, (size_t)cfg.memory_limit);
+    if (cfg.stack_size >= 0)
+        JS_SetMaxStackSize(reactor_rt, (size_t)cfg.stack_size);
 
-    reactor_ctx = JS_NewCustomContext(reactor_rt);
-    if (!reactor_ctx) {
-        js_std_free_handlers(reactor_rt);
-        JS_FreeRuntime(reactor_rt);
-        reactor_rt = NULL;
-        return -1;
-    }
+    qjs_setup_runtime(reactor_rt);
 
-    JS_SetModuleLoaderFunc2(reactor_rt, NULL, js_module_loader,
-                            js_module_check_attributes, NULL);
-    JS_SetHostPromiseRejectionTracker(reactor_rt, js_std_promise_rejection_tracker, NULL);
-    js_std_add_helpers(reactor_ctx, argc - optind, argv + optind);
-
-    if (load_std) {
-        const char *str =
-            "import * as bjson from 'qjs:bjson';\n"
-            "import * as std from 'qjs:std';\n"
-            "import * as os from 'qjs:os';\n"
-            "globalThis.bjson = bjson;\n"
-            "globalThis.std = std;\n"
-            "globalThis.os = os;\n";
-        if (eval_buf(reactor_ctx, str, strlen(str), "<input>", JS_EVAL_TYPE_MODULE))
-            goto fail;
-    }
+    reactor_ctx = qjs_new_context(reactor_rt);
+    if (!reactor_ctx)
+        goto fail;
 
-    for (i = 0; i < include_count; i++) {
-        if (eval_file(reactor_ctx, include_list[i], 0))
-            goto fail;
-    }
+    if (qjs_apply_config(reactor_ctx, &cfg, argc - optind, argv + optind) < 0)
+        goto fail;
 
-    if (expr) {
-        if (eval_buf(reactor_ctx, expr, strlen(expr), "<cmdline>",
-                     module == 1 ? JS_EVAL_TYPE_MODULE : 0))
-            goto fail;
-    } else if (optind < argc) {
-        if (eval_file(reactor_ctx, argv[optind], module))
+    /* Evaluate file argument if present */
+    if (optind < argc) {
+        if (qjs_eval_file(reactor_ctx, argv[optind], cfg.module))
             goto fail;
     }
 
     return 0;
 
 fail:
     js_std_free_handlers(reactor_rt);
-    JS_FreeContext(reactor_ctx);
+    if (reactor_ctx) {
+        JS_FreeContext(reactor_ctx);
+        reactor_ctx = NULL;
+    }
     JS_FreeRuntime(reactor_rt);
     reactor_rt = NULL;
-    reactor_ctx = NULL;
     return -1;
 }
 
diff --git a/qjs.c b/qjs.c
