visaljs 0.0.5 → 0.0.7

package/node/src/host_brotli.c

@@ -0,0 +1,157 @@
+/* Host primitives for node:zlib's Brotli streams (ADR 0012): Node's binding (src/node_zlib.cc, its
+ * BrotliEncoderContext and BrotliDecoderContext) over Brotli 1.1.0, the copy Node vendors. As
+ * host_zlib.c: a stream is a handle object, and a failure is [message, errno, code]. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "brotli/decode.h"
+#include "brotli/encode.h"
+#include "js_buffer.h"
+#include "js_exception.h"
+#include "js_node.h"
+#include "js_object.h"
+#include "js_ops.h"
+#include "jsstring.h"
+
+#define PRIMITIVE(fn) \
+    JSValue fn(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target)
+#define UNUSED_PRIMITIVE_ARGS (void)callee, (void)this_val, (void)new_target
+#define ARG(i) ((i) < argc ? argv[i] : JS_UNDEFINED)
+
+/* Node's node_zlib_mode */
+enum { BROTLI_DECODE = 8, BROTLI_ENCODE = 9 };
+
+typedef struct BrotliObject {
+    JSObject                  obj;
+    int                       mode;
+    BrotliEncoderState       *encoder;
+    BrotliDecoderState       *decoder;
+    int                       flush;
+    bool                      encode_result;  /* the encoder's last result */
+    BrotliDecoderResult       decode_result;
+    BrotliDecoderErrorCode    error;
+} BrotliObject;
+
+static void brotli_end(BrotliObject *b) {
+    if (b->encoder) BrotliEncoderDestroyInstance(b->encoder);
+    if (b->decoder) BrotliDecoderDestroyInstance(b->decoder);
+    b->encoder = NULL;
+    b->decoder = NULL;
+}
+
+static void brotli_finalize(JSRuntime *rt, JSCell *cell) {
+    (void)rt;
+    brotli_end((BrotliObject *)cell);
+}
+
+static const JSClass brotli_class = { "BrotliHandle", sizeof(BrotliObject), NULL, NULL, NULL, NULL, NULL, brotli_finalize, NULL };
+
+static BrotliObject *brotli_arg(JSValue v) {
+    return js_is_object(v) && js_as_object(v)->shape->cls == &brotli_class ? (BrotliObject *)js_as_object(v) : NULL;
+}
+
+static JSValue failure(JSContext *ctx, const char *message, int err, const char *code) {
+    JSValue items[3] = { js_new_string_cstr(ctx, message), js_int32(err), js_new_string_cstr(ctx, code) };
+    JSValue a = js_new_array(ctx, 3);
+    for (int i = 0; i < 3; i++)
+        if (js_array_append(ctx, a, items[i]) < 0) return JS_EXCEPTION;
+    return a;
+}
+
+/* Init (and ResetStream, which is Init again: the parameters set before are gone, as in Node) */
+static bool brotli_init(BrotliObject *b) {
+    brotli_end(b);
+    if (b->mode == BROTLI_ENCODE) b->encoder = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+    else b->decoder = BrotliDecoderCreateInstance(NULL, NULL, NULL);
+    return b->encoder || b->decoder;
+}
+
+/* brotliNew(mode) → handle */
+PRIMITIVE(js_host_brotli_new) {
+    UNUSED_PRIMITIVE_ARGS;
+    BrotliObject *b = (BrotliObject *)js_alloc_object(ctx, JS_CELL_OBJECT, js_shape_root(ctx, &brotli_class, JS_NULL, 0));
+    b->mode = js_is_number(ARG(0)) && js_as_number(ARG(0)) == BROTLI_ENCODE ? BROTLI_ENCODE : BROTLI_DECODE;
+    b->encoder = NULL;
+    b->decoder = NULL;
+    b->flush = BROTLI_OPERATION_PROCESS;
+    b->encode_result = false;
+    b->decode_result = BROTLI_DECODER_RESULT_SUCCESS;
+    b->error = BROTLI_DECODER_NO_ERROR;
+    return js_object_value(&b->obj);
+}
+
+/* brotliInit(handle, params): params a Uint32Array, by parameter number, 0xffffffff unset →
+ * 0 | failure */
+PRIMITIVE(js_host_brotli_init) {
+    UNUSED_PRIMITIVE_ARGS;
+    BrotliObject *b = brotli_arg(ARG(0));
+    uint8_t *p;
+    size_t n;
+    if (!b || !js_buffer_source_bytes(ARG(1), &p, &n)) return js_throw_type_error(ctx, "brotliInit: a handle and parameters expected");
+    if (!brotli_init(b)) return failure(ctx, "Could not initialize Brotli instance", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+    for (size_t i = 0; i < n / sizeof(uint32_t); i++) {
+        uint32_t value;
+        memcpy(&value, p + i * sizeof value, sizeof value);
+        if (value == UINT32_MAX) continue;
+        bool ok = b->encoder ? BrotliEncoderSetParameter(b->encoder, (BrotliEncoderParameter)i, value)
+                             : BrotliDecoderSetParameter(b->decoder, (BrotliDecoderParameter)i, value);
+        if (!ok) return failure(ctx, "Setting parameter failed", -1, "ERR_BROTLI_PARAM_SET_FAILED");
+    }
+    return js_int32(0);
+}
+
+/* brotliWrite(handle, flush, in | null, inOff, inLen, out, outOff, outLen, state) → 0, with state
+ * [availOut, availIn] after it, or a failure */
+PRIMITIVE(js_host_brotli_write) {
+    UNUSED_PRIMITIVE_ARGS;
+    BrotliObject *b = brotli_arg(ARG(0));
+    uint8_t *in = NULL, *out, *state;
+    size_t in_n = 0, out_n, state_n;
+    if (!b || (!b->encoder && !b->decoder) || (!js_is_null(ARG(2)) && !js_buffer_source_bytes(ARG(2), &in, &in_n))
+        || !js_buffer_source_bytes(ARG(5), &out, &out_n) || !js_buffer_source_bytes(ARG(8), &state, &state_n) || state_n < 2 * sizeof(uint32_t))
+        return js_throw_type_error(ctx, "brotliWrite: a handle, buffers and a state expected");
+    double in_off = in ? js_as_number(ARG(3)) : 0, in_len = in ? js_as_number(ARG(4)) : 0;
+    double out_off = js_as_number(ARG(6)), out_len = js_as_number(ARG(7));
+    if (!(in_off >= 0 && in_len >= 0 && in_off + in_len <= (double)in_n && out_off >= 0 && out_len >= 0 && out_off + out_len <= (double)out_n))
+        return js_throw_range_error(ctx, "brotliWrite: out of bounds");
+    const uint8_t *next_in = in ? in + (size_t)in_off : NULL;
+    uint8_t *next_out = out + (size_t)out_off;
+    size_t avail_in = (size_t)in_len, avail_out = (size_t)out_len;
+    b->flush = js_is_number(ARG(1)) ? (int)js_as_number(ARG(1)) : BROTLI_OPERATION_PROCESS;
+    if (b->encoder) {
+        b->encode_result = BrotliEncoderCompressStream(b->encoder, (BrotliEncoderOperation)b->flush, &avail_in, &next_in, &avail_out, &next_out, NULL);
+        if (!b->encode_result) return failure(ctx, "Compression failed", -1, "ERR_BROTLI_COMPRESSION_FAILED");
+    } else {
+        b->decode_result = BrotliDecoderDecompressStream(b->decoder, &avail_in, &next_in, &avail_out, &next_out, NULL);
+        if (b->decode_result == BROTLI_DECODER_RESULT_ERROR) b->error = BrotliDecoderGetErrorCode(b->decoder);
+        if (b->error != BROTLI_DECODER_NO_ERROR) {
+            char code[64];
+            snprintf(code, sizeof code, "ERR_%s", BrotliDecoderErrorString(b->error));
+            return failure(ctx, "Decompression failed", (int)b->error, code);
+        }
+        /* zlib's error for it: Brotli has none of its own */
+        if (b->flush == BROTLI_OPERATION_FINISH && b->decode_result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT)
+            return failure(ctx, "unexpected end of file", -5, "Z_BUF_ERROR");
+    }
+    uint32_t result[2] = { (uint32_t)avail_out, (uint32_t)avail_in };
+    memcpy(state, result, sizeof result);
+    return js_int32(0);
+}
+
+/* brotliReset(handle) → 0 | failure */
+PRIMITIVE(js_host_brotli_reset) {
+    UNUSED_PRIMITIVE_ARGS;
+    BrotliObject *b = brotli_arg(ARG(0));
+    if (!b) return js_throw_type_error(ctx, "brotliReset: a handle expected");
+    if (!brotli_init(b)) return failure(ctx, "Could not initialize Brotli instance", -1, "ERR_ZLIB_INITIALIZATION_FAILED");
+    return js_int32(0);
+}
+
+/* brotliClose(handle): Brotli's memory, now */
+PRIMITIVE(js_host_brotli_close) {
+    UNUSED_PRIMITIVE_ARGS;
+    BrotliObject *b = brotli_arg(ARG(0));
+    if (b) brotli_end(b);
+    return JS_UNDEFINED;
+}

package/node/src/host_fs.c

@@ -1,4 +1,5 @@
-/* Host primitives for node:fs (ADR 0012): synchronous file access through stdio and POSIX.
+/* Host primitives for node:fs (ADR 0012): synchronous file access through stdio and POSIX, and
+ * libuv's synchronous calls for stat, readdir and reads by position.
  * The prelude (node/prelude/fs.js) validates arguments and builds Node's errors from the
  * -errno these return. Linked only into programs whose prelude imports them. */
 #define _POSIX_C_SOURCE 200809L  /* access, unlink under -std=c11 */
@@ -8,6 +9,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <uv.h>
+
 #include "js_buffer.h"
 #include "js_exception.h"
 #include "js_ops.h"
@@ -132,3 +135,94 @@ JSValue js_host_fs_unlink(JSContext *ctx, JSValue callee, JSValue this_val, uint
     free(path);
     return r == 0 ? JS_UNDEFINED : errno_result(e);
 }
+
+/* ---- stat, readdir and reads by position, through libuv's synchronous calls (every platform) */
+
+static double ms_of(uv_timespec_t t) { return (double)t.tv_sec * 1000.0 + (double)t.tv_nsec / 1e6; }
+
+/* fsStat(path, follow): [mode, size, mtimeMs, atimeMs, ctimeMs, birthtimeMs, ino, dev, nlink,
+ * uid, gid, rdev, blksize, blocks], or -errno: stat(2), lstat(2) when !follow. */
+JSValue js_host_fs_stat(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
+                        const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    char *path = js_host_path_arg(ctx, argc, argv, 0);
+    if (!path) return JS_EXCEPTION;
+    bool follow = argc < 2 || js_truthy(argv[1]);
+    uv_fs_t req;
+    int r = follow ? uv_fs_stat(uv_default_loop(), &req, path, NULL) : uv_fs_lstat(uv_default_loop(), &req, path, NULL);
+    free(path);
+    if (r < 0) {
+        uv_fs_req_cleanup(&req);
+        return js_int32(r);
+    }
+    const uv_stat_t *s = &req.statbuf;
+    JSValue items[14] = {
+        js_number((double)s->st_mode), js_number((double)s->st_size), js_number(ms_of(s->st_mtim)),
+        js_number(ms_of(s->st_atim)), js_number(ms_of(s->st_ctim)), js_number(ms_of(s->st_birthtim)),
+        js_number((double)s->st_ino), js_number((double)s->st_dev), js_number((double)s->st_nlink),
+        js_number((double)s->st_uid), js_number((double)s->st_gid), js_number((double)s->st_rdev),
+        js_number((double)s->st_blksize), js_number((double)s->st_blocks),
+    };
+    uv_fs_req_cleanup(&req);
+    return js_new_array_from(ctx, items, 14);
+}
+
+/* fsReaddir(path): [name, type, …], or -errno; type is libuv's uv_dirent_type_t (0 unknown,
+ * 1 file, 2 directory, 3 symlink, 4 FIFO, 5 socket, 6 character device, 7 block device). */
+JSValue js_host_fs_readdir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
+                           const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    char *path = js_host_path_arg(ctx, argc, argv, 0);
+    if (!path) return JS_EXCEPTION;
+    uv_fs_t req;
+    int r = uv_fs_scandir(uv_default_loop(), &req, path, 0, NULL);
+    free(path);
+    if (r < 0) {
+        uv_fs_req_cleanup(&req);
+        return js_int32(r);
+    }
+    JSValue out = js_new_array(ctx, (uint32_t)(2 * r));
+    uv_dirent_t ent;
+    while (uv_fs_scandir_next(&req, &ent) != UV_EOF) {
+        JSValue name = js_new_string_cstr(ctx, ent.name);
+        if (js_array_push(ctx, js_as_object(out), name) < 0 || js_array_push(ctx, js_as_object(out), js_int32((int32_t)ent.type)) < 0) {
+            uv_fs_req_cleanup(&req);
+            return JS_EXCEPTION;
+        }
+    }
+    uv_fs_req_cleanup(&req);
+    return out;
+}
+
+/* fsReadAt(path, position, length): up to `length` bytes from `position`, as a Buffer (shorter
+ * at the end of the file; empty past it), or -errno: what a read stream reads, a chunk at a time. */
+JSValue js_host_fs_read_at(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
+                           const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    char *path = js_host_path_arg(ctx, argc, argv, 0);
+    if (!path) return JS_EXCEPTION;
+    double position = argc > 1 && js_is_number(argv[1]) ? js_as_number(argv[1]) : 0;
+    double length = argc > 2 && js_is_number(argv[2]) ? js_as_number(argv[2]) : 65536;
+    if (!(length >= 0 && length <= 1 << 30)) length = 65536;
+    uv_fs_t req;
+    int fd = uv_fs_open(uv_default_loop(), &req, path, UV_FS_O_RDONLY, 0, NULL);
+    uv_fs_req_cleanup(&req);
+    free(path);
+    if (fd < 0) return js_int32(fd);
+    char *buf = malloc((size_t)length + 1);
+    if (!buf) js_fatal("out of memory");
+    size_t got = 0;
+    int r = 0;
+    while (got < (size_t)length) {  /* a read may return less than asked before the end */
+        uv_buf_t b = uv_buf_init(buf + got, (unsigned)((size_t)length - got));
+        r = uv_fs_read(uv_default_loop(), &req, fd, &b, 1, (int64_t)position + (int64_t)got, NULL);
+        uv_fs_req_cleanup(&req);
+        if (r <= 0) break;
+        got += (size_t)r;
+    }
+    uv_fs_close(uv_default_loop(), &req, fd, NULL);
+    uv_fs_req_cleanup(&req);
+    JSValue out = r < 0 ? js_int32(r) : js_new_buffer_from_bytes(ctx, (const uint8_t *)buf, got);
+    free(buf);
+    return out;
+}

