xbintsc 0.3.81 → 0.3.87

package/runtime/xt_builtins.c

@@ -62,9 +62,77 @@ xt_value xt_object_spread(xt_value target, xt_value source) {
   return xt_object_assign(2, args);
 }
 
+/* True when `key` is one of the explicitly destructured properties. */
+static int xt_object_rest_excludes(xt_value key, int32_t argc, xt_value *argv) {
+  for (int32_t i = 0; i < argc; i++) {
+    if (xt_property_key_equals(key, argv[i])) return 1;
+  }
+  return 0;
+}
+
+static void xt_object_rest_copy(xt_value target, xt_value key, xt_value value, int32_t argc, xt_value *argv) {
+  if (xt_object_rest_excludes(key, argc, argv)) return;
+  xt_object_set(target, key, value);
+}
+
+/*
+ * `const { a, ...rest } = source` (and the assignment / parameter forms).
+ *
+ * Copies the *own enumerable* properties that the pattern did not name, in
+ * insertion order. Arrays and strings contribute their index properties, like
+ * ECMAScript; accessor properties are read through their getter, with the
+ * source as the receiver.
+ */
+xt_value xt_object_rest(xt_value source, int32_t argc, xt_value *argv) {
+  if (source == XT_UNDEFINED || source == XT_NULL) {
+    xt_throw(xt_string_from_cstr("TypeError: Cannot destructure null or undefined"));
+    return XT_UNDEFINED;
+  }
+  xt_value result = xt_object_new();
+
+  if (XT_IS_ARRAY(source)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(source);
+    for (uint32_t i = 0; i < array->length; i++) {
+      char buffer[16];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), array->items[i], argc, argv);
+    }
+    return result;
+  }
+
+  if (XT_IS_STRING(source)) {
+    xt_string *string = (xt_string *)XT_GET_PTR(source);
+    const char *bytes = xt_string_bytes(string);
+    for (uint32_t i = 0; i < string->length; i++) {
+      char buffer[16];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_object_rest_copy(result, xt_string_from_cstr(buffer), xt_string_new(bytes + i, 1), argc, argv);
+    }
+    return result;
+  }
+
+  if (!XT_IS_OBJECT(source) && !XT_IS_FUNCTION(source)) return result;
+  xt_object *object = xt_as_object(source);
+  if (!object) return result;
+  if (object->header.kind != XT_OBJECT_KIND_OBJECT && object->header.kind != XT_OBJECT_KIND_ERROR) {
+    /* Map/Set/Date/RegExp/Promise have no own enumerable string properties. */
+    return result;
+  }
+  for (uint32_t i = 0; i < object->count; i++) {
+    xt_property *property = &object->properties[i];
+    if (xt_object_rest_excludes(property->key, argc, argv)) continue;
+    xt_value value = property->value;
+    if (property->getter != XT_UNDEFINED && XT_IS_FUNCTION(property->getter)) {
+      value = xt_call_with_this(property->getter, source, 0, NULL);
+    }
+    xt_object_set(result, property->key, value);
+  }
+  return result;
+}
+
 xt_value xt_parse_int(int32_t argc, xt_value *argv) {
   xt_string *s = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
-  const char *p = s->data;
+  const char *p = xt_string_bytes(s);
   /* JavaScript `parseInt` semantics: skip leading whitespace, accept an
      optional sign, pick the radix (auto-detecting a `0x` prefix), read the
      longest run of valid digits and accumulate into a double. Accumulating as
@@ -107,9 +175,10 @@ xt_value xt_parse_int(int32_t argc, xt_value *argv) {
 
 xt_value xt_parse_float(int32_t argc, xt_value *argv) {
   xt_string *s = xt_as_string(xt_to_string(xt_arg_at(argc, argv, 0)));
+  const char *bytes = xt_string_bytes(s);
   char *end = NULL;
-  double value = strtod(s->data, &end);
-  if (end == s->data) return xt_number(NAN);
+  double value = strtod(bytes, &end);
+  if (end == bytes) return xt_number(NAN);
   return xt_number(value);
 }
 
@@ -140,6 +209,7 @@ static int xt_uri_is_kept(const char *allowed, unsigned char c) {
 
 static xt_value xt_uri_encode(xt_value input, const char *allowed) {
   xt_string *s = xt_as_string(xt_to_string(input));
+  const char *bytes = xt_string_bytes(s);
   static const char hex[] = "0123456789ABCDEF";
   char *out = (char *)malloc((size_t)s->length * 3 + 1);
   if (!out) {
@@ -148,7 +218,7 @@ static xt_value xt_uri_encode(xt_value input, const char *allowed) {
   }
   size_t written = 0;
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     if (xt_uri_is_kept(allowed, c)) {
       out[written++] = (char)c;
     } else {
@@ -173,6 +243,7 @@ static int xt_hex_value(int c) {
  * escapes for reserved characters are copied through unchanged. */
 static xt_value xt_uri_decode(xt_value input, int component) {
   xt_string *s = xt_as_string(xt_to_string(input));
+  const char *bytes = xt_string_bytes(s);
   char *out = (char *)malloc((size_t)s->length + 1);
   if (!out) {
     fprintf(stderr, "xbintsc: out of memory\n");
@@ -181,22 +252,22 @@ static xt_value xt_uri_decode(xt_value input, int component) {
   size_t written = 0;
   uint32_t i = 0;
   while (i < s->length) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     if (c != '%') {
       out[written++] = (char)c;
       i++;
       continue;
     }
     if (i + 2 >= s->length) xt_throw_uri_error("URI malformed");
-    int h1 = xt_hex_value((unsigned char)s->data[i + 1]);
-    int h2 = xt_hex_value((unsigned char)s->data[i + 2]);
+    int h1 = xt_hex_value((unsigned char)bytes[i + 1]);
+    int h2 = xt_hex_value((unsigned char)bytes[i + 2]);
     if (h1 < 0 || h2 < 0) xt_throw_uri_error("URI malformed");
     unsigned char b = (unsigned char)((h1 << 4) | h2);
     if (b < 0x80) {
       if (!component && xt_uri_is_kept(";/?:@&=+$,#", b)) {
-        out[written++] = s->data[i];
-        out[written++] = s->data[i + 1];
-        out[written++] = s->data[i + 2];
+        out[written++] = bytes[i];
+        out[written++] = bytes[i + 1];
+        out[written++] = bytes[i + 2];
       } else {
         out[written++] = (char)b;
       }
@@ -213,9 +284,9 @@ static xt_value xt_uri_decode(xt_value input, int component) {
     for (int k = 1; k <= extra; k++) {
       uint32_t pos = i + (uint32_t)k * 3;
       if (pos + 2 >= s->length) xt_throw_uri_error("URI malformed");
-      if (s->data[pos] != '%') xt_throw_uri_error("URI malformed");
-      int c1 = xt_hex_value((unsigned char)s->data[pos + 1]);
-      int c2 = xt_hex_value((unsigned char)s->data[pos + 2]);
+      if (bytes[pos] != '%') xt_throw_uri_error("URI malformed");
+      int c1 = xt_hex_value((unsigned char)bytes[pos + 1]);
+      int c2 = xt_hex_value((unsigned char)bytes[pos + 2]);
       if (c1 < 0 || c2 < 0) xt_throw_uri_error("URI malformed");
       unsigned char cb = (unsigned char)((c1 << 4) | c2);
       if ((cb & 0xC0) != 0x80) xt_throw_uri_error("URI malformed");
@@ -322,7 +393,7 @@ xt_value xt_in(xt_value key, xt_value value) {
     if (xt_is_symbol(key)) return XT_FALSE;
     xt_string *s = xt_as_string(value);
     xt_string *k = xt_as_string(xt_to_string(key));
-    if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return XT_TRUE;
+    if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return XT_TRUE;
     int32_t index = xt_to_int32(key);
     return xt_bool(index >= 0 && (uint32_t)index < s->length);
   }
@@ -446,6 +517,57 @@ xt_value xt_instance_of(xt_value value, xt_value ctor) {
   return XT_FALSE;
 }
 
+/*
+ * `value instanceof Array` (and the rest of the built-in constructors).
+ *
+ * Built-in constructors are not first-class values: the codegen recognises the
+ * name and asks this helper instead. Ids match `BUILTIN_INSTANCEOF` in
+ * `src/codegen/generator/tables.ts`; 16..24 map onto the runtime's `XT_TA_*`
+ * order (Uint8Array first).
+ */
+enum {
+  XT_INSTANCE_ARRAY = 0,
+  XT_INSTANCE_OBJECT = 1,
+  XT_INSTANCE_FUNCTION = 2,
+  XT_INSTANCE_MAP = 3,
+  XT_INSTANCE_SET = 4,
+  XT_INSTANCE_DATE = 5,
+  XT_INSTANCE_REGEXP = 6,
+  XT_INSTANCE_PROMISE = 7,
+  XT_INSTANCE_TYPED_ARRAY_FIRST = 16,
+  XT_INSTANCE_TYPED_ARRAY_LAST = 24
+};
+
+static int xt_value_has_kind(xt_value value, uint8_t kind) {
+  return XT_IS_OBJECT(value) && ((xt_object *)XT_GET_PTR(value))->header.kind == kind;
+}
+
+xt_value xt_instance_of_builtin(xt_value value, int32_t id) {
+  switch (id) {
+    case XT_INSTANCE_ARRAY:
+      return xt_bool(XT_IS_ARRAY(value));
+    case XT_INSTANCE_OBJECT:
+      return xt_bool(XT_IS_OBJECT(value) || XT_IS_ARRAY(value) || XT_IS_FUNCTION(value));
+    case XT_INSTANCE_FUNCTION:
+      return xt_bool(XT_IS_FUNCTION(value));
+    case XT_INSTANCE_MAP:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_MAP));
+    case XT_INSTANCE_SET:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_SET));
+    case XT_INSTANCE_DATE:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_DATE));
+    case XT_INSTANCE_REGEXP:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_REGEXP));
+    case XT_INSTANCE_PROMISE:
+      return xt_bool(xt_value_has_kind(value, XT_OBJECT_KIND_PROMISE));
+    default:
+      if (id >= XT_INSTANCE_TYPED_ARRAY_FIRST && id <= XT_INSTANCE_TYPED_ARRAY_LAST) {
+        return xt_bool(xt_typed_array_kind_of(value) == id - XT_INSTANCE_TYPED_ARRAY_FIRST);
+      }
+      return XT_FALSE;
+  }
+}
+
 xt_value xt_closure_env(xt_value value, int32_t index) {
   if (!XT_IS_FUNCTION(value)) return XT_UNDEFINED;
   xt_function *function = (xt_function *)XT_GET_PTR(value);

package/runtime/xt_containers/access.inc

@@ -13,7 +13,7 @@ static void xt_throw_read_of_nullish(xt_value target, xt_value key) {
   char keybuf[128];
   xt_string *k = XT_IS_STRING(key) ? xt_as_string(key) : xt_as_string(xt_to_string(key));
   uint32_t n = k->length < sizeof(keybuf) - 1 ? k->length : (uint32_t)(sizeof(keybuf) - 1);
-  memcpy(keybuf, k->data, n);
+  memcpy(keybuf, xt_string_bytes(k), n);
   keybuf[n] = 0;
   char message[256];
   snprintf(message, sizeof(message),
@@ -27,7 +27,7 @@ xt_value xt_get(xt_value target, xt_value key) {
     /* `arr.length` must read the array's length, never an element. */
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0)
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0)
         return xt_number((double)((xt_array *)XT_GET_PTR(target))->length);
       /* Named (non-index) properties such as `raw`/`index`/`input`. */
       uint32_t ignored = 0;
@@ -57,11 +57,11 @@ xt_value xt_get(xt_value target, xt_value key) {
     /* Functions expose own `name` / `length` (arity) properties. */
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) {
         int32_t arity = ((xt_function *)XT_GET_PTR(target))->arity;
         return xt_number(arity >= 0 ? (double)arity : 0.0);
       }
-      if (k->length == 4 && memcmp(k->data, "name", 4) == 0) {
+      if (k->length == 4 && memcmp(xt_string_bytes(k), "name", 4) == 0) {
         xt_string *name = ((xt_function *)XT_GET_PTR(target))->name;
         return name ? XT_FROM_PTR(XT_TAG_STRING, name) : xt_string_from_cstr("");
       }
@@ -79,7 +79,7 @@ xt_value xt_get(xt_value target, xt_value key) {
     if (obj->header.kind == XT_OBJECT_KIND_SYMBOL) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
-        if (k->length == 11 && memcmp(k->data, "description", 11) == 0) {
+        if (k->length == 11 && memcmp(xt_string_bytes(k), "description", 11) == 0) {
           return xt_symbol_description(target);
         }
       }
@@ -88,7 +88,7 @@ xt_value xt_get(xt_value target, xt_value key) {
     if (obj->header.kind == XT_OBJECT_KIND_MAP || obj->header.kind == XT_OBJECT_KIND_SET) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
-        if (k->length == 4 && memcmp(k->data, "size", 4) == 0) {
+        if (k->length == 4 && memcmp(xt_string_bytes(k), "size", 4) == 0) {
           int32_t size = obj->header.kind == XT_OBJECT_KIND_MAP ? xt_map_size(target) : xt_set_size(target);
           return xt_number((double)size);
         }
@@ -100,9 +100,10 @@ xt_value xt_get(xt_value target, xt_value key) {
     }
     if (obj->header.kind == XT_OBJECT_KIND_ERROR && XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 5 && memcmp(k->data, "stack", 5) == 0) {
-        xt_value own = xt_object_get(target, key);
-        return own != XT_UNDEFINED ? own : xt_error_to_string(target);
+      if (k->length == 5 && memcmp(xt_string_bytes(k), "stack", 5) == 0) {
+        xt_value captured = xt_error_stack(target);
+        if (captured != XT_UNDEFINED) return captured;
+        return xt_error_to_string(target);
       }
     }
     {
@@ -117,16 +118,16 @@ xt_value xt_get(xt_value target, xt_value key) {
     xt_string *s = xt_as_string(target);
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) return xt_number((double)s->length);
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) return xt_number((double)s->length);
       uint32_t index = 0;
       if (xt_key_is_array_index(k, &index) && index < s->length) {
-        return xt_string_new(s->data + index, 1);
+        return xt_string_new(xt_string_bytes(s) + index, 1);
       }
       return xt_method_value(target, key);
     }
     if (XT_IS_NUMBER(key)) {
       int32_t index = xt_to_int32(key);
-      if (index >= 0 && (uint32_t)index < s->length) return xt_string_new(s->data + index, 1);
+      if (index >= 0 && (uint32_t)index < s->length) return xt_string_new(xt_string_bytes(s) + index, 1);
     }
     return XT_UNDEFINED;
   }
@@ -142,7 +143,7 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
     /* Assigning `arr.length` truncates or extends the array. */
     if (XT_IS_STRING(key)) {
       xt_string *k = xt_as_string(key);
-      if (k->length == 6 && memcmp(k->data, "length", 6) == 0) {
+      if (k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) {
         xt_array *array = (xt_array *)XT_GET_PTR(target);
         int32_t n = xt_to_int32(value);
         if (n < 0) n = 0;
@@ -169,9 +170,9 @@ xt_value xt_set(xt_value target, xt_value key, xt_value value) {
     if (typed >= 0) {
       if (XT_IS_STRING(key)) {
         xt_string *k = xt_as_string(key);
-        if ((k->length == 6 && memcmp(k->data, "length", 6) == 0) ||
-            (k->length == 10 && memcmp(k->data, "byteLength", 10) == 0) ||
-            (k->length == 10 && memcmp(k->data, "byteOffset", 10) == 0)) {
+        if ((k->length == 6 && memcmp(xt_string_bytes(k), "length", 6) == 0) ||
+            (k->length == 10 && memcmp(xt_string_bytes(k), "byteLength", 10) == 0) ||
+            (k->length == 10 && memcmp(xt_string_bytes(k), "byteOffset", 10) == 0)) {
           xt_throw(xt_string_from_cstr("TypeError: Cannot assign to read only property"));
           return value;
         }

package/runtime/xt_containers/objects.inc

@@ -54,10 +54,11 @@ static xt_property *xt_object_find(xt_object *obj, xt_value key) {
  */
 static int xt_key_is_array_index(xt_string *key, uint32_t *out) {
   if (key->length == 0 || key->length > 10) return 0;
-  if (key->data[0] == '0' && key->length != 1) return 0; /* "0" is canonical, "01" is not */
+  const char *bytes = xt_string_bytes(key);
+  if (bytes[0] == '0' && key->length != 1) return 0; /* "0" is canonical, "01" is not */
   uint64_t value = 0;
   for (uint32_t i = 0; i < key->length; i++) {
-    char ch = key->data[i];
+    char ch = bytes[i];
     if (ch < '0' || ch > '9') return 0;
     value = value * 10 + (uint64_t)(ch - '0');
   }
@@ -117,7 +118,7 @@ int xt_property_key_equals(xt_value a, xt_value b) {
 static int xt_key_is_prototype(xt_value key) {
   if (!XT_IS_STRING(key)) return 0;
   xt_string *k = xt_as_string(key);
-  return k && k->length == 9 && memcmp(k->data, "prototype", 9) == 0;
+  return k && k->length == 9 && memcmp(xt_string_bytes(k), "prototype", 9) == 0;
 }
 
 xt_value xt_object_get(xt_value value, xt_value key) {

package/runtime/xt_io/exception.inc

@@ -14,6 +14,162 @@ static xt_try_frame *g_try_top = NULL;
 int32_t xt_program_argc = 0;
 char **xt_program_argv = NULL;
 
+/* ------------------------------------------------------------------------- */
+/* Shadow call stack                                                         */
+/* ------------------------------------------------------------------------- */
+
+/*
+ * Compiled functions push one frame on entry and pop it before returning, so
+ * `Error` can capture a JavaScript-level stack without any debug metadata.
+ * Generator bodies are not tracked (they switch stacks and can be suspended
+ * indefinitely); a normal function called from a generator is tracked normally.
+ *
+ * `name`/`file` point into the module's static string constants; the runtime
+ * never frees them. The depth is trimmed when a `try` frame is left, so frames
+ * from calls unwound by a throw cannot leak into a later stack.
+ */
+#define XT_STACK_MAX_DEPTH 256
+
+typedef struct {
+  const char *name;
+  const char *file;
+  int32_t line;
+} xt_stack_entry;
+
+static xt_stack_entry g_stack[XT_STACK_MAX_DEPTH];
+static int32_t g_stack_depth = 0;
+
+void xt_stack_push(const char *name, const char *file, int32_t line) {
+  if (g_stack_depth >= XT_STACK_MAX_DEPTH) return;
+  xt_stack_entry *entry = &g_stack[g_stack_depth++];
+  entry->name = name;
+  entry->file = file;
+  entry->line = line;
+}
+
+void xt_stack_pop(void) {
+  if (g_stack_depth > 0) g_stack_depth--;
+}
+
+int32_t xt_stack_depth(void) { return g_stack_depth; }
+
+void xt_stack_set_line(int32_t line) {
+  /* Called just before an `Error` is constructed, so the innermost frame
+   * reports the construction line rather than the function's declaration. */
+  if (g_stack_depth > 0) g_stack[g_stack_depth - 1].line = line;
+}
+
+void xt_stack_trim(int32_t depth) {
+  if (depth < 0) depth = 0;
+  if (depth < g_stack_depth) g_stack_depth = depth;
+}
+
+static void xt_stack_append(char **buffer, size_t *length, size_t *capacity, const char *text) {
+  size_t count = strlen(text);
+  if (*length + count + 1 > *capacity) {
+    size_t next = *capacity ? *capacity : 256;
+    while (next < *length + count + 1) next *= 2;
+    char *grown = (char *)realloc(*buffer, next);
+    if (!grown) return;
+    *buffer = grown;
+    *capacity = next;
+  }
+  memcpy(*buffer + *length, text, count);
+  *length += count;
+  (*buffer)[*length] = 0;
+}
+
+xt_value xt_stack_capture(const char *name, const char *message) {
+  const char *header = name && name[0] ? name : "Error";
+  char *buffer = NULL;
+  size_t length = 0;
+  size_t capacity = 0;
+  xt_stack_append(&buffer, &length, &capacity, header);
+  if (message && message[0]) {
+    xt_stack_append(&buffer, &length, &capacity, ": ");
+    xt_stack_append(&buffer, &length, &capacity, message);
+  }
+  xt_stack_append(&buffer, &length, &capacity, "\n");
+  for (int32_t index = g_stack_depth - 1; index >= 0; index--) {
+    const xt_stack_entry *entry = &g_stack[index];
+    char line[24];
+    xt_stack_append(&buffer, &length, &capacity, "    at ");
+    xt_stack_append(&buffer, &length, &capacity, entry->name && entry->name[0] ? entry->name : "anonymous");
+    xt_stack_append(&buffer, &length, &capacity, " (");
+    xt_stack_append(&buffer, &length, &capacity, entry->file && entry->file[0] ? entry->file : "<anonymous>");
+    if (entry->line > 0) {
+      snprintf(line, sizeof(line), ":%d", (int)entry->line);
+      xt_stack_append(&buffer, &length, &capacity, line);
+    }
+    xt_stack_append(&buffer, &length, &capacity, ")\n");
+  }
+  xt_value result = xt_string_new(buffer ? buffer : "", length);
+  free(buffer);
+  return result;
+}
+
+xt_value xt_error_stack(xt_value error) {
+  if (!XT_IS_OBJECT(error)) return XT_UNDEFINED;
+  xt_object *object = (xt_object *)XT_GET_PTR(error);
+  if (object->header.kind != XT_OBJECT_KIND_ERROR) return XT_UNDEFINED;
+  return object->error_stack;
+}
+
+/* ------------------------------------------------------------------------- */
+/* Fatal-signal diagnostics                                                  */
+/* ------------------------------------------------------------------------- */
+
+static char g_crash_report[16384];
+
+static int xt_format_stack(char *out, size_t size) {
+  int written = 0;
+  for (int32_t index = g_stack_depth - 1; index >= 0 && written < (int)size; index--) {
+    const xt_stack_entry *entry = &g_stack[index];
+    int count = snprintf(out + written, size - (size_t)written, "    at %s (%s:%d)\n",
+                         entry->name && entry->name[0] ? entry->name : "anonymous",
+                         entry->file && entry->file[0] ? entry->file : "<anonymous>", (int)entry->line);
+    if (count < 0) break;
+    written += count;
+  }
+  return written < (int)size ? written : (int)size - 1;
+}
+
+#if defined(_WIN32)
+
+static LONG WINAPI xt_fatal_exception(EXCEPTION_POINTERS *info) {
+  unsigned long code =
+      info && info->ExceptionRecord ? (unsigned long)info->ExceptionRecord->ExceptionCode : 0UL;
+  int written = snprintf(g_crash_report, sizeof(g_crash_report), "\nxbintsc: fatal exception 0x%08lx\n", code);
+  written += xt_format_stack(g_crash_report + written, sizeof(g_crash_report) - (size_t)written);
+  _write(2, g_crash_report, (unsigned int)written);
+  _exit(1);
+  return EXCEPTION_EXECUTE_HANDLER;
+}
+
+void xt_install_crash_handler(void) { SetUnhandledExceptionFilter(xt_fatal_exception); }
+
+#else
+
+static void xt_fatal_signal(int sig) {
+  int written = snprintf(g_crash_report, sizeof(g_crash_report), "\nxbintsc: fatal signal %d\n", sig);
+  written += xt_format_stack(g_crash_report + written, sizeof(g_crash_report) - (size_t)written);
+  ssize_t ignored = write(STDERR_FILENO, g_crash_report, (size_t)written);
+  (void)ignored;
+  _exit(128 + sig);
+}
+
+void xt_install_crash_handler(void) {
+  signal(SIGSEGV, xt_fatal_signal);
+  signal(SIGABRT, xt_fatal_signal);
+  signal(SIGFPE, xt_fatal_signal);
+  signal(SIGBUS, xt_fatal_signal);
+#ifdef SIGILL
+  signal(SIGILL, xt_fatal_signal);
+#endif
+}
+
+#endif
+
 #if defined(_WIN32)
 /*
  * The UCRT validates its low-level I/O arguments and, when one is out of
@@ -107,18 +263,23 @@ void *xt_try_enter(void) {
   if (!frame) abort();
   frame->prev = g_try_top;
   frame->exception = XT_UNDEFINED;
+  frame->stack_depth = g_stack_depth;
   g_try_top = frame;
   return (void *)frame;
 }
 
 xt_value xt_try_exception(void *framePtr) {
   xt_try_frame *frame = (xt_try_frame *)framePtr;
-  return frame ? frame->exception : XT_UNDEFINED;
+  if (!frame) return XT_UNDEFINED;
+  /* A throw longjmps past the calls it unwinds; drop their shadow frames. */
+  xt_stack_trim(frame->stack_depth);
+  return frame->exception;
 }
 
 void xt_try_leave(void *framePtr) {
   xt_try_frame *frame = (xt_try_frame *)framePtr;
   if (frame && g_try_top == frame) {
+    xt_stack_trim(frame->stack_depth);
     g_try_top = frame->prev;
     free(frame);
   }
@@ -135,8 +296,16 @@ void xt_throw(xt_value v) {
     g_try_top->exception = v;
     longjmp(g_try_top->buf, 1);
   }
+  xt_value stack = xt_error_stack(v);
+  if (stack != XT_UNDEFINED) {
+    xt_string *text = xt_as_string(stack);
+    if (text) {
+      fprintf(stderr, "Uncaught %s\n", xt_string_bytes(text));
+      exit(1);
+    }
+  }
   xt_value message = xt_to_string(v);
   xt_string *s = xt_as_string(message);
-  fprintf(stderr, "Uncaught %s\n", s->data);
+  fprintf(stderr, "Uncaught %s\n", xt_string_bytes(s));
   exit(1);
 }

package/runtime/xt_io/inspect.inc

@@ -5,12 +5,12 @@
 static void xt_print_value(xt_value v, FILE *out) {
   if (XT_IS_STRING(v)) {
     xt_string *s = xt_as_string(v);
-    fwrite(s->data, 1, s->length, out);
+    fwrite(xt_string_bytes(s), 1, s->length, out);
     return;
   }
   xt_value text = xt_to_string(v);
   xt_string *s = xt_as_string(text);
-  fwrite(s->data, 1, s->length, out);
+  fwrite(xt_string_bytes(s), 1, s->length, out);
 }
 
 void xt_print(xt_value v) { xt_print_value(v, stdout); }
@@ -48,10 +48,11 @@ static void xt_inspect_pop(void) {
 
 static int xt_inspect_identifier_key(xt_string *key) {
   if (key->length == 0) return 0;
-  char c = key->data[0];
+  const char *bytes = xt_string_bytes(key);
+  char c = bytes[0];
   if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$')) return 0;
   for (uint32_t i = 1; i < key->length; i++) {
-    c = key->data[i];
+    c = bytes[i];
     if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '$')) return 0;
   }
   return 1;
@@ -60,16 +61,17 @@ static int xt_inspect_identifier_key(xt_string *key) {
 /* Render a string the way `util.inspect` does inside a container: quoted,
  * preferring whichever quote character needs fewer escapes. */
 static void xt_inspect_string(xt_string *s, FILE *out) {
+  const char *bytes = xt_string_bytes(s);
   int hasSingle = 0;
   int hasDouble = 0;
   for (uint32_t i = 0; i < s->length; i++) {
-    if (s->data[i] == '\'') hasSingle = 1;
-    else if (s->data[i] == '"') hasDouble = 1;
+    if (bytes[i] == '\'') hasSingle = 1;
+    else if (bytes[i] == '"') hasDouble = 1;
   }
   char quote = (hasSingle && !hasDouble) ? '"' : '\'';
   fputc(quote, out);
   for (uint32_t i = 0; i < s->length; i++) {
-    unsigned char c = (unsigned char)s->data[i];
+    unsigned char c = (unsigned char)bytes[i];
     switch (c) {
       case '\\': fputs("\\\\", out); break;
       case '\n': fputs("\\n", out); break;
@@ -90,13 +92,13 @@ static void xt_inspect_string(xt_string *s, FILE *out) {
 static void xt_inspect(xt_value v, FILE *out, int nested) {
   if (xt_is_symbol(v)) {
     xt_string *text = xt_as_string(xt_symbol_to_string(v));
-    fwrite(text->data, 1, text->length, out);
+    fwrite(xt_string_bytes(text), 1, text->length, out);
     return;
   }
   if (XT_IS_BIGINT(v)) {
     xt_value text = xt_bigint_to_decimal(v);
     xt_string *s = xt_as_string(text);
-    fwrite(s->data, 1, s->length, out);
+    fwrite(xt_string_bytes(s), 1, s->length, out);
     fputc('n', out);
     return;
   }
@@ -130,10 +132,10 @@ static void xt_inspect(xt_value v, FILE *out, int nested) {
         xt_value key = extra->properties[i].key;
         if (xt_is_symbol(key)) {
           xt_string *text = xt_as_string(xt_symbol_to_string(key));
-          fwrite(text->data, 1, text->length, out);
+          fwrite(xt_string_bytes(text), 1, text->length, out);
         } else {
           xt_string *keyString = xt_as_string(key);
-          fwrite(keyString->data, 1, keyString->length, out);
+          fwrite(xt_string_bytes(keyString), 1, keyString->length, out);
         }
         fputs(": ", out);
         xt_inspect(extra->properties[i].value, out, 1);
@@ -170,10 +172,10 @@ static void xt_inspect(xt_value v, FILE *out, int nested) {
         written++;
         if (isSymbol) {
           xt_string *text = xt_as_string(xt_symbol_to_string(key));
-          fwrite(text->data, 1, text->length, out);
+          fwrite(xt_string_bytes(text), 1, text->length, out);
         } else {
           xt_string *keyString = xt_as_string(key);
-          if (xt_inspect_identifier_key(keyString)) fwrite(keyString->data, 1, keyString->length, out);
+          if (xt_inspect_identifier_key(keyString)) fwrite(xt_string_bytes(keyString), 1, keyString->length, out);
           else xt_inspect_string(keyString, out);
         }
         fputs(": ", out);

package/runtime/xt_io.c

@@ -37,7 +37,12 @@
 #if defined(_WIN32)
 #include <fcntl.h>
 #include <io.h>
+#include <process.h>
 #include <winsock2.h>
+#include <windows.h>
+#else
+#include <signal.h>
+#include <unistd.h>
 #endif
 
 #include "xt_io/exception.inc"

package/runtime/xt_stdlib/arrays.inc

@@ -47,11 +47,11 @@ static xt_value xt_array_join(xt_value value, xt_value separator) {
   if (!out) abort();
   out[0] = '\0';
   for (uint32_t i = 0; i < array->length; i++) {
-    if (i > 0) xt_buffer_append(&out, &length, &capacity, sep->data, sep->length);
+    if (i > 0) xt_buffer_append(&out, &length, &capacity, xt_string_bytes(sep), sep->length);
     xt_value item = array->items[i];
     if (item == XT_UNDEFINED || item == XT_NULL) continue;
     xt_string *str = xt_as_string(xt_to_string(item));
-    xt_buffer_append(&out, &length, &capacity, str->data, str->length);
+    xt_buffer_append(&out, &length, &capacity, xt_string_bytes(str), str->length);
   }
   xt_value result = xt_string_new(out, length);
   free(out);