Merge remote-tracking branch 'upstream/master'

Author: skuzzis

CMakeLists.txt

@@ -70,6 +70,18 @@ if(MSVC)
     xcheck_add_c_compiler_flag(/wd5045) # Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
 endif()
 
+# Set a 8MB default stack size on Windows.
+# It defaults to 1MB on MSVC, which is the same as our current JS stack size,
+# so it will overflow and crash otherwise.
+# On MinGW it defaults to 2MB.
+if(WIN32)
+    if(MSVC)
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:8388608")
+    else()
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,8388608")
+    endif()
+endif()
+
 # MacOS and GCC 11 or later need -Wno-maybe-uninitialized
 # https://github.com/quickjs-ng/quickjs/issues/453
 if(APPLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11)
@@ -88,7 +100,8 @@ if(CMAKE_SYSTEM_NAME STREQUAL "WASI")
 endif()
 
 if(CMAKE_BUILD_TYPE MATCHES "Debug")
-    add_compile_options(-O0)
+    xcheck_add_c_compiler_flag(/Od)
+    xcheck_add_c_compiler_flag(-O0)
     xcheck_add_c_compiler_flag(-ggdb)
     xcheck_add_c_compiler_flag(-fno-omit-frame-pointer)
 endif()

Makefile

@@ -45,6 +45,15 @@ endif
 
 all: $(QJS)
 
+amalgam: TEMP := $(shell mktemp -d)
+amalgam: $(QJS)
+	$(QJS) amalgam.js $(TEMP)/quickjs-amalgam.c
+	cp quickjs.h quickjs-libc.h $(TEMP)
+	cd $(TEMP) && zip -9 quickjs-amalgam.zip quickjs-amalgam.c quickjs.h quickjs-libc.h
+	cp $(TEMP)/quickjs-amalgam.zip $(BUILD_DIR)
+	cd $(TEMP) && $(RM) quickjs-amalgam.zip quickjs-amalgam.c quickjs.h quickjs-libc.h
+	$(RM) -d $(TEMP)
+
 fuzz:
 	clang -g -O1 -fsanitize=address,undefined,fuzzer -o fuzz fuzz.c
 	./fuzz
@@ -71,6 +80,7 @@ codegen: $(QJSC)
 	$(QJSC) -e -o gen/hello.c examples/hello.js
 	$(QJSC) -e -o gen/hello_module.c -m examples/hello_module.js
 	$(QJSC) -e -o gen/test_fib.c -M examples/fib.so,fib -m examples/test_fib.js
+	$(QJSC) -C -ss -o gen/builtin-array-fromasync.h builtin-array-fromasync.js
 
 debug:
 	BUILD_TYPE=Debug $(MAKE)
@@ -81,6 +91,23 @@ distclean:
 stats: $(QJS)
 	$(QJS) -qd
 
+jscheck: CFLAGS=-I. -D_GNU_SOURCE -DJS_CHECK_JSVALUE -Wall -Werror -fsyntax-only -c -o /dev/null
+jscheck:
+	$(CC) $(CFLAGS) api-test.c
+	$(CC) $(CFLAGS) ctest.c
+	$(CC) $(CFLAGS) fuzz.c
+	$(CC) $(CFLAGS) gen/function_source.c
+	$(CC) $(CFLAGS) gen/hello.c
+	$(CC) $(CFLAGS) gen/hello_module.c
+	$(CC) $(CFLAGS) gen/repl.c
+	$(CC) $(CFLAGS) gen/standalone.c
+	$(CC) $(CFLAGS) gen/test_fib.c
+	$(CC) $(CFLAGS) qjs.c
+	$(CC) $(CFLAGS) qjsc.c
+	$(CC) $(CFLAGS) quickjs-libc.c
+	$(CC) $(CFLAGS) quickjs.c
+	$(CC) $(CFLAGS) run-test262.c
+
 # effectively .PHONY because it doesn't generate output
 ctest: CFLAGS=-std=c11 -fsyntax-only -Wall -Wextra -Werror -pedantic
 ctest: ctest.c quickjs.h
@@ -117,4 +144,4 @@ unicode_gen: $(BUILD_DIR)
 libunicode-table.h: unicode_gen
 	$(BUILD_DIR)/unicode_gen unicode $@
 
