xbintsc 0.3.81 → 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/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

@@ -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(s->data, 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(s->data, 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); }
@@ -48,10 +69,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 +82,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;
@@ -81,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);
     }
   }
@@ -90,13 +125,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 +165,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 +205,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"