xbintsc 0.3.12 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xbintsc",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "xbintsc - a TypeScript binary compiler (TypeScript -> LLVM IR -> native binary)",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:e2e": "vitest run tests/e2e",
-    "coverage": "vitest run --coverage"
+    "coverage": "vitest run --coverage",
+    "coverage:runtime": "tsx scripts/coverage-runtime.ts"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.5",

package/runtime/ext_node/buffer/parts/prototype.inc

@@ -52,3 +52,10 @@ unsigned char *xt_node_buffer_bytes(xt_value value, size_t *outLength) {
   *outLength = length;
   return bytes;
 }
+
+/* Cross-module helpers used by the fs module to fill/read Buffer objects. */
+uint32_t xt_node_buffer_length(xt_value value) { return xt_buffer_length(value); }
+
+void xt_node_buffer_set(xt_value value, uint32_t index, unsigned char byte) {
+  xt_buffer_put(value, index, byte);
+}

package/runtime/ext_node/buffer/parts/search.inc

@@ -1,12 +1,14 @@
 /* -- search --------------------------------------------------------------- */
 
 static const unsigned char *xt_buffer_search_needle(xt_value value, const char *encoding, size_t *length,
-                                                     unsigned char *single) {
+                                                     unsigned char *single, int *heapAllocated) {
   if (XT_IS_NUMBER(value)) {
     *single = (unsigned char)((int32_t)xt_to_number(value) & 0xff);
     *length = 1;
+    *heapAllocated = 0;
     return single;
   }
+  *heapAllocated = 1;
   if (xt_buffer_is(value)) {
     uint32_t n = xt_buffer_length(value);
     unsigned char *bytes = (unsigned char *)malloc(n ? n : 1);
@@ -28,13 +30,15 @@ static xt_value xt_buffer_method_index_of(xt_value thisValue, xt_value env, int3
   const char *encoding = argc > 2 ? xt_node_encoding(argv[2]) : NULL;
   size_t needleLength = 0;
   unsigned char single = 0;
-  const unsigned char *needle = xt_buffer_search_needle(xt_arg_at(argc, argv, 0), encoding, &needleLength, &single);
+  int needleOnHeap = 0;
+  const unsigned char *needle =
+      xt_buffer_search_needle(xt_arg_at(argc, argv, 0), encoding, &needleLength, &single, &needleOnHeap);
   uint32_t length = xt_buffer_length(thisValue);
   int32_t start = argc > 1 ? (int32_t)xt_to_number(argv[1]) : (reverse ? (int32_t)length - 1 : 0);
   if (start < 0) start += (int32_t)length;
   if (start < 0) start = 0;
   if (needleLength == 0 || needleLength > length) {
-    if (!xt_buffer_is(xt_arg_at(argc, argv, 0))) free((void *)needle);
+    if (needleOnHeap) free((void *)needle);
     return xt_number(-1);
   }
   int found = -1;
@@ -68,7 +72,7 @@ static xt_value xt_buffer_method_index_of(xt_value thisValue, xt_value env, int3
       }
     }
   }
-  if (!xt_buffer_is(xt_arg_at(argc, argv, 0))) free((void *)needle);
+  if (needleOnHeap) free((void *)needle);
   return xt_number((double)found);
 }
 

package/runtime/ext_node/child_process/child_process.c

@@ -112,6 +112,11 @@ xt_value xt_child_process_spawn_sync(int32_t argc, xt_value *argv) {
     return make_result(-1, "", "could not create temporary files");
   }
 
+  /* Flush anything the parent has already buffered on stdout/stderr before
+   * redirecting the descriptors; otherwise that pending output would be
+   * flushed into the child's capture file (and lost from the real stdout). */
+  fflush(stdout);
+  fflush(stderr);
   int saved_out = _dup(_fileno(stdout));
   int saved_err = _dup(_fileno(stderr));
   _dup2(_fileno(out_file), _fileno(stdout));

package/runtime/ext_node/fs/constants.c