package/node/src/host_loop.c

@@ -66,15 +66,21 @@ void js_uv_set_flush(void (*fn)(void)) { flush_hook = fn; }
 bool js_uv_call(JSValue fn, uint32_t argc, JSValue *argv, JSValue *result) {
     if (failed) return false;
     JSContext *ctx = loop_ctx;
+    /* under no async context (ADR 0020): the prelude binds a callback to the one it was given in */
+    JSValue saved = js_async_context(ctx);
+    js_set_async_context(ctx, JS_UNDEFINED);
     JSValue r = js_call(ctx, fn, JS_UNDEFINED, argc, argv);
+    js_set_async_context(ctx, saved);
     if (js_is_exception(r)) {
         failed = js_report_uncaught(ctx);
-        if (!failed) failed = 1;
-        uv_stop(loop);
-        return false;
+        if (failed) {
+            uv_stop(loop);
+            return false;
+        }
+        r = JS_UNDEFINED;  /* handled ('uncaughtException'): the program goes on */
     }
     if (js_run_microtasks(ctx) < 0) {
-        failed = 1;
+        failed = ctx->rt->failure;
         uv_stop(loop);
         return false;
     }

package/node/src/host_signal.c

@@ -0,0 +1,70 @@
+/* Host primitives for process's signal events and process.kill (prelude/internal/
+ * process_signals.js), on libuv's signal handles. A watched signal's handle is unref'd: like
+ * Node's, it doesn't keep the program alive.
+ *
+ *   signalStart(signum, cb) → 0 | -errno   cb(signum) from the loop each time the signal arrives
+ *   signalStop(signum)                      the default action again
+ *   processKill(pid, signum) → 0 | -errno */
+#define _POSIX_C_SOURCE 200809L  /* libuv's headers: pthread_rwlock_t */
+#include "js_gc.h"
+#include "js_node.h"
+#include "js_ops.h"
+#include "js_uv.h"
+#include "jscontext.h"
+
+#define PRIMITIVE(fn) \
+    JSValue fn(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target)
+#define UNUSED (void)callee, (void)this_val, (void)new_target
+#define MAX_SIGNAL 65  /* above Linux's SIGRTMAX */
+
+static struct {
+    uv_signal_t handle;
+    bool        open;
+    JSValue     cb;  /* a root once open */
+} watches[MAX_SIGNAL];
+
+static void on_signal(uv_signal_t *handle, int signum) {
+    (void)handle;
+    JSValue arg = js_int32(signum);
+    (void)js_uv_call(watches[signum].cb, 1, &arg, NULL);
+}
+
+static int signal_arg(uint32_t argc, const JSValue *argv) {
+    int signum = argc > 0 && js_is_int32(argv[0]) ? js_as_int32(argv[0]) : 0;
+    return signum > 0 && signum < MAX_SIGNAL ? signum : 0;
+}
+
+PRIMITIVE(js_host_signal_start) {
+    UNUSED;
+    int signum = signal_arg(argc, argv);
+    if (!signum || argc < 2 || !js_is_callable(argv[1])) return js_int32(UV_EINVAL);
+    if (!watches[signum].open) {
+        int r = uv_signal_init(js_uv_loop(ctx), &watches[signum].handle);
+        if (r < 0) return js_int32(r);
+        uv_unref((uv_handle_t *)&watches[signum].handle);
+        watches[signum].cb = JS_UNDEFINED;
+        js_add_root(ctx->rt, &watches[signum].cb);
+        watches[signum].open = true;
+    }
+    int r = uv_signal_start(&watches[signum].handle, on_signal, signum);
+    if (r == 0) watches[signum].cb = argv[1];
+    return js_int32(r);
+}
+
+PRIMITIVE(js_host_signal_stop) {
+    UNUSED;
+    (void)ctx;
+    int signum = signal_arg(argc, argv);
+    if (signum && watches[signum].open) {
+        uv_signal_stop(&watches[signum].handle);
+        watches[signum].cb = JS_UNDEFINED;
+    }
+    return JS_UNDEFINED;
+}
+
+PRIMITIVE(js_host_process_kill) {
+    UNUSED;
+    (void)ctx;
+    if (argc < 2 || !js_is_number(argv[0]) || !js_is_int32(argv[1])) return js_int32(UV_EINVAL);
+    return js_int32(uv_kill((int)js_as_number(argv[0]), js_as_int32(argv[1])));
+}

package/node/src/host_sys.c

@@ -16,6 +16,7 @@
 
 #include "js_exception.h"
 #include "js_jobs.h"
+#include "js_ops.h"
 #include "jsstring.h"
 
 /* Each error by its C errno and its libuv code: the same number on POSIX, but on Windows libuv
@@ -23,6 +24,7 @@
 #define E(name, message) { name, -UV_##name, #name, message }
 static const struct { int code, uv; const char *name, *message; } ERRORS[] = {
     E(EPERM, "operation not permitted"),
+    E(ESRCH, "no such process"),
     E(ENOENT, "no such file or directory"),
     E(EIO, "i/o error"),
     E(EBADF, "bad file descriptor"),
@@ -104,3 +106,51 @@ JSValue js_host_timer_unref(JSContext *ctx, JSValue callee, JSValue this_val, ui
     if (argc < 2 || !js_is_callable(argv[0]) || !js_is_number(argv[1])) return js_throw_type_error(ctx, "timerUnref: (fn, ms) expected");
     return js_int32((int32_t)js_add_timer(ctx, argv[0], js_as_number(argv[1]), true));
 }
+
+/* the id a timer primitive takes: a positive int32, else 0 */
+static uint32_t timer_id(uint32_t argc, const JSValue *argv, uint32_t i) {
+    return i < argc && js_is_int32(argv[i]) && js_as_int32(argv[i]) > 0 ? (uint32_t)js_as_int32(argv[i]) : 0;
+}
+
+/* timerStart(fn, ms, ref, id) → id: fn() once after ms, or at the loop's time when ms < 0 (an
+ * immediate); id restarts that timer (refresh()), 0 starts a new one. node:timers' Timeouts. */
+JSValue js_host_timer_start(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv,
+                            JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    if (argc < 3 || !js_is_callable(argv[0]) || !js_is_number(argv[1])) return js_throw_type_error(ctx, "timerStart: (fn, ms, ref, id) expected");
+    double ms = js_as_number(argv[1]);
+    return js_int32((int32_t)js_timer_start(ctx, argv[0], ms, ms < 0, !js_truthy(argv[2]), timer_id(argc, argv, 3)));
+}
+
+/* asyncContextGet() → the current async context (ADR 0020): undefined, or AsyncLocalStorage's frame */
+JSValue js_host_async_context_get(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv,
+                                  JSValue new_target) {
+    (void)callee, (void)this_val, (void)argc, (void)argv, (void)new_target;
+    return js_async_context(ctx);
+}
+
+/* asyncContextSet(context): what jobs, timers and promise reactions queued from now on carry */
+JSValue js_host_async_context_set(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv,
+                                  JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    js_set_async_context(ctx, argc ? argv[0] : JS_UNDEFINED);
+    return JS_UNDEFINED;
+}
+
+/* timerRef(id, ref): whether a pending timer keeps the program alive */
+JSValue js_host_timer_ref(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv,
+                          JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    uint32_t id = timer_id(argc, argv, 0);
+    if (id) js_timer_set_ref(ctx, id, argc > 1 && js_truthy(argv[1]));
+    return JS_UNDEFINED;
+}
+
+/* timerClear(id) */
+JSValue js_host_timer_clear(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv,
+                            JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    uint32_t id = timer_id(argc, argv, 0);
+    if (id) js_timer_clear(ctx, id);
+    return JS_UNDEFINED;
+}