xbintsc 0.3.87 → 0.5.20

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);
     }
   }
@@ -146,8 +179,120 @@ static void xt_inspect(xt_value v, FILE *out, int nested) {
     xt_inspect_pop();
     return;
   }
+  int typedKind = xt_typed_array_kind_of(v);
+  if (typedKind >= 0) {
+    const char *name = xt_typed_array_name_of(typedKind);
+    uint32_t length = (uint32_t)xt_to_number(xt_get(v, xt_string_from_cstr("length")));
+    fprintf(out, "%s(%u) [", name ? name : "TypedArray", length);
+    for (uint32_t i = 0; i < length; i++) {
+      fputs(i == 0 ? " " : ", ", out);
+      xt_inspect(xt_typed_array_read(v, i), out, 1);
+    }
+    if (length > 0) fputc(' ', out);
+    fputc(']', out);
+    return;
+  }
   if (XT_IS_OBJECT(v)) {
     xt_object *obj = (xt_object *)XT_GET_PTR(v);
+    /* Map, Set, Date, RegExp, Promise, generators and iterators are heap
+     * objects with their own struct layouts, so treating them as `xt_object`
+     * and reading `count`/`properties` reads unrelated memory (it used to
+     * crash on a non-empty Map). Format each kind from its real fields. */
+    switch (obj->header.kind) {
+      case XT_OBJECT_KIND_MAP: {
+        xt_map *map = (xt_map *)obj;
+        int seenMap = xt_inspect_seen(map);
+        if (seenMap > 0) {
+          fprintf(out, "[Circular *%d]", seenMap);
+          return;
+        }
+        if (xt_inspect_depth >= XT_INSPECT_MAX_DEPTH) {
+          fputs("[Map]", out);
+          return;
+        }
+        xt_inspect_push(map);
+        fprintf(out, "Map(%u) {", map->count);
+        for (uint32_t i = 0; i < map->count; i++) {
+          fputs(i == 0 ? " " : ", ", out);
+          xt_inspect(map->keys[i], out, 1);
+          fputs(" => ", out);
+          xt_inspect(map->values[i], out, 1);
+        }
+        if (map->count > 0) fputc(' ', out);
+        fputc('}', out);
+        xt_inspect_pop();
+        return;
+      }
+      case XT_OBJECT_KIND_SET: {
+        xt_set_object *set = (xt_set_object *)obj;
+        int seenSet = xt_inspect_seen(set);
+        if (seenSet > 0) {
+          fprintf(out, "[Circular *%d]", seenSet);
+          return;
+        }
+        if (xt_inspect_depth >= XT_INSPECT_MAX_DEPTH) {
+          fputs("[Set]", out);
+          return;
+        }
+        xt_inspect_push(set);
+        fprintf(out, "Set(%u) {", set->count);
+        for (uint32_t i = 0; i < set->count; i++) {
+          fputs(i == 0 ? " " : ", ", out);
+          xt_inspect(set->values[i], out, 1);
+        }
+        if (set->count > 0) fputc(' ', out);
+        fputc('}', out);
+        xt_inspect_pop();
+        return;
+      }
+      case XT_OBJECT_KIND_DATE: {
+        /* `Date.prototype.toISOString` is the representation Node prints. */
+        xt_value text = xt_call_method(v, xt_string_from_cstr("toISOString"), 0, NULL);
+        xt_inspect(text, out, 0);
+        return;
+      }
+      case XT_OBJECT_KIND_REGEXP: {
+        xt_regexp *regexp = (xt_regexp *)obj;
+        fputc('/', out);
+        xt_inspect(regexp->source, out, 0);
+        fputc('/', out);
+        xt_inspect(regexp->flags, out, 0);
+        return;
+      }
+      case XT_OBJECT_KIND_PROMISE: {
+        int state = xt_promise_state_of(v);
+        fputs("Promise { ", out);
+        if (state == XT_PROMISE_PENDING) {
+          fputs("<pending>", out);
+        } else {
+          if (state == XT_PROMISE_REJECTED) fputs("<rejected> ", out);
+          xt_inspect(xt_promise_value_of(v), out, 1);
+        }
+        fputs(" }", out);
+        return;
+      }
+      case XT_OBJECT_KIND_WEAK_MAP:
+        fputs("WeakMap { <items unknown> }", out);
+        return;
+      case XT_OBJECT_KIND_WEAK_SET:
+        fputs("WeakSet { <items unknown> }", out);
+        return;
+      case XT_OBJECT_KIND_WEAK_REF:
+        fputs("WeakRef {}", out);
+        return;
+      case XT_OBJECT_KIND_GENERATOR:
+        fputs("Object [Generator] {}", out);
+        return;
+      case XT_OBJECT_KIND_ITERATOR:
+      case XT_OBJECT_KIND_ASYNC:
+        /* Internal helper objects have no useful user-visible shape. */
+        fputs("[object Object]", out);
+        return;
+      default:
+        /* XT_OBJECT_KIND_OBJECT and XT_OBJECT_KIND_ERROR share the property
+         * bag layout and fall through to the generic formatter below. */
+        break;
+    }
     int seen = xt_inspect_seen(obj);
     if (seen > 0) {
       fprintf(out, "[Circular *%d]", seen);

package/runtime/xt_loop.c

@@ -88,8 +88,23 @@ static int64_t xt_loop_now_ms(void) {
 #endif
 }
 
-static void xt_loop_sleep_ms(int ms) {
-  if (ms <= 0) return;
+/* Fractional monotonic milliseconds for `performance.now()`. Kept separate from
+ * xt_loop_now_ms(), which only needs whole milliseconds for timer deadlines. */
+double xt_monotonic_ms(void) {
+#if defined(_WIN32)
+  static LARGE_INTEGER frequency;
+  if (frequency.QuadPart == 0) QueryPerformanceFrequency(&frequency);
+  LARGE_INTEGER counter;
+  QueryPerformanceCounter(&counter);
+  return (double)counter.QuadPart * 1000.0 / (double)frequency.QuadPart;
+#else
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1000000.0;
+#endif
+}
+
+static void xt_loop_sleep_ms(int ms) {  if (ms <= 0) return;
 #if defined(_WIN32)
   Sleep((DWORD)ms);
 #else
@@ -228,7 +243,7 @@ static void xt_timer_run_due(void) {
 xt_value xt_set_timeout(int32_t argc, xt_value *argv) {
   xt_value callback = xt_arg_at(argc, argv, 0);
   if (!XT_IS_FUNCTION(callback)) {
-    xt_throw(xt_string_from_cstr("TypeError: The \"callback\" argument must be of type function"));
+    xt_throw(xt_error_from_message("TypeError: The \"callback\" argument must be of type function"));
     return XT_UNDEFINED;
   }
   int64_t delay = xt_timer_delay_arg(xt_arg_at(argc, argv, 1));
@@ -240,7 +255,7 @@ xt_value xt_set_timeout(int32_t argc, xt_value *argv) {
 xt_value xt_set_interval(int32_t argc, xt_value *argv) {
   xt_value callback = xt_arg_at(argc, argv, 0);
   if (!XT_IS_FUNCTION(callback)) {
-    xt_throw(xt_string_from_cstr("TypeError: The \"callback\" argument must be of type function"));
+    xt_throw(xt_error_from_message("TypeError: The \"callback\" argument must be of type function"));
     return XT_UNDEFINED;
   }
   int64_t delay = xt_timer_delay_arg(xt_arg_at(argc, argv, 1));
@@ -263,6 +278,22 @@ xt_value xt_clear_interval(int32_t argc, xt_value *argv) {
   return XT_UNDEFINED;
 }
 
+xt_value xt_set_immediate(int32_t argc, xt_value *argv) {
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) {
+    xt_value message = xt_string_from_cstr("The \"callback\" argument must be of type function");
+    xt_throw(xt_type_error_ctor(1, &message));
+    return XT_UNDEFINED;
+  }
+  int32_t extra = argc > 1 ? argc - 1 : 0;
+  uint64_t id = xt_timer_add(callback, 0, 0, extra, extra > 0 ? argv + 1 : NULL);
+  return xt_number((double)id);
+}
+
+xt_value xt_clear_immediate(int32_t argc, xt_value *argv) {
+  return xt_clear_timeout(argc, argv);
+}
+
 int xt_loop_add(int fd, int events, xt_io_handler handler, void *userdata) {
   if (fd < 0 || !handler) return -1;
   xt_loop_gc_register();

package/runtime/xt_performance.c

@@ -0,0 +1,37 @@
+/*
+ * xbintsc runtime — `performance.now()`.
+ *
+ * The namespace is dispatched two ways: `performance.now()` lowers to
+ * xt_performance_call(name, argc, argv), while reading the method as a value
+ * (`const now = performance.now`) goes through xt_performance_get(name), which
+ * returns a closure with the standard ABI. Both read the same monotonic clock.
+ */
+
+#include "rt_internal.h"
+
+#include <string.h>
+
+static xt_value xt_performance_now_value(xt_value thisValue, xt_value env, int32_t argc,
+                                         xt_value *argv) {
+  (void)thisValue;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_number(xt_monotonic_ms());
+}
+
+xt_value xt_performance_get(xt_value name) {
+  const char *key = xt_string_data(name);
+  if (key != NULL && strcmp(key, "now") == 0) {
+    return xt_closure_new((void *)xt_performance_now_value, 0, NULL);
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_performance_call(xt_value name, int32_t argc, xt_value *argv) {
+  (void)argc;
+  (void)argv;
+  const char *key = xt_string_data(name);
+  if (key != NULL && strcmp(key, "now") == 0) return xt_number(xt_monotonic_ms());
+  return XT_UNDEFINED;
+}

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,63 @@ 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()); }
+
+/* Queue a microtask that resumes a suspended async coroutine with an already
+ * settled value. Reusing a reaction keeps FIFO order with pending `.then`
+ * callbacks (the specification always yields once per `await`). */
+void xt_promise_queue_async_wake(void *asyncPointer, xt_value settled, int rejected) {
+  xt_promise *promise = xt_promise_new();
+  promise->state = rejected ? XT_PROMISE_REJECTED : XT_PROMISE_FULFILLED;
+  promise->value = settled;
+  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 = asyncPointer;
+  xt_microtask_push(reaction);
+}
+
+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 ------------------------------------------ */
@@ -243,9 +304,34 @@ xt_value xt_promise_reject(xt_value value) {
   return xt_promise_value(promise);
 }
 
+static xt_value xt_promise_with_resolvers_resolve(xt_value thisValue, xt_value env, int32_t argc,
+                                                  xt_value *argv) {
+  (void)thisValue;
+  xt_promise_fulfill(xt_closure_env(env, 0), xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+static xt_value xt_promise_with_resolvers_reject(xt_value thisValue, xt_value env, int32_t argc,
+                                                 xt_value *argv) {
+  (void)thisValue;
+  xt_promise_reject_value(xt_closure_env(env, 0), xt_arg_at(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
 xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
   const char *fn = xt_string_data(name);
   if (!fn) return XT_UNDEFINED;
+  if (strcmp(fn, "withResolvers") == 0) {
+    xt_value promise = xt_promise_create();
+    xt_value environment[1] = {promise};
+    xt_value result = xt_object_new();
+    xt_object_set(result, xt_string_from_cstr("promise"), promise);
+    xt_object_set(result, xt_string_from_cstr("resolve"),
+                  xt_closure_new((void *)xt_promise_with_resolvers_resolve, 1, environment));
+    xt_object_set(result, xt_string_from_cstr("reject"),
+                  xt_closure_new((void *)xt_promise_with_resolvers_reject, 1, environment));
+    return result;
+  }
   if (strcmp(fn, "resolve") == 0) return xt_promise_resolve(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "reject") == 0) return xt_promise_reject(xt_arg_at(argc, argv, 0));
   if (strcmp(fn, "all") == 0 || strcmp(fn, "allSettled") == 0 || strcmp(fn, "race") == 0 || strcmp(fn, "any") == 0) {
@@ -277,7 +363,12 @@ xt_value xt_promise_static(xt_value name, int32_t argc, xt_value *argv) {
           xt_promise_settle(result, XT_PROMISE_REJECTED, inner->value);
           return xt_promise_value(result);
         }
-        xt_value settled = xt_await(item);
+        xt_value settled;
+        if (xt_promise_state_of(item) == XT_PROMISE_FULFILLED) {
+          settled = xt_promise_value_of(item);
+        } else {
+          settled = xt_await(item);
+        }
         if (strcmp(fn, "any") == 0 || strcmp(fn, "race") == 0) {
           xt_promise_settle(result, XT_PROMISE_FULFILLED, settled);
           return xt_promise_value(result);
@@ -316,6 +407,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;
@@ -341,3 +433,18 @@ xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt
   *handled = 0;
   return XT_UNDEFINED;
 }
+
+xt_value xt_queue_microtask(int32_t argc, xt_value *argv) {
+  xt_value callback = xt_arg_at(argc, argv, 0);
+  if (!XT_IS_FUNCTION(callback)) {
+    xt_value message = xt_string_from_cstr("The \"callback\" argument must be of type function");
+    xt_throw(xt_type_error_ctor(1, &message));
+    return XT_UNDEFINED;
+  }
+  /* Reuse the promise reaction queue: a settled promise's `then` callback is
+   * exactly a microtask, and it keeps FIFO order with pending `.then`s. */
+  xt_value promise = xt_promise_resolve(XT_UNDEFINED);
+  int handled = 0;
+  xt_promise_method(promise, "then", 1, &callback, &handled);
+  return XT_UNDEFINED;
+}

package/runtime/xt_stdlib/arrays.inc

@@ -150,7 +150,7 @@ static xt_value xt_array_reduce(xt_value value, xt_value fn, int32_t hasInitial,
     accumulator = array->items[0];
     i = 1;
   } else {
-    xt_throw(xt_string_from_cstr("TypeError: Reduce of empty array with no initial value"));
+    xt_throw(xt_error_from_message("TypeError: Reduce of empty array with no initial value"));
     return XT_UNDEFINED;
   }
   for (; i < array->length; i++) {