@@ -0,0 +1,113 @@
+/*
+ * `fs.constants` for xbintsc.
+ *
+ * The numeric values mirror the host platform's `<fcntl.h>` / `<sys/stat.h>`
+ * (which is what Node reports on that platform). Constants a platform does not
+ * define are omitted rather than faked.
+ */
+
+#include "../node_common.h"
+#include "fs_common.h"
+
+#include <sys/stat.h>
+
+#if defined(_WIN32)
+#include <fcntl.h>
+#endif
+
+#ifndef F_OK
+#define F_OK 0
+#endif
+#ifndef R_OK
+#define R_OK 4
+#endif
+#ifndef W_OK
+#define W_OK 2
+#endif
+#ifndef X_OK
+#define X_OK 1
+#endif
+
+#define XT_FS_CONST(name, value) xt_object_set(object, xt_string_from_cstr(name), xt_number((double)(value)))
+
+xt_value xt_fs_constants(void) {
+  xt_value object = xt_object_new();
+
+  XT_FS_CONST("F_OK", F_OK);
+  XT_FS_CONST("R_OK", R_OK);
+  XT_FS_CONST("W_OK", W_OK);
+  XT_FS_CONST("X_OK", X_OK);
+
+  XT_FS_CONST("COPYFILE_EXCL", 1);
+  XT_FS_CONST("COPYFILE_FICLONE", 2);
+  XT_FS_CONST("COPYFILE_FICLONE_FORCE", 4);
+
+#ifdef O_RDONLY
+  XT_FS_CONST("O_RDONLY", O_RDONLY);
+#endif
+#ifdef O_WRONLY
+  XT_FS_CONST("O_WRONLY", O_WRONLY);
+#endif
+#ifdef O_RDWR
+  XT_FS_CONST("O_RDWR", O_RDWR);
+#endif
+#ifdef O_CREAT
+  XT_FS_CONST("O_CREAT", O_CREAT);
+#elif defined(_O_CREAT)
+  XT_FS_CONST("O_CREAT", _O_CREAT);
+#endif
+#ifdef O_EXCL
+  XT_FS_CONST("O_EXCL", O_EXCL);
+#elif defined(_O_EXCL)
+  XT_FS_CONST("O_EXCL", _O_EXCL);
+#endif
+#ifdef O_TRUNC
+  XT_FS_CONST("O_TRUNC", O_TRUNC);
+#elif defined(_O_TRUNC)
+  XT_FS_CONST("O_TRUNC", _O_TRUNC);
+#endif
+#ifdef O_APPEND
+  XT_FS_CONST("O_APPEND", O_APPEND);
+#elif defined(_O_APPEND)
+  XT_FS_CONST("O_APPEND", _O_APPEND);
+#endif
+#ifdef O_NOCTTY
+  XT_FS_CONST("O_NOCTTY", O_NOCTTY);
+#endif
+#ifdef O_DIRECTORY
+  XT_FS_CONST("O_DIRECTORY", O_DIRECTORY);
+#endif
+#ifdef O_NOFOLLOW
+  XT_FS_CONST("O_NOFOLLOW", O_NOFOLLOW);
+#endif
+#ifdef O_SYNC
+  XT_FS_CONST("O_SYNC", O_SYNC);
+#endif
+#ifdef O_DSYNC
+  XT_FS_CONST("O_DSYNC", O_DSYNC);
+#endif
+#ifdef O_NONBLOCK
+  XT_FS_CONST("O_NONBLOCK", O_NONBLOCK);
+#endif
+#ifdef O_SYMLINK
+  XT_FS_CONST("O_SYMLINK", O_SYMLINK);
+#endif
+
+#if defined(_WIN32)
+  XT_FS_CONST("S_IFMT", _S_IFMT);
+  XT_FS_CONST("S_IFREG", _S_IFREG);
+  XT_FS_CONST("S_IFDIR", _S_IFDIR);
+  XT_FS_CONST("S_IFCHR", _S_IFCHR);
+#else
+  XT_FS_CONST("S_IFMT", S_IFMT);
+  XT_FS_CONST("S_IFREG", S_IFREG);
+  XT_FS_CONST("S_IFDIR", S_IFDIR);
+  XT_FS_CONST("S_IFCHR", S_IFCHR);
+  XT_FS_CONST("S_IFBLK", S_IFBLK);
+  XT_FS_CONST("S_IFIFO", S_IFIFO);
+  XT_FS_CONST("S_IFLNK", S_IFLNK);
+  XT_FS_CONST("S_IFSOCK", S_IFSOCK);
+#endif
+
+  return object;
+}

package/runtime/ext_node/fs/copy_ops.c

