xbintsc 0.3.87 → 0.5.6

package/runtime/xt_generator.c

@@ -8,28 +8,17 @@
  * `finally` and nested loops work across suspension points without a state
  * machine transform.
  *
- * POSIX uses `ucontext` (`swapcontext`); Windows uses fibers. The generator's
- * exception stack is swapped alongside it so a `throw` inside the body still
- * targets the body's own `try` frames.
+ * The private stack and the context switch come from `xt_coroutine.c`, which
+ * `async` functions use as well. The generator's exception stack is swapped
+ * alongside it so a `throw` inside the body still targets the body's own
+ * `try` frames.
  */
 
-#define _XOPEN_SOURCE 700
-
 #include "rt_internal.h"
 
 #include <stdlib.h>
 #include <string.h>
 
-#if defined(__APPLE__)
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <ucontext.h>
-#endif
-
 typedef struct xt_generator {
   xt_header header;
   xt_value function;
@@ -44,35 +33,13 @@ typedef struct xt_generator {
   int started;
   int done;
   int threw;
-  int booted;
-  /* Private stack bounds, registered as an active stack region while the
-   * generator runs and scanned conservatively while it is suspended. */
-  char *stack;
-  size_t stack_size;
-  int stack_pushed;
-  void *saved_try_top;
-#ifdef _WIN32
-  void *fiber;
-  void *caller_fiber;
-  /* `SwitchToFiber` keeps the resumer's callee-saved registers in an opaque
-   * fiber context (POSIX stores them in `caller`), so snapshot them for the
-   * collector before switching away. */
-  jmp_buf caller_regs;
-  int has_caller_regs;
-#else
-  ucontext_t ctx;
-  ucontext_t caller;
-#endif
+  /* Private stack, context switch and GC region bookkeeping live in
+   * xt_coroutine.c; `NULL` once the body has finished. */
+  xt_coroutine *coroutine;
 } xt_generator;
 
 /* The generator whose coroutine is running, if any. */
 static xt_generator *g_active_generator = NULL;
-/* Filled in just before a coroutine is first entered (POSIX has no portable
- * way to pass a pointer to `makecontext`). */
-static xt_generator *g_boot_generator = NULL;
-#ifdef _WIN32
-static void *g_main_fiber = NULL;
-#endif
 
 int xt_is_generator(xt_value value) {
   if (!XT_IS_OBJECT(value)) return 0;
@@ -91,38 +58,9 @@ static xt_value xt_generator_result_object(xt_value value, int done) {
   return result;
 }
 
-static void xt_generator_suspend(xt_generator *gen) {
-  gen->saved_try_top = xt_try_mark();
-#ifdef _WIN32
-  SwitchToFiber(gen->caller_fiber);
-#else
-  swapcontext(&gen->ctx, &gen->caller);
-#endif
-}
-
 /* Runs on the generator's private stack. */
-static void xt_generator_run(xt_generator *gen) {
-#ifdef _WIN32
-  /* The fiber stack is not observable from the outside; capture its bounds
-   * here (before the body allocates anything) so a collection during the body
-   * has a valid scan region. */
-  if (!gen->stack) {
-    MEMORY_BASIC_INFORMATION info;
-    uintptr_t here = (uintptr_t)&info;
-    if (VirtualQuery((LPCVOID)here, &info, sizeof(info))) {
-      /* Use the *committed* region containing the current frame: a Windows
-       * stack reserves more than it commits, and `AllocationBase + RegionSize`
-       * can fall in uncommitted memory. `BaseAddress + RegionSize` is the
-       * stack top. */
-      gen->stack = (char *)info.BaseAddress;
-      gen->stack_size = info.RegionSize;
-    }
-  }
-#endif
-  if (gen->stack && gen->stack_size && !gen->stack_pushed) {
-    xt_gc_push_stack((uintptr_t)gen->stack, (uintptr_t)gen->stack + gen->stack_size);
-    gen->stack_pushed = 1;
-  }
+static void xt_generator_run(void *arg) {
+  xt_generator *gen = (xt_generator *)arg;
   void *boundary = xt_try_enter();
   if (xt_try_setjmp(boundary) == 0) {
     xt_function *function = (xt_function *)XT_GET_PTR(gen->function);
@@ -133,90 +71,23 @@ static void xt_generator_run(xt_generator *gen) {
     gen->threw = 1;
   }
   gen->done = 1;
-  xt_generator_suspend(gen);
-}
-
-#ifndef _WIN32
-static void xt_generator_entry(void) {
-  xt_generator *gen = g_boot_generator;
-  g_boot_generator = NULL;
-  xt_generator_run(gen);
-}
-#else
-static void CALLBACK xt_generator_entry(void *param) {
-  xt_generator_run((xt_generator *)param);
-}
-#endif
-
-static void xt_generator_boot(xt_generator *gen) {
-#ifdef _WIN32
-  if (!g_main_fiber) g_main_fiber = ConvertThreadToFiber(NULL);
-  gen->fiber = CreateFiber(1 << 20, xt_generator_entry, gen);
-  if (!gen->fiber) abort();
-#else
-  size_t size = 1 << 20;
-  gen->stack = (char *)malloc(size);
-  if (!gen->stack) abort();
-  gen->stack_size = size;
-  if (getcontext(&gen->ctx) != 0) abort();
-  gen->ctx.uc_stack.ss_sp = gen->stack;
-  gen->ctx.uc_stack.ss_size = size;
-  gen->ctx.uc_link = NULL;
-  g_boot_generator = gen;
-  makecontext(&gen->ctx, xt_generator_entry, 0);
-#endif
-  gen->booted = 1;
+  xt_coroutine_leave(gen->coroutine);
 }
 
 /* Release the private stack once the coroutine has finished. The generator
  * object itself stays valid; later `.next()` calls just report `done`. */
 static void xt_generator_dispose(xt_generator *gen) {
-#ifdef _WIN32
-  if (gen->fiber) {
-    DeleteFiber(gen->fiber);
-    gen->fiber = NULL;
-  }
-  gen->caller_fiber = NULL;
-  /* `DeleteFiber` releases the stack: never scan it again. */
-  gen->stack = NULL;
-  gen->stack_size = 0;
-#else
-  if (gen->stack) {
-    free(gen->stack);
-    gen->stack = NULL;
-  }
-#endif
+  xt_coroutine_release(gen->coroutine);
+  gen->coroutine = NULL;
 }
 
+static void xt_generator_boot(xt_generator *gen);
+
 static void xt_generator_resume(xt_generator *gen) {
-  if (!gen->booted) xt_generator_boot(gen);
+  if (!gen->coroutine) xt_generator_boot(gen);
   xt_generator *previous = g_active_generator;
   g_active_generator = gen;
-  /* Record where the current (calling) stack suspends before switching away.
-   * On Windows the first push happens inside the fiber once its stack bounds
-   * are known, so the caller's region must be marked suspended here, on the
-   * caller's own stack. */
-  xt_gc_suspend((uintptr_t)&gen);
-  if (gen->stack && gen->stack_size && !gen->stack_pushed) {
-    xt_gc_push_stack((uintptr_t)gen->stack, (uintptr_t)gen->stack + gen->stack_size);
-    gen->stack_pushed = 1;
-  }
-  void *caller_try = xt_try_mark();
-  xt_try_restore(gen->saved_try_top);
-#ifdef _WIN32
-  _setjmp(gen->caller_regs);
-  gen->has_caller_regs = 1;
-  gen->caller_fiber = GetCurrentFiber();
-  SwitchToFiber(gen->fiber);
-#else
-  swapcontext(&gen->caller, &gen->ctx);
-#endif
-  gen->saved_try_top = xt_try_mark();
-  xt_try_restore(caller_try);
-  if (gen->stack_pushed) {
-    xt_gc_pop_stack();
-    gen->stack_pushed = 0;
-  }
+  xt_coroutine_enter(gen->coroutine);
   if (gen->done) xt_generator_dispose(gen);
   g_active_generator = previous;
 }
@@ -242,23 +113,18 @@ void xt_generator_gc_trace(xt_header *header) {
   if (gen->args && gen->argc > 0) {
     xt_gc_scan_region(gen->args, sizeof(xt_value) * (size_t)gen->argc);
   }
-  if (gen->stack && gen->stack_size) xt_gc_scan_region(gen->stack, gen->stack_size);
-#ifndef _WIN32
-  /* Registers saved by `swapcontext` at the last yield are not on the stack. */
-  xt_gc_scan_region(&gen->ctx, sizeof(gen->ctx));
-#else
-  if (gen->has_caller_regs) xt_gc_scan_region(&gen->caller_regs, sizeof(gen->caller_regs));
-#endif
+  xt_coroutine_gc_trace(gen->coroutine);
 }
 
 void xt_generator_gc_release(xt_header *header) {
   xt_generator *gen = (xt_generator *)header;
   free(gen->args);
-#ifdef _WIN32
-  if (gen->fiber) DeleteFiber(gen->fiber);
-#else
-  free(gen->stack);
-#endif
+  xt_coroutine_release(gen->coroutine);
+  gen->coroutine = NULL;
+}
+
+static void xt_generator_boot(xt_generator *gen) {
+  gen->coroutine = xt_coroutine_create(xt_generator_run, gen);
 }
 
 xt_value xt_generator_new(xt_value function, xt_value thisValue, int32_t argc, xt_value *argv) {
@@ -267,9 +133,7 @@ xt_value xt_generator_new(xt_value function, xt_value thisValue, int32_t argc, x
   gen->this_value = thisValue;
   gen->argc = argc;
   gen->args = NULL;
-  gen->stack = NULL;
-  gen->stack_size = 0;
-  gen->stack_pushed = 0;
+  gen->coroutine = NULL;
   gen->result = XT_UNDEFINED;
   gen->sent = XT_UNDEFINED;
   gen->iter_value = XT_UNDEFINED;
@@ -339,7 +203,7 @@ xt_value xt_yield(xt_value value) {
   xt_generator *gen = g_active_generator;
   if (!gen || gen->done) return XT_UNDEFINED;
   gen->result = value;
-  xt_generator_suspend(gen);
+  xt_coroutine_leave(gen->coroutine);
   if (gen->resume_kind == 1) {
     xt_throw(gen->sent);
     return XT_UNDEFINED;
@@ -348,7 +212,7 @@ xt_value xt_yield(xt_value value) {
     gen->done = 1;
     gen->threw = 0;
     gen->result = gen->sent;
-    xt_generator_suspend(gen);
+    xt_coroutine_leave(gen->coroutine);
     return XT_UNDEFINED;
   }
   return gen->sent;
@@ -396,3 +260,8 @@ xt_value xt_generator_iter_value(xt_value generator) {
   xt_generator *gen = xt_as_generator(generator);
   return gen ? gen->iter_value : XT_UNDEFINED;
 }
+
+xt_value xt_function_set_generator(xt_value value) {
+  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->is_generator = 1;
+  return value;
+}

package/runtime/xt_io/inspect.inc

@@ -2,15 +2,36 @@
 /* Output and inspection                                                     */
 /* ------------------------------------------------------------------------- */
 
+/* Write UTF-8 bytes, turning a lone surrogate half (WTF-8) into U+FFFD. Node's
+ * terminal encoding does the same, so `console.log("😀"[0])` prints one
+ * replacement character instead of emitting invalid UTF-8. */
+static void xt_print_utf8(FILE *out, const char *bytes, size_t length) {
+  size_t offset = 0;
+  while (offset < length) {
+    unsigned char c = (unsigned char)bytes[offset];
+    if (c == 0xED && offset + 2 < length) {
+      unsigned char second = (unsigned char)bytes[offset + 1];
+      unsigned char third = (unsigned char)bytes[offset + 2];
+      if (second >= 0xA0 && second <= 0xBF && third >= 0x80 && third <= 0xBF) {
+        fwrite("\xEF\xBF\xBD", 1, 3, out);
+        offset += 3;
+        continue;
+      }
+    }
+    fputc((int)c, out);
+    offset++;
+  }
+}
+
 static void xt_print_value(xt_value v, FILE *out) {
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    fwrite(xt_string_bytes(s), 1, s->length, out);
+    xt_print_utf8(out, xt_string_bytes(s), s->length);
     return;
   }
   xt_value text = xt_to_string(v);
   xt_string *s = xt_as_string(text);
-  fwrite(xt_string_bytes(s), 1, s->length, out);
+  xt_print_utf8(out, xt_string_bytes(s), s->length);
 }
 
 void xt_print(xt_value v) { xt_print_value(v, stdout); }
@@ -83,6 +104,18 @@ static void xt_inspect_string(xt_string *s, FILE *out) {
       default:
         if (c == (unsigned char)quote) { fputc('\\', out); fputc(c, out); }
         else if (c < 0x20) fprintf(out, "\\x%02x", c);
+        else if (c == 0xED && i + 2 < s->length) {
+          unsigned char second = (unsigned char)bytes[i + 1];
+          unsigned char third = (unsigned char)bytes[i + 2];
+          if (second >= 0xA0 && second <= 0xBF && third >= 0x80 && third <= 0xBF) {
+            unsigned code = ((unsigned)(c & 0x0F) << 12) | ((unsigned)(second & 0x3F) << 6) |
+                            (unsigned)(third & 0x3F);
+            fprintf(out, "\\u%04x", code);
+            i += 2;
+          } else {
+            fputc(c, out);
+          }
+        }
         else fputc(c, out);
     }
   }

package/runtime/xt_promise.c

@@ -1,10 +1,12 @@
 /*
- * xbintsc runtime — promises and async support.
+ * xbintsc runtime — promises and the microtask queue.
  *
- * There is no event loop in the runtime, so promises use a microtask queue
- * that the compiler drains when the program body finishes (and that `await`
- * drains on demand). This gives synchronous-looking `async`/`await` semantics
- * for the common case where every awaited value is already settled.
+ * Promise reactions are queued as microtasks and run when the program body
+ * finishes, by the event loop between callbacks, and on demand. `await` lives
+ * in `xt_async.c`: an `async` function runs on a coroutine, so awaiting a
+ * promise that is still pending suspends it and registers a waiter here. When
+ * the promise settles, the waiter becomes a microtask that resumes the
+ * coroutine. Everything is single-threaded and non-blocking.
  */
 
 #include "rt_internal.h"
@@ -12,10 +14,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define XT_PROMISE_PENDING 0
-#define XT_PROMISE_FULFILLED 1
-#define XT_PROMISE_REJECTED 2
-
 typedef struct xt_promise xt_promise;
 
 typedef struct {
@@ -23,6 +21,9 @@ typedef struct {
   xt_value on_fulfilled;
   xt_value on_rejected;
   xt_promise *result;
+  /* Non-NULL for an `async` coroutine waiting on this promise. Such a reaction
+   * has no handlers: running it resumes the coroutine instead. */
+  void *async;
 } xt_reaction;
 
 struct xt_promise {
@@ -87,6 +88,7 @@ static void xt_promise_gc_scan_roots(void) {
     xt_gc_mark_value(reaction->on_fulfilled);
     xt_gc_mark_value(reaction->on_rejected);
     xt_gc_mark_header((xt_header *)reaction->result);
+    if (reaction->async) xt_gc_mark_header((xt_header *)reaction->async);
   }
 }
 
@@ -107,6 +109,7 @@ void xt_promise_gc_trace(xt_header *header) {
     xt_gc_mark_value(reaction->on_fulfilled);
     xt_gc_mark_value(reaction->on_rejected);
     xt_gc_mark_header((xt_header *)reaction->result);
+    if (reaction->async) xt_gc_mark_header((xt_header *)reaction->async);
   }
 }
 
@@ -133,6 +136,7 @@ static void xt_promise_resolve_into(xt_promise *result, xt_value value) {
     reaction->on_fulfilled = XT_UNDEFINED;
     reaction->on_rejected = XT_UNDEFINED;
     reaction->result = result;
+    reaction->async = NULL;
     if (other->reaction_count >= other->reaction_capacity) {
       other->reaction_capacity = other->reaction_capacity == 0 ? 4 : other->reaction_capacity * 2;
       other->reactions = (xt_reaction **)realloc(other->reactions, sizeof(xt_reaction *) * other->reaction_capacity);
@@ -156,6 +160,16 @@ static xt_value xt_promise_run_reactions(void) {
   while (xt_microtask_head < xt_microtask_count) {
     xt_reaction *reaction = xt_microtasks[xt_microtask_head++];
     xt_promise *promise = reaction->promise;
+    if (reaction->async) {
+      /* A suspended `async` coroutine: resume it with the settled value. It
+       * runs until it completes or awaits another pending promise. */
+      void *async = reaction->async;
+      int rejected = promise->state == XT_PROMISE_REJECTED;
+      xt_value settled = promise->value;
+      free(reaction);
+      xt_async_wake(async, settled, rejected);
+      continue;
+    }
     xt_value handler = promise->state == XT_PROMISE_FULFILLED ? reaction->on_fulfilled : reaction->on_rejected;
     if (XT_IS_FUNCTION(handler)) {
       xt_value arg = promise->value;
@@ -181,16 +195,46 @@ void xt_drain_microtasks(void) {
   }
 }
 
-xt_value xt_await(xt_value value) {
+/* -- helpers used by the async coroutine runtime -------------------------- */
+
+xt_value xt_promise_create(void) { return xt_promise_value(xt_promise_new()); }
+
+void xt_promise_fulfill(xt_value promise, xt_value value) {
+  xt_promise *target = xt_as_promise(promise);
+  if (target) xt_promise_resolve_into(target, value);
+}
+
+void xt_promise_reject_value(xt_value promise, xt_value value) {
+  xt_promise *target = xt_as_promise(promise);
+  if (target) xt_promise_settle(target, XT_PROMISE_REJECTED, value);
+}
+
+int xt_promise_state_of(xt_value value) {
   xt_promise *promise = xt_as_promise(value);
-  if (!promise) return value;
-  int guard = 0;
-  while (promise->state == XT_PROMISE_PENDING && guard++ < 100000) xt_drain_microtasks();
-  if (promise->state == XT_PROMISE_REJECTED) {
-    xt_throw(promise->value);
-    return XT_UNDEFINED;
+  return promise ? promise->state : -1;
+}
+
+xt_value xt_promise_value_of(xt_value value) {
+  xt_promise *promise = xt_as_promise(value);
+  return promise ? promise->value : value;
+}
+
+void xt_promise_add_async_waiter(xt_value promiseValue, void *async) {
+  xt_promise *promise = xt_as_promise(promiseValue);
+  if (!promise || promise->state != XT_PROMISE_PENDING) return;
+  xt_reaction *reaction = (xt_reaction *)malloc(sizeof(xt_reaction));
+  if (!reaction) abort();
+  reaction->promise = promise;
+  reaction->on_fulfilled = XT_UNDEFINED;
+  reaction->on_rejected = XT_UNDEFINED;
+  reaction->result = NULL;
+  reaction->async = async;
+  if (promise->reaction_count >= promise->reaction_capacity) {
+    promise->reaction_capacity = promise->reaction_capacity == 0 ? 4 : promise->reaction_capacity * 2;
+    promise->reactions = (xt_reaction **)realloc(promise->reactions, sizeof(xt_reaction *) * promise->reaction_capacity);
+    if (!promise->reactions) abort();
   }
-  return promise->value;
+  promise->reactions[promise->reaction_count++] = reaction;
 }
 
 /* -- C-callable resolve / reject ------------------------------------------ */
@@ -316,6 +360,7 @@ xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt
     reaction->on_fulfilled = xt_arg_at(argc, argv, 0);
     reaction->on_rejected = xt_arg_at(argc, argv, 1);
     reaction->result = result;
+    reaction->async = NULL;
     if (promise->state == XT_PROMISE_PENDING) {
       if (promise->reaction_count >= promise->reaction_capacity) {
         promise->reaction_capacity = promise->reaction_capacity == 0 ? 4 : promise->reaction_capacity * 2;

package/runtime/xt_stdlib/dispatch.inc

@@ -40,6 +40,7 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   *handled = 1;
   if (strcmp(method, "charAt") == 0) return xt_string_char_at(target, xt_arg_at(argc, argv, 0));
   if (strcmp(method, "charCodeAt") == 0) return xt_string_char_code_at(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "codePointAt") == 0) return xt_string_code_point_at_value(target, xt_arg_at(argc, argv, 0));
   if (strcmp(method, "indexOf") == 0) return xt_string_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "includes") == 0) return xt_bool(xt_truthy(xt_ne(xt_string_index_of(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1)), xt_number(-1))));
   if (strcmp(method, "slice") == 0) return xt_string_slice(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
@@ -51,8 +52,8 @@ static xt_value xt_string_method(xt_value target, const char *method, int32_t ar
   if (strcmp(method, "trim") == 0) return xt_string_trim(target);
   if (strcmp(method, "replace") == 0) return xt_string_replace(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "repeat") == 0) return xt_string_repeat(target, xt_arg_at(argc, argv, 0));
-  if (strcmp(method, "startsWith") == 0) return xt_string_starts_with(target, xt_arg_at(argc, argv, 0));
-  if (strcmp(method, "endsWith") == 0) return xt_string_ends_with(target, xt_arg_at(argc, argv, 0));
+  if (strcmp(method, "startsWith") == 0) return xt_string_starts_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
+  if (strcmp(method, "endsWith") == 0) return xt_string_ends_with(target, xt_arg_at(argc, argv, 0), xt_arg_at(argc, argv, 1));
   if (strcmp(method, "concat") == 0) return xt_string_concat_args(target, argc, argv);
   *handled = 0;
   return XT_UNDEFINED;
@@ -286,11 +287,19 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     if (kind != XT_OBJECT_KIND_OBJECT && kind != XT_OBJECT_KIND_FUNCTION) {
       xt_value result = xt_ext_container_method(target, method, argc, argv, &handled);
       if (handled) return result;
+      /* Containers keep their methods in dedicated C dispatch tables, but
+       * still inherit `Object.prototype` (`new Map().toString()`). */
+      xt_value inherited = xt_get(target, name);
+      if (XT_IS_FUNCTION(inherited)) return xt_call_with_this(inherited, target, argc, argv);
     }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
     xt_value result = xt_ext_object_method(target, method, argc, argv, &handled);
     if (handled) return result;
+    /* Inherited Object.prototype methods on containers without a property bag
+     * (`new Map().toString()`, ...). */
+    xt_value inherited = xt_get(target, name);
+    if (XT_IS_FUNCTION(inherited)) return xt_call_with_this(inherited, target, argc, argv);
     {
       char message[256];
       snprintf(message, sizeof(message), "TypeError: object has no callable method '%s'", method);
@@ -333,6 +342,13 @@ xt_value xt_call_method(xt_value target, xt_value name, int32_t argc, xt_value *
     }
     xt_value fn = xt_object_get(target, name);
     if (XT_IS_FUNCTION(fn)) return xt_call_with_this(fn, target, argc, argv);
+    /* Statics of a first-class built-in constructor (`const A = Array;
+     * A.isArray(x)`). */
+    xt_value builtinStatic = xt_builtin_static_value(target, name);
+    if (builtinStatic != XT_UNDEFINED) {
+      if (XT_IS_FUNCTION(builtinStatic)) return xt_call_with_this(builtinStatic, target, argc, argv);
+      return builtinStatic;
+    }
     if (strcmp(method, "toString") == 0) {
       /* Source text is not retained; report a native-style representation. */
       xt_function *self = (xt_function *)XT_GET_PTR(target);