-.PHONY: all ctest cxxtest debug fuzz install clean codegen distclean stats test test262 test262-update test262-check microbench unicode_gen $(QJS) $(QJSC)
+.PHONY: all amalgam ctest cxxtest debug fuzz jscheck install clean codegen distclean stats test test262 test262-update test262-check microbench unicode_gen $(QJS) $(QJSC)

amalgam.js

@@ -0,0 +1,49 @@
+import {loadFile, writeFile} from "qjs:std"
+
+const cutils_c = loadFile("cutils.c")
+const cutils_h = loadFile("cutils.h")
+const libbf_c = loadFile("libbf.c")
+const libbf_h = loadFile("libbf.h")
+const libregexp_c = loadFile("libregexp.c")
+const libregexp_h = loadFile("libregexp.h")
+const libregexp_opcode_h = loadFile("libregexp-opcode.h")
+const libunicode_c = loadFile("libunicode.c")
+const libunicode_h = loadFile("libunicode.h")
+const libunicode_table_h = loadFile("libunicode-table.h")
+const list_h = loadFile("list.h")
+const quickjs_atom_h = loadFile("quickjs-atom.h")
+const quickjs_c = loadFile("quickjs.c")
+const quickjs_c_atomics_h = loadFile("quickjs-c-atomics.h")
+const quickjs_h = loadFile("quickjs.h")
+const quickjs_libc_c = loadFile("quickjs-libc.c")
+const quickjs_libc_h = loadFile("quickjs-libc.h")
+const quickjs_opcode_h = loadFile("quickjs-opcode.h")
+const gen_builtin_array_fromasync_h = loadFile("gen/builtin-array-fromasync.h")
+
+let source = "#if defined(QJS_BUILD_LIBC) && defined(__linux__) && !defined(_GNU_SOURCE)\n"
+           + "#define _GNU_SOURCE\n"
+           + "#endif\n"
+           + quickjs_c_atomics_h
+           + cutils_h
+           + list_h
+           + libbf_h
+           + libunicode_h // exports lre_is_id_start, used by libregexp.h
+           + libregexp_h
+           + libunicode_table_h
+           + quickjs_h
+           + quickjs_c
+           + cutils_c
+           + libbf_c
+           + libregexp_c
+           + libunicode_c
+           + "#ifdef QJS_BUILD_LIBC\n"
+           + quickjs_libc_h
+           + quickjs_libc_c
+           + "#endif // QJS_BUILD_LIBC\n"
+source = source.replace(/#include "quickjs-atom.h"/g, quickjs_atom_h)
+source = source.replace(/#include "quickjs-opcode.h"/g, quickjs_opcode_h)
+source = source.replace(/#include "libregexp-opcode.h"/g, libregexp_opcode_h)
+source = source.replace(/#include "gen\/builtin-array-fromasync.h"/g,
+                        gen_builtin_array_fromasync_h)
+source = source.replace(/#include "[^"]+"/g, "")
+writeFile(execArgv[2] ?? "quickjs-amalgam.c", source)

api-test.c

@@ -3,11 +3,12 @@
 #endif
 #include <assert.h>
 #include <stdlib.h>
+#include <string.h>
 #include "quickjs.h"
 
 #define MAX_TIME 10
 
-static int timeout_interrupt_handler(JSRuntime *rt, void *opaque) 
+static int timeout_interrupt_handler(JSRuntime *rt, void *opaque)
 {
     int *time = (int *)opaque;
     if (*time <= MAX_TIME)
@@ -17,7 +18,7 @@ static int timeout_interrupt_handler(JSRuntime *rt, void *opaque)
 
 static void sync_call(void)
 {
-    const char *code = 
+    const char *code =
 "(function() { \
     try { \
         while (true) {} \
@@ -42,7 +43,7 @@ static void sync_call(void)
 
 static void async_call(void)
 {
-    const char *code = 
+    const char *code =
 "(async function() { \
     const loop = async () => { \
         await Promise.resolve(); \
@@ -73,7 +74,8 @@ static void async_call(void)
     JS_FreeRuntime(rt);
 }
 
-static JSValue save_value(JSContext *ctx, JSValue this_val, int argc, JSValue *argv)
+static JSValue save_value(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
 {
     assert(argc == 1);
     JSValue *p = (JSValue *)JS_GetContextOpaque(ctx);
@@ -96,8 +98,6 @@ static void async_call_stack_overflow(void)
 
     JSRuntime *rt = JS_NewRuntime();
     JSContext *ctx = JS_NewContext(rt);
-    JS_SetMaxStackSize(rt, 128 * 1024);
-    JS_UpdateStackTop(rt);
     JSValue value = JS_UNDEFINED;
     JS_SetContextOpaque(ctx, &value);
     JSValue global = JS_GetGlobalObject(ctx);
@@ -147,11 +147,136 @@ static void raw_context_global_var(void)
     JS_FreeRuntime(rt);
 }
 
+static void is_array(void)
+{
+    JSRuntime *rt = JS_NewRuntime();
+    JSContext *ctx = JS_NewContext(rt);
+    {
+        static const char code[] = "[]";
+        JSValue ret = JS_Eval(ctx, code, strlen(code), "*", JS_EVAL_TYPE_GLOBAL);
+        assert(!JS_IsException(ret));
+        assert(JS_IsArray(ret));
+        JS_FreeValue(ctx, ret);
+    }
+    {
+        static const char code[] = "new Proxy([], {})";
+        JSValue ret = JS_Eval(ctx, code, strlen(code), "*", JS_EVAL_TYPE_GLOBAL);
+        assert(!JS_IsException(ret));
+        assert(!JS_IsArray(ret));
+        assert(JS_IsProxy(ret));
+        JSValue handler = JS_GetProxyHandler(ctx, ret);
+        JSValue target = JS_GetProxyTarget(ctx, ret);
+        assert(!JS_IsException(handler));
+        assert(!JS_IsException(target));
+        assert(!JS_IsProxy(handler));
+        assert(!JS_IsProxy(target));
+        assert(JS_IsObject(handler));
+        assert(JS_IsArray(target));
+        JS_FreeValue(ctx, handler);
+        JS_FreeValue(ctx, target);
+        JS_FreeValue(ctx, ret);
+    }
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+static int loader_calls;
+
+static JSModuleDef *loader(JSContext *ctx, const char *name, void *opaque)
+{
+    loader_calls++;
+    assert(!strcmp(name, "b"));
+    static const char code[] = "export function f(x){}";
+    JSValue ret = JS_Eval(ctx, code, strlen(code), "b",
+                          JS_EVAL_TYPE_MODULE|JS_EVAL_FLAG_COMPILE_ONLY);
+    assert(!JS_IsException(ret));
+    JSModuleDef *m = JS_VALUE_GET_PTR(ret);
+    assert(m);
+    JS_FreeValue(ctx, ret);
+    return m;
+}
+
+static void module_serde(void)
+{
+    JSRuntime *rt = JS_NewRuntime();
+    JS_SetDumpFlags(rt, JS_DUMP_MODULE_RESOLVE);
+    JS_SetModuleLoaderFunc(rt, NULL, loader, NULL);
+    JSContext *ctx = JS_NewContext(rt);
+    static const char code[] = "import {f} from 'b'; f()";
+    assert(loader_calls == 0);
+    JSValue mod = JS_Eval(ctx, code, strlen(code), "a",
+                          JS_EVAL_TYPE_MODULE|JS_EVAL_FLAG_COMPILE_ONLY);
+    assert(loader_calls == 1);
+    assert(!JS_IsException(mod));
+    assert(JS_IsModule(mod));
+    size_t len = 0;
+    uint8_t *buf = JS_WriteObject(ctx, &len, mod,
+                                  JS_WRITE_OBJ_BYTECODE|JS_WRITE_OBJ_REFERENCE);
+    assert(buf);
+    assert(len > 0);
+    JS_FreeValue(ctx, mod);
+    assert(loader_calls == 1);
+    mod = JS_ReadObject(ctx, buf, len, JS_READ_OBJ_BYTECODE);
+    free(buf);
+    assert(loader_calls == 1); // 'b' is returned from cache
+    assert(!JS_IsException(mod));
+    JSValue ret = JS_EvalFunction(ctx, mod);
+    assert(!JS_IsException(ret));
+    assert(JS_IsPromise(ret));
+    JSValue result = JS_PromiseResult(ctx, ret);
+    assert(!JS_IsException(result));
+    assert(JS_IsUndefined(result));
+    JS_FreeValue(ctx, result);
+    JS_FreeValue(ctx, ret);
+    JS_FreeValue(ctx, mod);
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
+static void two_byte_string(void)
+{
+    JSRuntime *rt = JS_NewRuntime();
+    JSContext *ctx = JS_NewContext(rt);
+    {
+        JSValue v = JS_NewTwoByteString(ctx, NULL, 0);
+        assert(!JS_IsException(v));
+        const char *s = JS_ToCString(ctx, v);
+        assert(s);
+        assert(!strcmp(s, ""));
+        JS_FreeCString(ctx, s);
+        JS_FreeValue(ctx, v);
+    }
+    {
+        JSValue v = JS_NewTwoByteString(ctx, (uint16_t[]){'o','k'}, 2);
+        assert(!JS_IsException(v));
+        const char *s = JS_ToCString(ctx, v);
+        assert(s);
+        assert(!strcmp(s, "ok"));
+        JS_FreeCString(ctx, s);
+        JS_FreeValue(ctx, v);
+    }
+    {
+        JSValue v = JS_NewTwoByteString(ctx, (uint16_t[]){0xD800}, 1);
+        assert(!JS_IsException(v));
+        const char *s = JS_ToCString(ctx, v);
+        assert(s);
+        // questionable but surrogates don't map to UTF-8 without WTF-8
+        assert(!strcmp(s, "\xED\xA0\x80"));
+        JS_FreeCString(ctx, s);
+        JS_FreeValue(ctx, v);
+    }
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+}
+
 int main(void)
 {
     sync_call();
     async_call();
     async_call_stack_overflow();
     raw_context_global_var();
+    is_array();
+    module_serde();
+    two_byte_string();
     return 0;
 }

builtin-array-fromasync.js

@@ -0,0 +1,36 @@
+;(function(Array, TypeError, asyncIterator, defineProperty, iterator) {
+    "use strict" // result.length=i should throw if .length is not writable
+    return async function fromAsync(arrayLike, mapFn=undefined, thisArg=undefined) {
+        if (mapFn !== undefined && typeof mapFn !== "function") throw new TypeError("not a function")
+        let result, i = 0, isConstructor = typeof this === "function"
+        let sync = false, method = arrayLike[asyncIterator]
+        if (method == null) sync = true, method = arrayLike[iterator]
+        if (method == null) {
+            let {length} = arrayLike
+            length = +length || 0
+            result = isConstructor ? new this(length) : Array(length)
+            while (i < length) {
+                let value = arrayLike[i]
+                if (sync) value = await value
+                if (mapFn) value = await mapFn.call(thisArg, value, i)
+                defineProperty(result, i++, {value, configurable: true, writable: true})
+            }
+        } else {
+            const iter = method.call(arrayLike)
+            result = isConstructor ? new this() : Array()
+            try {
+                for (;;) {
+                    let {value, done} = await iter.next()
+                    if (done) break
+                    if (sync) value = await value
+                    if (mapFn) value = await mapFn.call(thisArg, value, i)
+                    defineProperty(result, i++, {value, configurable: true, writable: true})
+                }
+            } finally {
+                if (iter.return) iter.return()
+            }
+        }
+        result.length = i
+        return result
+    }
+})

docs/docs/building.md

@@ -26,6 +26,16 @@ make
 This will build the `qjs` and `qjsc` executables and other test tools. Head over [here](./cli) for
 instructions on how to use them.
 
+## Amalgamated builds
+
+The amalgamated build rolls individual source files into a single big file.
+It's a good choice for projects that want to use QuickJS without CMake.
+
+Download quickjs-amalgam.zip from https://github.com/quickjs-ng/quickjs/releases
+
+To enable the std, os and bjson modules, compile quickjs-amalgam.c with
+`-DQJS_BUILD_LIBC`.
+
 ## Debug builds
 
 ```bash

docs/docs/projects.md

@@ -30,3 +30,7 @@ Rust wrapper focus on embedding-ready and no-pain type conversion and interopera
 ## [GodotJS](https://github.com/godotjs/GodotJS)
 
 This project adds TypeScript/JavaScript support for Godot 4.x. It supports multiple javascript runtimes, including QuickJS-NG.
+
+## [quickjs_es_runtime](https://github.com/HiRoFa/quickjs_es_runtime)
+
+Rust wrapper with typescript, modules, promises, async/await and much more.