@@ -0,0 +1,145 @@
+/*
+ * Node.js `fs.cpSync` for xbintsc.
+ *
+ * Copies files, symbolic links and (with `recursive: true`) directories.
+ * Supported options: `recursive`, `force`, `errorOnExist`, `dereference`,
+ * `preserveTimestamps`. Other Node options are ignored (documented).
+ */
+
+#include "../node_common.h"
+#include "fs_common.h"
+
+#if !defined(_WIN32)
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+static int xt_fs_option_bool(xt_value options, const char *key, int fallback) {
+  if (!XT_IS_OBJECT(options)) return fallback;
+  xt_value value = xt_object_get_cstr(options, key);
+  if (XT_IS_UNDEFINED(value) || XT_IS_NULL(value)) return fallback;
+  return xt_truthy(value);
+}
+
+static void xt_fs_copy_file_bytes(const char *from, const char *to) {
+  FILE *source = fopen(from, "rb");
+  if (!source) {
+    xt_fs_error("open", from);
+    return;
+  }
+  FILE *destination = fopen(to, "wb");
+  if (!destination) {
+    fclose(source);
+    xt_fs_error("open", to);
+    return;
+  }
+  char buffer[8192];
+  size_t read;
+  while ((read = fread(buffer, 1, sizeof(buffer), source)) > 0) fwrite(buffer, 1, read, destination);
+  fclose(source);
+  fclose(destination);
+}
+
+static char *xt_fs_join(const char *dir, const char *name) {
+  size_t size = strlen(dir) + strlen(name) + 2;
+  char *path = (char *)malloc(size);
+  if (!path) return NULL;
+  snprintf(path, size, "%s/%s", dir, name);
+  return path;
+}
+
+static void xt_fs_copy_any(const char *src, const char *dest, xt_value options, int recursive) {
+  xt_fs_stat_t info;
+  if (xt_fs_lstat_fn(src, &info) != 0) {
+    xt_fs_raise_path("lstat", src);
+    return;
+  }
+  int force = xt_fs_option_bool(options, "force", 1);
+  int errorOnExist = xt_fs_option_bool(options, "errorOnExist", 0);
+  int dereference = xt_fs_option_bool(options, "dereference", 0);
+
+  if (S_ISDIR(info.st_mode)) {
+    if (!recursive) {
+      xt_fs_raise_errno(EISDIR, "cp", src);
+      return;
+    }
+    if (xt_fs_mkdir_mode(dest, (int)(info.st_mode & 0777)) != 0 && errno != EEXIST) {
+      xt_fs_raise_path("mkdir", dest);
+      return;
+    }
+    xt_fs_dir dir;
+    if (!xt_fs_dir_open(&dir, src)) {
+      xt_fs_error("open directory", src);
+      return;
+    }
+    while (xt_fs_dir_next(&dir)) {
+      const char *name = xt_fs_dir_name(&dir);
+      if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
+      char *childSrc = xt_fs_join(src, name);
+      char *childDest = xt_fs_join(dest, name);
+      if (childSrc && childDest) xt_fs_copy_any(childSrc, childDest, options, recursive);
+      free(childSrc);
+      free(childDest);
+    }
+    xt_fs_dir_close(&dir);
+    return;
+  }
+
+  if (xt_fs_access(dest, F_OK) == 0) {
+    if (!force) {
+      if (errorOnExist) xt_fs_raise_errno(EEXIST, "cp", dest);
+      return;
+    }
+  }
+
+#if !defined(_WIN32)
+  if (S_ISLNK(info.st_mode) && !dereference) {
+    size_t capacity = 256;
+    for (;;) {
+      char *target = (char *)malloc(capacity);
+      if (!target) return;
+      ssize_t length = readlink(src, target, capacity);
+      if (length < 0) {
+        free(target);
+        xt_fs_raise_path("readlink", src);
+        return;
+      }
+      if ((size_t)length < capacity) {
+        target[length] = '\0';
+        if (symlink(target, dest) != 0) xt_fs_raise_path("symlink", dest);
+        free(target);
+        return;
+      }
+      free(target);
+      capacity *= 2;
+    }
+  }
+#endif
+
+  xt_fs_copy_file_bytes(src, dest);
+
+  if (xt_fs_option_bool(options, "preserveTimestamps", 0)) {
+#if !defined(_WIN32)
+    struct timeval times[2];
+    times[0].tv_sec = info.st_atime;
+    times[0].tv_usec = 0;
+    times[1].tv_sec = info.st_mtime;
+    times[1].tv_usec = 0;
+    utimes(dest, times);
+#endif
+  }
+}
+
+xt_value xt_node_cp(int32_t argc, xt_value *argv) {
+  if (argc < 2) return xt_undefined();
+  const char *src = xt_node_cstr(argv[0]);
+  const char *dest = xt_node_cstr(argv[1]);
+  if (!src || !dest) {
+    xt_fs_raise_errno(EINVAL, "cp", NULL);
+    return xt_undefined();
+  }
+  xt_value options = argc > 2 ? argv[2] : XT_UNDEFINED;
+  int recursive = xt_fs_option_bool(options, "recursive", 0);
+  xt_fs_copy_any(src, dest, options, recursive);
+  return xt_undefined();
+}

