xbintsc 0.3.87 → 0.5.20

package/runtime/xt_array_buffer.c

@@ -0,0 +1,284 @@
+/*
+ * xbintsc runtime — ArrayBuffer and DataView.
+ *
+ * An ArrayBuffer is a plain object holding its bytes as an array of numbers
+ * under a private symbol, plus a public `byteLength`. A DataView is another
+ * plain object that points at the buffer and exposes the get/set accessors;
+ * every accessor assembles the bytes explicitly, so the default big-endian
+ * order and the optional `littleEndian` argument follow ECMAScript.
+ *
+ * Keeping both as ordinary objects means the garbage collector, property
+ * lookup and the rest of the runtime need no new object kind. Typed arrays
+ * are buffer-backed views over this object and share its bytes; `new
+ * Uint8Array(buffer, offset, length)`, `.buffer` and `subarray` are handled by
+ * xt_typed_array.c.
+ */
+
+#include "rt_internal.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+static xt_value xt_ab_data_key_value = XT_UNDEFINED;
+
+static xt_value xt_ab_data_key(void) {
+  /* A symbol key keeps the backing bytes out of Object.keys / JSON.stringify,
+   * like the platform's internal [[ArrayBufferData]] slot. */
+  if (!xt_is_symbol(xt_ab_data_key_value)) {
+    xt_ab_data_key_value = xt_symbol_new(xt_string_from_cstr("__arrayBufferData"));
+    xt_gc_add_root(&xt_ab_data_key_value);
+  }
+  return xt_ab_data_key_value;
+}
+
+static xt_value xt_ab_data(xt_value buffer) {  if (!XT_IS_OBJECT(buffer)) return XT_UNDEFINED;
+  return xt_object_get(buffer, xt_ab_data_key());
+}
+
+static int xt_ab_is_buffer(xt_value value) {
+  return XT_IS_ARRAY(xt_ab_data(value));
+}
+
+static xt_value xt_ab_new(uint32_t length) {
+  xt_value buffer = xt_object_new();
+  xt_object_set(buffer, xt_string_from_cstr("byteLength"), xt_number((double)length));
+  xt_value data = xt_array_new(0, NULL);
+  for (uint32_t i = 0; i < length; i++) xt_array_push(data, xt_number(0));
+  xt_object_set(buffer, xt_ab_data_key(), data);
+  return buffer;
+}
+
+static xt_value xt_ab_slice(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv);
+static void xt_ab_install(xt_value object, const char *name, void *fn);
+
+xt_value xt_array_buffer_ctor(int32_t argc, xt_value *argv) {
+  double length = xt_to_number(xt_arg_at(argc, argv, 0));
+  if (!(length >= 0) || length > 4294967295.0) length = 0;
+  xt_value buffer = xt_ab_new((uint32_t)length);
+  xt_ab_install(buffer, "slice", (void *)xt_ab_slice);
+  return buffer;
+}
+
+int xt_is_array_buffer(xt_value value) { return xt_ab_is_buffer(value); }
+
+uint32_t xt_array_buffer_byte_length(xt_value value) {
+  if (!xt_ab_is_buffer(value)) return 0;
+  return (uint32_t)xt_to_number(xt_get(value, xt_string_from_cstr("byteLength")));
+}
+
+uint8_t xt_array_buffer_get_byte(xt_value buffer, uint32_t index) {
+  xt_value data = xt_ab_data(buffer);
+  if (!XT_IS_ARRAY(data)) return 0;
+  return (uint8_t)xt_to_int32(xt_get(data, xt_number((double)index)));
+}
+
+void xt_array_buffer_set_byte(xt_value buffer, uint32_t index, uint8_t value) {
+  xt_value data = xt_ab_data(buffer);
+  if (!XT_IS_ARRAY(data)) return;
+  xt_set(data, xt_number((double)index), xt_number((double)value));
+}
+
+static xt_value xt_ab_slice(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  xt_value data = xt_ab_data(thisValue);
+  if (!XT_IS_ARRAY(data)) return xt_ab_new(0);
+  int32_t length = xt_to_int32(xt_array_length(data));
+  int32_t start = argc > 0 && argv[0] != XT_UNDEFINED ? xt_to_int32(argv[0]) : 0;
+  int32_t end = argc > 1 && argv[1] != XT_UNDEFINED ? xt_to_int32(argv[1]) : length;
+  if (start < 0) start += length;
+  if (end < 0) end += length;
+  if (start < 0) start = 0;
+  if (end > length) end = length;
+  if (end < start) end = start;
+  xt_value result = xt_ab_new(0);
+  xt_ab_install(result, "slice", (void *)xt_ab_slice);
+  xt_value source = xt_ab_data(result);
+  for (int32_t i = start; i < end; i++) xt_array_push(source, xt_get(data, xt_number((double)i)));
+  xt_object_set(result, xt_string_from_cstr("byteLength"), xt_number((double)(end - start)));
+  return result;
+}
+
+static void xt_ab_install(xt_value object, const char *name, void *fn) {
+  xt_object_set(object, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
+}
+
+xt_value xt_array_buffer_static(xt_value name, int32_t argc, xt_value *argv) {
+  const char *method = xt_string_data(name);
+  if (!method) return XT_UNDEFINED;
+  if (strcmp(method, "isView") == 0) {
+    xt_value value = xt_arg_at(argc, argv, 0);
+    if (xt_typed_array_kind_of(value) >= 0) return XT_TRUE;
+    if (!XT_IS_OBJECT(value)) return XT_FALSE;
+    if (((xt_object *)XT_GET_PTR(value))->header.kind != XT_OBJECT_KIND_OBJECT) return XT_FALSE;
+    xt_value buffer = xt_object_get(value, xt_string_from_cstr("buffer"));
+    return xt_bool(xt_ab_is_buffer(buffer) &&
+                   xt_object_get(value, xt_string_from_cstr("byteLength")) != XT_UNDEFINED);
+  }
+  return XT_UNDEFINED;
+}
+
+/* -- DataView ------------------------------------------------------------- */
+
+enum {
+  XT_DV_U8,
+  XT_DV_I8,
+  XT_DV_U16,
+  XT_DV_I16,
+  XT_DV_U32,
+  XT_DV_I32,
+  XT_DV_F32,
+  XT_DV_F64,
+};
+
+static uint32_t xt_dv_width(int kind) {
+  switch (kind) {
+    case XT_DV_U8:
+    case XT_DV_I8:
+      return 1;
+    case XT_DV_U16:
+    case XT_DV_I16:
+      return 2;
+    case XT_DV_U32:
+    case XT_DV_I32:
+    case XT_DV_F32:
+      return 4;
+    default:
+      return 8;
+  }
+}
+
+static int xt_dv_signed(int kind) {
+  return kind == XT_DV_I8 || kind == XT_DV_I16 || kind == XT_DV_I32;
+}
+
+static xt_value xt_dv_data(xt_value view) {
+  return xt_ab_data(xt_get(view, xt_string_from_cstr("buffer")));
+}
+
+static uint32_t xt_dv_offset(xt_value view) {
+  return (uint32_t)xt_to_number(xt_get(view, xt_string_from_cstr("byteOffset")));
+}
+
+static uint32_t xt_dv_length(xt_value view) {
+  return (uint32_t)xt_to_number(xt_get(view, xt_string_from_cstr("byteLength")));
+}
+
+static int xt_dv_check(xt_value view, xt_value indexValue, uint32_t width, uint32_t *out) {
+  double raw = xt_to_number(indexValue);
+  if (!(raw >= 0)) raw = -1;
+  int64_t index = (int64_t)raw;
+  if (index < 0 || (uint64_t)index + width > xt_dv_length(view)) {
+    xt_value message = xt_string_from_cstr("Offset is outside the bounds of the DataView");
+    xt_throw(xt_range_error_ctor(1, &message));
+  }
+  *out = xt_dv_offset(view) + (uint32_t)index;
+  return 1;
+}
+
+static uint64_t xt_dv_read_bits(xt_value view, uint32_t offset, uint32_t width, int little) {
+  xt_value data = xt_dv_data(view);
+  uint64_t value = 0;
+  for (uint32_t i = 0; i < width; i++) {
+    uint32_t index = little ? offset + width - 1 - i : offset + i;
+    uint64_t byte = (uint64_t)xt_to_number(xt_get(data, xt_number((double)index)));
+    value = (value << 8) | (byte & 0xff);
+  }
+  return value;
+}
+
+static void xt_dv_write_bits(xt_value view, uint32_t offset, uint32_t width, uint64_t value,
+                             int little) {
+  xt_value data = xt_dv_data(view);
+  for (uint32_t i = 0; i < width; i++) {
+    uint32_t shift = little ? i * 8 : (width - 1 - i) * 8;
+    uint32_t index = offset + i;
+    xt_set(data, xt_number((double)index), xt_number((double)((value >> shift) & 0xff)));
+  }
+}
+
+static xt_value xt_dv_method(xt_value thisValue, xt_value env, int32_t argc, xt_value *argv) {
+  int kind = (int)xt_to_number(xt_closure_env(env, 0));
+  int setter = (int)xt_to_number(xt_closure_env(env, 1));
+  uint32_t width = xt_dv_width(kind);
+  uint32_t offset = 0;
+  xt_dv_check(thisValue, xt_arg_at(argc, argv, 0), width, &offset);
+  int little = argc > (setter ? 2 : 1) && xt_truthy(xt_arg_at(argc, argv, setter ? 2 : 1));
+  if (setter) {
+    double value = xt_to_number(xt_arg_at(argc, argv, 1));
+    uint64_t bits;
+    if (kind == XT_DV_F32) {
+      float narrowed = (float)value;
+      uint32_t raw;
+      memcpy(&raw, &narrowed, sizeof(raw));
+      bits = raw;
+    } else if (kind == XT_DV_F64) {
+      double raw = value;
+      memcpy(&bits, &raw, sizeof(bits));
+    } else if (kind == XT_DV_I8) {
+      bits = (uint64_t)(uint8_t)(int8_t)xt_to_int32(xt_number(value));
+    } else if (kind == XT_DV_I16) {
+      bits = (uint64_t)(uint16_t)(int16_t)xt_to_int32(xt_number(value));
+    } else if (kind == XT_DV_I32) {
+      bits = (uint64_t)(uint32_t)(int32_t)xt_to_int32(xt_number(value));
+    } else {
+      bits = (uint64_t)(uint32_t)xt_to_int32(xt_number(value));
+    }
+    xt_dv_write_bits(thisValue, offset, width, bits, little);
+    return XT_UNDEFINED;
+  }
+  uint64_t bits = xt_dv_read_bits(thisValue, offset, width, little);
+  if (kind == XT_DV_F32) {
+    uint32_t raw = (uint32_t)bits;
+    float value;
+    memcpy(&value, &raw, sizeof(value));
+    return xt_number((double)value);
+  }
+  if (kind == XT_DV_F64) {
+    double value;
+    memcpy(&value, &bits, sizeof(value));
+    return xt_number(value);
+  }
+  if (xt_dv_signed(kind)) {
+    int64_t signedValue = (int64_t)bits;
+    if (width < 8) {
+      uint64_t signBit = 1ULL << (width * 8 - 1);
+      if (bits & signBit) signedValue = (int64_t)(bits | (~0ULL << (width * 8)));
+    }
+    return xt_number((double)signedValue);
+  }
+  return xt_number((double)bits);
+}
+
+xt_value xt_data_view_ctor(int32_t argc, xt_value *argv) {
+  xt_value buffer = xt_arg_at(argc, argv, 0);
+  if (!xt_ab_is_buffer(buffer)) {
+    xt_value message = xt_string_from_cstr("First argument to DataView constructor must be an ArrayBuffer");
+    xt_throw(xt_type_error_ctor(1, &message));
+  }
+  uint32_t bufferLength = (uint32_t)xt_to_number(xt_get(buffer, xt_string_from_cstr("byteLength")));
+  double rawOffset = argc > 1 ? xt_to_number(argv[1]) : 0;
+  uint32_t offset = rawOffset > 0 ? (uint32_t)rawOffset : 0;
+  double rawLength = argc > 2 && argv[2] != XT_UNDEFINED ? xt_to_number(argv[2]) : (double)(bufferLength - offset);
+  uint32_t length = rawLength > 0 ? (uint32_t)rawLength : 0;
+  if (offset > bufferLength || length > bufferLength - offset) {
+    xt_value message = xt_string_from_cstr("Invalid DataView length");
+    xt_throw(xt_range_error_ctor(1, &message));
+  }
+  xt_value view = xt_object_new();
+  xt_object_set(view, xt_string_from_cstr("buffer"), buffer);
+  xt_object_set(view, xt_string_from_cstr("byteOffset"), xt_number((double)offset));
+  xt_object_set(view, xt_string_from_cstr("byteLength"), xt_number((double)length));
+  static const char *const getters[] = {"getUint8", "getInt8", "getUint16", "getInt16",
+                                        "getUint32", "getInt32", "getFloat32", "getFloat64"};
+  static const char *const setters[] = {"setUint8", "setInt8", "setUint16", "setInt16",
+                                        "setUint32", "setInt32", "setFloat32", "setFloat64"};
+  for (int kind = 0; kind < 8; kind++) {
+    for (int isSetter = 0; isSetter < 2; isSetter++) {
+      xt_value environment[2] = {xt_number((double)kind), xt_number((double)isSetter)};
+      xt_value closure = xt_closure_new((void *)xt_dv_method, 2, environment);
+      xt_object_set(view, xt_string_from_cstr(isSetter ? setters[kind] : getters[kind]), closure);
+    }
+  }
+  return view;
+}

package/runtime/xt_async.c

@@ -0,0 +1,222 @@
+/*
+ * 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` always yields: even a non-promise or an already-settled promise
+ * queues a microtask before the body resumes, matching the specification's
+ * interleaving with pending `.then` callbacks. (Top-level `await`, with no
+ * coroutine to suspend, still blocks on the event loop.)
+ */
+
+#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) {
+  if (!asyncPointer) return;
+  /* Async generators park the same kind of waiter, but their completion sends
+   * a promise to the current `.next()` request instead of settling a single
+   * `async` promise. */
+  if (((xt_header *)asyncPointer)->kind == XT_OBJECT_KIND_GENERATOR) {
+    xt_generator_wake(asyncPointer, value, rejected);
+    return;
+  }
+  xt_async *async = (xt_async *)asyncPointer;
+  if (async->done || !async->coroutine) return;
+  async->resume_value = value;
+  async->await_threw = rejected;
+  xt_async_resume(async);
+}
+
+/* `await value`: every await yields once. A settled promise (or a plain value)
+ * queues a microtask before resuming, so an await always interleaves with
+ * pending `.then` callbacks exactly like the specification. */
+xt_value xt_await(xt_value value) {
+  /* An `await` inside an async generator suspends that generator's coroutine
+   * while leaving the current `.next()` promise pending. */
+  xt_value generatorResult;
+  if (xt_generator_await(value, &generatorResult)) return generatorResult;
+
+  int state = xt_promise_state_of(value);
+  xt_async *async = g_active_async;
+  if (async && async->coroutine && xt_coroutine_is_current(async->coroutine)) {
+    if (state == XT_PROMISE_PENDING) {
+      async->await_threw = 0;
+      async->resume_value = XT_UNDEFINED;
+      xt_promise_add_async_waiter(value, async);
+      xt_coroutine_leave(async->coroutine);
+    } else {
+      int rejected = state == XT_PROMISE_REJECTED;
+      xt_value settled = (state == XT_PROMISE_FULFILLED || rejected)
+                             ? xt_promise_value_of(value)
+                             : value;
+      async->await_threw = rejected;
+      async->resume_value = settled;
+      xt_promise_queue_async_wake(async, settled, rejected);
+      xt_coroutine_leave(async->coroutine);
+    }
+    /* The waiter/queued microtask 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;
+  }
+
+  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);
+
+  /* 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/helpers.inc

@@ -54,7 +54,7 @@ static void bi_throw_type(const char *message) {
   size_t len = strlen(message);
   char *buffer = (char *)malloc(len + 16);
   snprintf(buffer, len + 16, "TypeError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   free(buffer);
 }
 
@@ -62,7 +62,7 @@ static void bi_throw_range(const char *message) {
   size_t len = strlen(message);
   char *buffer = (char *)malloc(len + 16);
   snprintf(buffer, len + 16, "RangeError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   free(buffer);
 }
 
@@ -70,7 +70,7 @@ static void bi_throw_syntax(const char *message) {
   size_t len = strlen(message);
   char *buffer = (char *)malloc(len + 16);
   snprintf(buffer, len + 16, "SyntaxError: %s", message);
-  xt_throw(xt_string_from_cstr(buffer));
+  xt_throw(xt_error_from_message(buffer));
   free(buffer);
 }