xbintsc 0.3.81 → 0.5.6

package/runtime/rt_internal.h

@@ -21,8 +21,15 @@
  *    code free of write barriers and makes the first implementation small and
  *    predictable. Replacing it with a precise/conservative collector is an
  *    isolated change behind `xt_alloc` plus root registration.
- *  * Strings are UTF-8. JavaScript measures string length in UTF-16 code
- *    units; `xt_string_length` currently reports code points (see README).
+ *  * Strings are stored as UTF-8 (with lone surrogate halves kept as WTF-8) but
+ *    expose JavaScript's UTF-16 view: `length`, indexing, slicing, searching
+ *    and splitting all count UTF-16 code units. `xt_string_length` is the raw
+ *    byte length (what extensions and I/O need), while
+ *    `xt_string_utf16_length` is the JavaScript `.length`. Concatenation is
+ *    lazy: a `+` between two non-empty strings builds an immutable cons node
+ *    (`flat == NULL`) and the bytes are materialised once, on first
+ *    observation, by `xt_string_bytes`. This keeps `s += x` in a loop linear
+ *    instead of copying the accumulated prefix every iteration.
  *  * Objects use a small linear property list. Fine for the language subset
  *    xbintsc targets today; swap for a hash map when the profile demands it.
  */
@@ -51,6 +58,7 @@
 #define XT_OBJECT_KIND_ERROR 12
 #define XT_OBJECT_KIND_GENERATOR 13
 #define XT_OBJECT_KIND_ITERATOR 14
+#define XT_OBJECT_KIND_ASYNC 15
 
 /* Common header for every heap object. `flags` bit 0 is the collector's mark
  * bit; it is cleared on every surviving object at the end of a sweep. */