package/runtime/ext_node/fs/dir.c

@@ -0,0 +1,101 @@
+/*
+ * `fs.opendirSync` / the `Dir` object for xbintsc.
+ *
+ * The runtime has no asynchronous thread pool, so `read`/`close` invoke their
+ * callbacks immediately (Node would defer them). `readSync`/`closeSync` are the
+ * fully synchronous equivalents. `Dir` is a plain object (there is no shared
+ * `Dir` prototype yet), so `dir instanceof Dir` is not supported.
+ */
+
+#include "../node_common.h"
+#include "fs_common.h"
+
+static xt_fs_dir *xt_fs_dir_handle(xt_value thisValue) {
+  xt_value handle = xt_object_get_cstr(thisValue, "__xt_dir");
+  return (xt_fs_dir *)(uintptr_t)xt_to_number(handle);
+}
+
+static xt_value xt_fs_dir_read_entry(xt_value thisValue) {
+  xt_fs_dir *dir = xt_fs_dir_handle(thisValue);
+  if (!dir) return xt_null();
+  const char *path = xt_node_cstr(xt_object_get_cstr(thisValue, "path"));
+  while (xt_fs_dir_next(dir)) {
+    const char *name = xt_fs_dir_name(dir);
+    if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
+    return xt_node_dirent_result(path ? path : "", name);
+  }
+  return xt_null();
+}
+
+static xt_value xt_fs_dir_read_sync(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_fs_dir_read_entry(thisValue);
+}
+
+static xt_value xt_fs_dir_close_sync(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_fs_dir *dir = xt_fs_dir_handle(thisValue);
+  if (dir) {
+    xt_fs_dir_close(dir);
+    free(dir);
+    xt_object_set(thisValue, xt_string_from_cstr("__xt_dir"), xt_number(0));
+  }
+  return xt_undefined();
+}
+
+static xt_value xt_fs_dir_read_async(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value callback = xt_arg(argc, argv, 0);
+  xt_value dirent = xt_fs_dir_read_entry(thisValue);
+  if (XT_IS_FUNCTION(callback)) {
+    xt_value args[2];
+    args[0] = xt_null();
+    args[1] = dirent;
+    xt_call_with_this(callback, xt_undefined(), 2, args);
+  }
+  return xt_undefined();
+}
+
+static xt_value xt_fs_dir_close_async(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value callback = xt_arg(argc, argv, 0);
+  xt_fs_dir_close_sync(thisValue, env, 0, NULL);
+  if (XT_IS_FUNCTION(callback)) {
+    xt_value args[1];
+    args[0] = xt_null();
+    xt_call_with_this(callback, xt_undefined(), 1, args);
+  }
+  return xt_undefined();
+}
+
+xt_value xt_node_opendir(int32_t argc, xt_value *argv) {
+  if (argc < 1) return xt_undefined();
+  const char *path = xt_node_cstr(argv[0]);
+  if (!path) {
+    xt_fs_raise_errno(EINVAL, "opendir", NULL);
+    return xt_undefined();
+  }
+  xt_fs_dir *dir = (xt_fs_dir *)malloc(sizeof(xt_fs_dir));
+  if (!dir) {
+    xt_fs_raise_errno(ENOMEM, "opendir", path);
+    return xt_undefined();
+  }
+  if (!xt_fs_dir_open(dir, path)) {
+    free(dir);
+    xt_fs_error("open directory", path);
+    return xt_undefined();
+  }
+
+  xt_value object = xt_object_new();
+  xt_node_set(object, "path", xt_string_from_cstr(path));
+  xt_node_set(object, "__xt_dir", xt_number((double)(uintptr_t)dir));
+  xt_node_define_method(object, "readSync", (void *)xt_fs_dir_read_sync);
+  xt_node_define_method(object, "closeSync", (void *)xt_fs_dir_close_sync);
+  xt_node_define_method(object, "read", (void *)xt_fs_dir_read_async);
+  xt_node_define_method(object, "close", (void *)xt_fs_dir_close_async);
+  return object;
+}