@@ -64,11 +72,24 @@ typedef struct xt_header {
 
 #define XT_GC_MARK 0x01u
 
-typedef struct {
+/* A string is either *flat* (`flat` points at `capacity` bytes, the last one
+ * NUL) or a *cons* node (`flat == NULL`, `left`/`right` name the operands).
+ * `length` is the raw UTF-8 byte length; `utf16_length` (cached, 0 means
+ * "not computed yet" and is also the length of the empty string) is the same
+ * text measured in UTF-16 code units, which is what JavaScript observes.
+ * `code_point_count` is the number of Unicode scalar values (used by
+ * `for...of` and `Array.from`). `xt_string_bytes` turns a cons node into a flat
+ * one in place; treat the result as immutable and never write through a pointer
+ * obtained from it. */
+typedef struct xt_string {
   xt_header header;
   uint32_t length;
+  uint32_t utf16_length;
+  uint32_t code_point_count;
   uint32_t capacity;
-  char *data;
+  char *flat;
+  struct xt_string *left;
+  struct xt_string *right;
 } xt_string;
 
 /* Sign-magnitude arbitrary-precision integer; see xt_bigint.c. */
@@ -99,6 +120,10 @@ typedef struct {
   uint8_t frozen;
   uint8_t is_array_base;
   uint16_t reserved2;
+  /* Captured `Error.stack` for XT_OBJECT_KIND_ERROR, XT_UNDEFINED otherwise.
+   * Deliberately not a property: `Object.keys`, `for...in` and JSON.stringify
+   * must not see it, while `error.stack` returns it through `xt_get`. */
+  xt_value error_stack;
 } xt_object;
 
 typedef struct {
@@ -109,6 +134,10 @@ typedef struct {
   /* Named (non-index) properties such as `raw` on template strings or
    * `index`/`input` on RegExp match results, stored in an `xt_object`. */
   xt_value extra;
+  /* The array's [[Prototype]] (`Array.prototype` for ordinary arrays). Arrays
+   * are a distinct allocation kind, so this field is what lets
+   * `Object.getPrototypeOf([])` and `x instanceof <Array alias>` work. */
+  xt_value prototype;
 } xt_array;
 
 typedef struct {
@@ -123,6 +152,13 @@ typedef struct {
   /* Set on generator function objects: calling the closure does not run the
    * body, it creates a suspended generator (see xt_generator.c). */
   uint8_t is_generator;
+  /* Set on `async` function objects: calling the closure starts a coroutine
+   * (see xt_async.c) and immediately returns the promise it resolves. */
+  uint8_t is_async;
+  /* Non-NULL for the first-class value of a built-in constructor ("Array",
+   * "Map", ...). It lets property access resolve the constructor's statics
+   * (`const A = Array; A.isArray(x)`). Points at a static string. */
+  const char *builtin_name;
 } xt_function;
 
 /* Allocation and garbage collection (xt_alloc.c).
@@ -185,12 +221,67 @@ void xt_promise_gc_trace(xt_header *header);
 void xt_promise_gc_release(xt_header *header);
 void xt_generator_gc_trace(xt_header *header);
 void xt_generator_gc_release(xt_header *header);
+void xt_async_gc_trace(xt_header *header);
+void xt_async_gc_release(xt_header *header);
+
+/* Stackful coroutines (xt_coroutine.c). A coroutine owns a private C stack and
+ * switches to it with `ucontext`/fibers; `enter` runs until the body calls
+ * `leave`. Exception frames and GC stack regions are swapped alongside the C
+ * stack. Generators and async functions own one each. */
+typedef struct xt_coroutine xt_coroutine;
+xt_coroutine *xt_coroutine_create(void (*entry)(void *), void *arg);
+void xt_coroutine_enter(xt_coroutine *co);
+void xt_coroutine_leave(xt_coroutine *co);
+void xt_coroutine_gc_trace(xt_coroutine *co);
+void xt_coroutine_release(xt_coroutine *co);
 
 /* Value / string helpers shared across translation units (xt_values.c). */
 xt_string *xt_string_alloc(size_t length);
 xt_string *xt_as_string(xt_value value);
 int32_t xt_string_length(xt_string *s);
 int xt_string_equals(xt_string *a, xt_string *b);
+/* Contiguous UTF-8 bytes of a string, flattening a cons node in place on first
+ * use. The result is NUL-terminated at `s->length`; never write through it. */
+const char *xt_string_bytes(xt_string *s);
+
+/* UTF-8 <-> UTF-16 helpers (xt_values/utf16.inc). Decoding accepts WTF-8, so
+ * lone surrogate halves produced by indexing survive a round trip. */
+uint32_t xt_utf8_decode(const char *data, size_t length, size_t *width);
+size_t xt_utf8_encode(uint32_t code, char *out);
+uint32_t xt_utf8_utf16_length(const char *data, size_t length);
+void xt_utf8_measure(const char *data, size_t length, uint32_t *units, uint32_t *points);
+/* Combine an adjacent WTF-8 high/low surrogate pair into one four-byte
+ * sequence, in place. Returns the resulting byte length. */
+size_t xt_utf8_normalize_surrogates(char *data, size_t length);
+
+/* Publish a manually filled buffer (`xt_string_alloc` + `xt_string_mutable`):
+ * normalises surrogate pairs, records the byte length and caches the UTF-16 and
+ * code-point counts. */
+void xt_string_finish(xt_string *s);
+uint32_t xt_string_utf16_length(xt_string *s);
+uint32_t xt_string_code_point_count(xt_string *s);
+/* UTF-16 code unit at `index`, or -1 when out of range. */
+int32_t xt_string_code_unit(xt_string *s, int32_t index);
+/* Unicode code point beginning at UTF-16 index `index` (combining a surrogate
+ * pair), or -1 when out of range. */
+int32_t xt_string_code_point_at(xt_string *s, int32_t index);
+/* A one-code-unit string (a lone surrogate when `index` points into a pair). */
+xt_value xt_string_unit_value(xt_string *s, int32_t index);
+xt_value xt_string_from_code_point(uint32_t code);
+xt_value xt_string_from_units(const uint16_t *units, size_t count);
+/* Copy UTF-16 range [start, end), splitting a surrogate pair when needed. */
+xt_value xt_string_slice_units(xt_string *s, int32_t start, int32_t end);
+/* Byte offset / UTF-16 index conversions; both clamp to the string bounds. */
+int32_t xt_string_byte_offset(xt_string *s, int32_t unit_index);
+int32_t xt_string_unit_offset(xt_string *s, int32_t byte_offset);
+/* True when `unit_index` sits on a code-point boundary (not between the two
+ * halves of a surrogate pair). */
+int xt_string_is_boundary(xt_string *s, int32_t unit_index);
+/* The `index`-th Unicode code point (for `for...of` and `Array.from`). */
+xt_value xt_string_code_point_value(xt_string *s, int32_t index);
+/* Mutable bytes of a string just created with `xt_string_alloc` (never a cons
+ * node). Used by the constructors that fill a buffer before publishing it. */
+char *xt_string_mutable(xt_string *s);
 int32_t xt_to_int32(xt_value v);
 
 /* ECMAScript number formatting (xt_values.c). */
@@ -277,6 +368,26 @@ xt_value xt_yield_star(xt_value delegate);
 int xt_generator_has_next(xt_value generator);
 xt_value xt_generator_iter_value(xt_value generator);
 
+/* Async coroutines (xt_async.c). Calling an `async` function runs its body on
+ * a coroutine that suspends at a pending `await` and resumes when the awaited
+ * promise settles, so the event loop can make progress in between. */
+#define XT_PROMISE_PENDING 0
+#define XT_PROMISE_FULFILLED 1
+#define XT_PROMISE_REJECTED 2
+xt_value xt_async_call(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv);
+/* Resume `async` with the settlement of the promise it awaited. Called by the
+ * microtask runner when the promise settles. */
+void xt_async_wake(void *async, xt_value value, int rejected);
+/* Create a pending promise / settle an existing one (used by xt_async.c). */
+xt_value xt_promise_create(void);
+void xt_promise_fulfill(xt_value promise, xt_value value);
+void xt_promise_reject_value(xt_value promise, xt_value value);
+/* `-1` when `value` is not a promise, otherwise PENDING / FULFILLED / REJECTED. */
+int xt_promise_state_of(xt_value value);
+xt_value xt_promise_value_of(xt_value value);
+/* Register a coroutine to resume when `promise` settles (it must be pending). */
+void xt_promise_add_async_waiter(xt_value promise, void *async);
+
 /* Exception-frame plumbing shared with the generator runtime. The struct is
  * public so a coroutine can `_setjmp` its own boundary directly (a `setjmp`
  * must run in the frame it returns to, never in a helper). */
@@ -284,6 +395,10 @@ typedef struct xt_try_frame {
   jmp_buf buf;
   struct xt_try_frame *prev;
   xt_value exception;
+  /* Shadow-stack depth when the protected region was entered; restored when
+   * the region is left (normally or through a throw) so frames from unwound
+   * calls do not leak into later stack traces. */
+  int32_t stack_depth;
 } xt_try_frame;
 /* Save a try frame with clang's `_setjmp` built-in.
  *
@@ -300,6 +415,23 @@ typedef struct xt_try_frame {
 void *xt_try_mark(void);
 void xt_try_restore(void *mark);
 
+/* -- shadow call stack and diagnostics (xt_io/exception.inc) --------------- */
+/* Generated code pushes a frame on entry and pops it before returning, so an
+ * Error can capture a JavaScript-level stack without any debug metadata. Frame
+ * strings live in the module's static data and are never freed. */
+void xt_stack_push(const char *name, const char *file, int32_t line);
+void xt_stack_pop(void);
+int32_t xt_stack_depth(void);
+void xt_stack_set_line(int32_t line);
+/* Restore the depth saved by a try frame after unwinding inner calls. */
+void xt_stack_trim(int32_t depth);
+/* Format `Name: message` plus the current frames as an `Error.stack` string. */
+xt_value xt_stack_capture(const char *name, const char *message);
+/* The captured stack of an error object, or XT_UNDEFINED. */
+xt_value xt_error_stack(xt_value error);
+/* Best-effort stack dump on a fatal native signal / unhandled exception. */
+void xt_install_crash_handler(void);
+
 /* -- collection / date / regexp representations --------------------------- */
 typedef struct {
   xt_header header;

package/runtime/xt_alloc.c

@@ -210,6 +210,9 @@ void xt_gc_init(void) {
       g_gc_threshold_pinned = 1;
     }
   }
+  /* A crash is the one case where the JavaScript-level shadow stack is the
+   * most useful thing to print; install the handler once per process. */
+  xt_install_crash_handler();
 }
 
 void xt_gc_arm(void) { g_gc_armed = 1; }
@@ -328,7 +331,16 @@ static void xt_gc_process(xt_header *header) {
   const void *base = (const char *)header + sizeof(xt_header);
 
   switch (header->kind) {
-    case XT_OBJECT_KIND_STRING:
+    case XT_OBJECT_KIND_STRING: {
+      /* A flat string holds bytes only. A cons node is an immutable rope whose
+       * children must stay alive until `xt_string_bytes` materialises it. */
+      xt_string *string = (xt_string *)header;
+      if (string->flat == NULL) {
+        if (string->left) xt_gc_gray_push(&string->left->header);
+        if (string->right) xt_gc_gray_push(&string->right->header);
+      }
+      return;
+    }
     case XT_OBJECT_KIND_BIGINT:
     case XT_OBJECT_KIND_DATE:
       /* Numbers/bytes only: no references to follow. */
@@ -377,6 +389,9 @@ static void xt_gc_process(xt_header *header) {
     case XT_OBJECT_KIND_GENERATOR:
       xt_generator_gc_trace(header);
       return;
+    case XT_OBJECT_KIND_ASYNC:
+      xt_async_gc_trace(header);
+      return;
     default:
       /* Symbols, regexps, iterators and any future kind whose references live
        * inline: the payload scan covers them. */
@@ -392,7 +407,7 @@ static void xt_gc_process(xt_header *header) {
 static void xt_gc_release(xt_header *header) {
   switch (header->kind) {
     case XT_OBJECT_KIND_STRING:
-      free(((xt_string *)header)->data);
+      free(((xt_string *)header)->flat);
       break;
     case XT_OBJECT_KIND_BIGINT:
       free(((xt_bigint *)header)->limbs);
@@ -420,6 +435,9 @@ static void xt_gc_release(xt_header *header) {
     case XT_OBJECT_KIND_GENERATOR:
       xt_generator_gc_release(header);
       break;
+    case XT_OBJECT_KIND_ASYNC:
+      xt_async_gc_release(header);
+      break;
     default:
       break;
   }

package/runtime/xt_async.c

@@ -0,0 +1,197 @@
+/*
+ * xbintsc runtime — real `async` / `await`.
+ *
+ * An `async` function runs its body on a stackful coroutine (the same
+ * machinery generators use, see `xt_coroutine.c`) and immediately returns a
+ * promise. The body runs synchronously until it reaches an `await` whose
+ * operand is still pending; at that point the coroutine suspends and control
+ * returns to the caller, so the program body or the event loop can keep going.
+ * When the awaited promise settles, the promise runtime queues a microtask that
+ * resumes the coroutine exactly where it stopped — because the coroutine keeps
+ * a real C stack, `try`/`finally`, loops and locals all survive the suspension
+ * without a state-machine transform.
+ *
+ * `await` on an already-settled value keeps the historical fast path: it
+ * returns (or throws) synchronously instead of forcing a microtask turn. This
+ * makes the common "await a synchronous builtin" case cheap and preserves the
+ * existing ordering guarantees.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct xt_async {
+  xt_header header;
+  xt_value function;
+  xt_value this_value;
+  xt_value *args;
+  int32_t argc;
+  /* Promise returned to the caller and settled when the body finishes. */
+  xt_value promise;
+  /* Completion value, or the exception that escaped the body. */
+  xt_value value;
+  /* Values handed over by the waiter and consumed by `xt_await`. */
+  xt_value resume_value;
+  int await_threw;
+  int done;
+  int threw;
+  xt_coroutine *coroutine;
+} xt_async;
+
+/* The async coroutine currently running on its private stack, if any. It is
+ * only reachable through this pointer while it runs, so it is a GC root. */
+static xt_async *g_active_async = NULL;
+
+static void xt_async_gc_register(void);
+
+/* Runs on the coroutine's private stack and never returns normally: it
+ * suspends back to the resumer once the body has completed. */
+static void xt_async_run(void *arg) {
+  xt_async *async = (xt_async *)arg;
+  void *boundary = xt_try_enter();
+  if (xt_try_setjmp(boundary) == 0) {
+    xt_function *function = (xt_function *)XT_GET_PTR(async->function);
+    async->value = function->code(async->this_value, async->function, async->argc, async->args);
+    async->threw = 0;
+  } else {
+    /* `throw` inside the body (not caught by a `try`) rejects the promise. */
+    async->value = xt_try_exception(boundary);
+    async->threw = 1;
+  }
+  async->done = 1;
+  xt_coroutine_leave(async->coroutine);
+}
+
+/* Switch onto the coroutine. It either suspends at an `await` or completes. */
+static void xt_async_resume(xt_async *async) {
+  xt_async *previous = g_active_async;
+  g_active_async = async;
+  xt_coroutine_enter(async->coroutine);
+  g_active_async = previous;
+  if (!async->done) return;
+  xt_coroutine_release(async->coroutine);
+  async->coroutine = NULL;
+  if (async->threw) xt_promise_reject_value(async->promise, async->value);
+  else xt_promise_fulfill(async->promise, async->value);
+}
+
+xt_value xt_async_call(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv) {
+  xt_async *async = (xt_async *)xt_alloc(sizeof(xt_async), XT_OBJECT_KIND_ASYNC);
+  async->function = function;
+  async->this_value = thisValue;
+  async->argc = argc;
+  async->args = NULL;
+  if (argc > 0 && argv) {
+    async->args = (xt_value *)malloc(sizeof(xt_value) * (size_t)argc);
+    if (!async->args) abort();
+    memcpy(async->args, argv, sizeof(xt_value) * (size_t)argc);
+  }
+  async->promise = xt_promise_create();
+  async->value = XT_UNDEFINED;
+  async->resume_value = XT_UNDEFINED;
+  async->await_threw = 0;
+  async->done = 0;
+  async->threw = 0;
+  async->coroutine = xt_coroutine_create(xt_async_run, async);
+  xt_async_gc_register();
+  /* Start synchronously, matching JavaScript: the body runs up to its first
+   * pending `await` before the call returns. */
+  xt_async_resume(async);
+  return async->promise;
+}
+
+void xt_async_wake(void *asyncPointer, xt_value value, int rejected) {
+  xt_async *async = (xt_async *)asyncPointer;
+  if (!async || async->done || !async->coroutine) return;
+  async->resume_value = value;
+  async->await_threw = rejected;
+  xt_async_resume(async);
+}
+
+/* `await value`: unwrap promises, suspending the running async coroutine when
+ * the promise is still pending. */
+xt_value xt_await(xt_value value) {
+  int state = xt_promise_state_of(value);
+  if (state < 0) return value;
+  if (state == XT_PROMISE_REJECTED) {
+    xt_throw(xt_promise_value_of(value));
+    return XT_UNDEFINED;
+  }
+  if (state == XT_PROMISE_FULFILLED) return xt_promise_value_of(value);
+
+  xt_async *async = g_active_async;
+  if (async && async->coroutine) {
+    async->await_threw = 0;
+    async->resume_value = XT_UNDEFINED;
+    xt_promise_add_async_waiter(value, async);
+    xt_coroutine_leave(async->coroutine);
+    /* The waiter resumed us. A rejection is rethrown inside the coroutine so
+     * its own `try`/`catch` and `finally` see it. */
+    if (async->await_threw) {
+      async->await_threw = 0;
+      xt_throw(async->resume_value);
+      return XT_UNDEFINED;
+    }
+    return async->resume_value;
+  }
+
+  /* No coroutine to suspend (top-level `await`, or `await` reached outside an
+   * async function): block on the reactor until the promise settles, exactly
+   * like a synchronous embedder waiting for the event loop. The loop returns
+   * immediately when no work remains, so a promise nothing can settle does not
+   * hang the process here. */
+  for (int guard = 0; guard < 100000; guard++) {
+    xt_drain_microtasks();
+    state = xt_promise_state_of(value);
+    if (state != XT_PROMISE_PENDING) break;
+    if (!xt_loop_has_work()) break;
+    if (xt_loop_poll(-1) < 0) break;
+  }
+  state = xt_promise_state_of(value);
+  if (state == XT_PROMISE_REJECTED) {
+    xt_throw(xt_promise_value_of(value));
+    return XT_UNDEFINED;
+  }
+  return state == XT_PROMISE_FULFILLED ? xt_promise_value_of(value) : XT_UNDEFINED;
+}
+
+/* While a coroutine runs, the async object is only reachable through this
+ * static pointer. */
+static void xt_async_gc_scan_roots(void) {
+  if (!g_active_async) return;
+  xt_gc_mark_header((xt_header *)g_active_async);
+}
+
+static void xt_async_gc_register(void) {
+  static int registered = 0;
+  if (registered) return;
+  registered = 1;
+  xt_gc_register_root_provider(xt_async_gc_scan_roots);
+}
+
+void xt_async_gc_trace(xt_header *header) {
+  xt_async *async = (xt_async *)header;
+  xt_gc_mark_value(async->function);
+  xt_gc_mark_value(async->this_value);
+  xt_gc_mark_value(async->promise);
+  xt_gc_mark_value(async->value);
+  xt_gc_mark_value(async->resume_value);
+  if (async->args && async->argc > 0) {
+    xt_gc_scan_region(async->args, sizeof(xt_value) * (size_t)async->argc);
+  }
+  xt_coroutine_gc_trace(async->coroutine);
+}
+
+void xt_async_gc_release(xt_header *header) {
+  xt_async *async = (xt_async *)header;
+  free(async->args);
+  xt_coroutine_release(async->coroutine);
+  async->coroutine = NULL;
+}
+
+xt_value xt_function_set_async(xt_value value) {
+  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_async = 1;
+  return value;
+}

package/runtime/xt_bigint/conversions.inc

@@ -41,7 +41,7 @@ static xt_value bi_from_xt_value(xt_value value) {
   if (XT_IS_NUMBER(value)) return xt_bigint_from_double(xt_to_double(value));
   if (XT_IS_STRING(value)) {
     xt_string *s = xt_as_string(value);
-    return xt_bigint_from_string(s->data, s->length);
+    return xt_bigint_from_string(xt_string_bytes(s), s->length);
   }
   if (value == XT_TRUE) return xt_bigint_from_i64(1);
   if (value == XT_FALSE) return xt_bigint_from_i64(0);