xbintsc 0.1.3 → 0.1.8

package/runtime/rt_internal.h

@@ -0,0 +1,106 @@
+/*
+ * xbintsc runtime — private internal header.
+ *
+ * Shared by the runtime translation units:
+ *   xt_alloc.c       heap arena + allocation kinds
+ *   xt_values.c      constructors, strings, conversions, arithmetic, comparison
+ *   xt_containers.c  objects, arrays, generic member access, boxes
+ *   xt_stdlib.c      Array/String methods and Math
+ *   xt_builtins.c    Object methods, globals and closures
+ *   xt_io.c          exceptions (try/catch) and console output
+ *
+ * This header declares the internal object layouts and the small set of
+ * helpers that cross translation-unit boundaries. Nothing here is part of the
+ * public ABI in `rt.h`; generated code only sees the `xt_*` prototypes there.
+ *
+ * Design notes
+ * ------------
+ *  * Values are 64-bit NaN-boxed words (`xt_value`). Numbers travel unboxed;
+ *    everything else is a tagged pointer into an allocation arena.
+ *  * The allocator is a bump arena. It never frees, which keeps the generated
+ *    code free of write barriers and makes the first implementation small and
+ *    predictable. Replacing it with a precise/conservative collector is an
+ *    isolated change behind `xt_alloc` plus root registration.
+ *  * Strings are UTF-8. JavaScript measures string length in UTF-16 code
+ *    units; `xt_string_length` currently reports code points (see README).
+ *  * Objects use a small linear property list. Fine for the language subset
+ *    xbintsc targets today; swap for a hash map when the profile demands it.
+ */
+
+#ifndef XT_RT_INTERNAL_H
+#define XT_RT_INTERNAL_H
+
+#include "rt.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+/* Allocation kinds recorded in `xt_header.kind`. */
+#define XT_OBJECT_KIND_STRING 1
+#define XT_OBJECT_KIND_OBJECT 2
+#define XT_OBJECT_KIND_ARRAY 3
+#define XT_OBJECT_KIND_FUNCTION 4
+
+/* Common header for every heap object. */
+typedef struct xt_header {
+  uint8_t kind;
+  uint8_t flags;
+  uint16_t reserved;
+  uint32_t size;
+  struct xt_header *gc_next;
+} xt_header;
+
+typedef struct {
+  xt_header header;
+  uint32_t length;
+  uint32_t capacity;
+  char *data;
+} xt_string;
+
+typedef struct {
+  xt_string *key;
+  xt_value value;
+} xt_property;
+
+typedef struct {
+  xt_header header;
+  uint32_t count;
+  uint32_t capacity;
+  xt_property *properties;
+} xt_object;
+
+typedef struct {
+  xt_header header;
+  uint32_t length;
+  uint32_t capacity;
+  xt_value *items;
+} xt_array;
+
+typedef struct {
+  xt_header header;
+  xt_code_fn code;
+  xt_value *environment;
+  int32_t environment_count;
+  int32_t arity;
+  xt_string *name;
+  xt_object *properties;
+} xt_function;
+
+/* Allocation (xt_alloc.c). */
+void *xt_alloc(size_t size, int kind);
+
+/* Value / string helpers shared across translation units (xt_values.c). */
+xt_string *xt_string_alloc(size_t length);
+xt_string *xt_as_string(xt_value value);
+int32_t xt_string_length(xt_string *s);
+int xt_string_equals(xt_string *a, xt_string *b);
+int32_t xt_to_int32(xt_value v);
+
+/* Container helper (xt_containers.c). */
+void xt_array_reserve(xt_array *array, uint32_t needed);
+
+/* Standard-library helpers (xt_stdlib.c). */
+xt_array *xt_as_array(xt_value value);
+xt_value xt_arg_at(int32_t argc, xt_value *argv, int32_t index);
+
+#endif /* XT_RT_INTERNAL_H */

package/runtime/xt_alloc.c

@@ -0,0 +1,38 @@
+/*
+ * xbintsc runtime — heap allocation.
+ *
+ * A bump-style arena shared by every object kind. Allocations are never
+ * reclaimed; the design keeps replacing this with a real collector isolated
+ * behind `xt_alloc` (see rt_internal.h).
+ */
+
+#include "rt_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------------- */
+/* Allocation                                                                */
+/* ------------------------------------------------------------------------- */
+
+static size_t g_heap_bytes = 0;
+static size_t g_heap_allocations = 0;
+static xt_header *g_heap_head = NULL;
+
+void *xt_alloc(size_t size, int kind) {
+  xt_header *header = (xt_header *)calloc(1, size);
+  if (!header) {
+    fprintf(stderr, "xbintsc: out of memory allocating %zu bytes\n", size);
+    abort();
+  }
+  header->kind = (uint8_t)kind;
+  header->size = (uint32_t)size;
+  header->gc_next = g_heap_head;
+  g_heap_head = header;
+  g_heap_bytes += size;
+  g_heap_allocations++;
+  return header;
+}
+
+size_t xt_heap_bytes(void) { return g_heap_bytes; }
+size_t xt_heap_allocations(void) { return g_heap_allocations; }

package/runtime/xt_builtins.c

@@ -0,0 +1,192 @@
+/*
+ * xbintsc runtime — builtins.
+ *
+ * `Object.*` statics and the free functions (`parseInt`, `isNaN`, `in`, ...),
+ * along with the closure representation and calling convention.
+ */
+
+#include "rt_internal.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------------- */
+/* Object methods and global functions                                       */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_object_values(xt_value value) {
+  xt_value result = xt_array_new(0, NULL);
+  if (!XT_IS_OBJECT(value)) return result;
+  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  for (uint32_t i = 0; i < obj->count; i++) xt_array_push(result, obj->properties[i].value);
+  return result;
+}
+
+xt_value xt_object_entries(xt_value value) {
+  xt_value result = xt_array_new(0, NULL);
+  if (!XT_IS_OBJECT(value)) return result;
+  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  for (uint32_t i = 0; i < obj->count; i++) {
+    xt_value pair = xt_array_new(0, NULL);
+    xt_array_push(pair, XT_FROM_PTR(XT_TAG_STRING, obj->properties[i].key));
+    xt_array_push(pair, obj->properties[i].value);
+    xt_array_push(result, pair);
+  }
+  return result;
+}
+
+xt_value xt_object_assign(int32_t argc, xt_value *argv) {
+  if (argc <= 0) return xt_undefined();
+  xt_value target = argv[0];
+  if (!XT_IS_OBJECT(target)) return target;
+  for (int32_t i = 1; i < argc; i++) {
+    if (!XT_IS_OBJECT(argv[i])) continue;
+    xt_object *source = (xt_object *)XT_GET_PTR(argv[i]);
+    for (uint32_t j = 0; j < source->count; j++) {
+      xt_object_set(target, XT_FROM_PTR(XT_TAG_STRING, source->properties[j].key), source->properties[j].value);
+    }
+  }
+  return target;
+}
+
+/* Copy every own enumerable property of `source` onto `target` (`{...source}`). */
+xt_value xt_object_spread(xt_value target, xt_value source) {
+  xt_value args[2];
+  args[0] = target;
+  args[1] = source;
+  return xt_object_assign(2, args);
+}
+
+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)));
+  int32_t radix = argc >= 2 ? xt_to_int32(argv[1]) : 0;
+  char *end = NULL;
+  long value = strtol(s->data, &end, radix);
+  if (end == s->data) return xt_number(NAN);
+  return xt_number((double)value);
+}
+
+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)));
+  char *end = NULL;
+  double value = strtod(s->data, &end);
+  if (end == s->data) return xt_number(NAN);
+  return xt_number(value);
+}
+
+xt_value xt_is_nan(int32_t argc, xt_value *argv) {
+  double value = xt_to_number(xt_arg_at(argc, argv, 0));
+  return xt_bool(value != value);
+}
+
+xt_value xt_is_finite(int32_t argc, xt_value *argv) {
+  double value = xt_to_number(xt_arg_at(argc, argv, 0));
+  return xt_bool(!isnan(value) && !isinf(value));
+}
+
+xt_value xt_number_ctor(int32_t argc, xt_value *argv) {
+  if (argc == 0) return xt_number(0);
+  return xt_number(xt_to_number(argv[0]));
+}
+
+xt_value xt_string_ctor(int32_t argc, xt_value *argv) {
+  if (argc == 0) return xt_string_from_cstr("");
+  return xt_to_string(argv[0]);
+}
+
+xt_value xt_boolean_ctor(int32_t argc, xt_value *argv) {
+  if (argc == 0) return XT_FALSE;
+  return xt_bool(xt_truthy(argv[0]));
+}
+
+xt_value xt_in(xt_value key, xt_value value) {
+  if (XT_IS_OBJECT(value)) return xt_object_has(value, key);
+  if (XT_IS_ARRAY(value)) {
+    int32_t index = xt_to_int32(key);
+    return xt_bool(index >= 0 && (uint32_t)index < xt_as_array(value)->length);
+  }
+  if (XT_IS_STRING(value)) {
+    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;
+    int32_t index = xt_to_int32(key);
+    return xt_bool(index >= 0 && (uint32_t)index < s->length);
+  }
+  return XT_FALSE;
+}
+
+xt_value xt_delete(xt_value value, xt_value key) {
+  if (XT_IS_OBJECT(value)) {
+    xt_object *obj = (xt_object *)XT_GET_PTR(value);
+    xt_string *k = xt_as_string(xt_to_string(key));
+    for (uint32_t i = 0; i < obj->count; i++) {
+      if (xt_string_equals(obj->properties[i].key, k)) {
+        for (uint32_t j = i + 1; j < obj->count; j++) obj->properties[j - 1] = obj->properties[j];
+        obj->count--;
+        break;
+      }
+    }
+    return XT_TRUE;
+  }
+  if (XT_IS_ARRAY(value)) {
+    xt_array_set(value, key, XT_UNDEFINED);
+    return XT_TRUE;
+  }
+  return XT_TRUE;
+}
+
+xt_value xt_rest_args(int32_t argc, xt_value *argv, int32_t start) {
+  if (start < 0) start = 0;
+  int32_t count = argc - start;
+  if (count < 0) count = 0;
+  return xt_array_new(count, argv ? argv + start : NULL);
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* Functions                                                                 */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_arg(int32_t argc, xt_value *argv, int32_t index) {
+  if (index < 0 || index >= argc) return XT_UNDEFINED;
+  return argv[index];
+}
+
+xt_value xt_closure_new(void *fn, int32_t env_count, xt_value *env) {
+  xt_function *function = (xt_function *)xt_alloc(sizeof(xt_function), XT_OBJECT_KIND_FUNCTION);
+  function->code = (xt_code_fn)fn;
+  function->environment_count = env_count;
+  function->arity = -1;
+  function->properties = NULL;
+  function->environment = NULL;
+  if (env_count > 0) {
+    function->environment = (xt_value *)malloc(sizeof(xt_value) * (size_t)env_count);
+    for (int32_t i = 0; i < env_count; i++) function->environment[i] = env[i];
+  }
+  return XT_FROM_PTR(XT_TAG_FUNCTION, function);
+}
+
+xt_value xt_closure_call(xt_value value, int32_t argc, xt_value *argv) {
+  if (!XT_IS_FUNCTION(value)) {
+    xt_throw(xt_string_from_cstr("TypeError: value is not a function"));
+    return XT_UNDEFINED;
+  }
+  xt_function *function = (xt_function *)XT_GET_PTR(value);
+  /* The closure value itself is threaded through as `env` so the callee can
+   * read its captures with xt_closure_env(env, i). */
+  return function->code(value, argc, argv);
+}
+
+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);
+  if (index < 0 || index >= function->environment_count) return XT_UNDEFINED;
+  return function->environment[index];
+}
+
+int32_t xt_closure_arity(xt_value value) {
+  if (!XT_IS_FUNCTION(value)) return -1;
+  return ((xt_function *)XT_GET_PTR(value))->arity;
+}
+

package/runtime/xt_containers.c

@@ -0,0 +1,225 @@
+/*
+ * xbintsc runtime — containers.
+ *
+ * Objects (linear property lists) and arrays (dynamic vectors), plus the
+ * generic `xt_get`/`xt_set` member access used by the codegen and the boxing
+ * helpers used for captured `let` bindings.
+ */
+
+#include "rt_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------------- */
+/* Objects                                                                   */
+/* ------------------------------------------------------------------------- */
+
+static void xt_object_reserve(xt_object *obj, uint32_t needed) {
+  if (needed <= obj->capacity) return;
+  uint32_t capacity = obj->capacity ? obj->capacity * 2 : 8;
+  while (capacity < needed) capacity *= 2;
+  obj->properties = (xt_property *)realloc(obj->properties, sizeof(xt_property) * capacity);
+  if (!obj->properties) {
+    fprintf(stderr, "xbintsc: out of memory growing object\n");
+    abort();
+  }
+  obj->capacity = capacity;
+}
+
+xt_value xt_object_new(void) {
+  xt_object *obj = (xt_object *)xt_alloc(sizeof(xt_object), XT_OBJECT_KIND_OBJECT);
+  obj->count = 0;
+  obj->capacity = 0;
+  obj->properties = NULL;
+  return XT_FROM_PTR(XT_TAG_OBJECT, obj);
+}
+
+static xt_property *xt_object_find(xt_object *obj, xt_string *key) {
+  for (uint32_t i = 0; i < obj->count; i++) {
+    if (xt_string_equals(obj->properties[i].key, key)) return &obj->properties[i];
+  }
+  return NULL;
+}
+
+xt_value xt_object_get(xt_value value, xt_value key) {
+  if (!XT_IS_OBJECT(value)) return XT_UNDEFINED;
+  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  xt_value keyString = xt_to_string(key);
+  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
+  return prop ? prop->value : XT_UNDEFINED;
+}
+
+xt_value xt_object_set(xt_value value, xt_value key, xt_value newValue) {
+  if (!XT_IS_OBJECT(value)) return newValue;
+  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  xt_value keyString = xt_to_string(key);
+  xt_property *prop = xt_object_find(obj, xt_as_string(keyString));
+  if (prop) {
+    prop->value = newValue;
+    return newValue;
+  }
+  xt_object_reserve(obj, obj->count + 1);
+  obj->properties[obj->count].key = xt_as_string(keyString);
+  obj->properties[obj->count].value = newValue;
+  obj->count++;
+  return newValue;
+}
+
+xt_value xt_object_has(xt_value value, xt_value key) {
+  if (!XT_IS_OBJECT(value)) return XT_FALSE;
+  xt_object *obj = (xt_object *)XT_GET_PTR(value);
+  xt_value keyString = xt_to_string(key);
+  return xt_bool(xt_object_find(obj, xt_as_string(keyString)) != NULL);
+}
+
+xt_value xt_object_keys(xt_value value) {
+  xt_value result = xt_array_new(0, NULL);
+  if (XT_IS_OBJECT(value)) {
+    xt_object *obj = (xt_object *)XT_GET_PTR(value);
+    for (uint32_t i = 0; i < obj->count; i++) {
+      xt_array_push(result, XT_FROM_PTR(XT_TAG_STRING, obj->properties[i].key));
+    }
+    return result;
+  }
+  if (XT_IS_ARRAY(value)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(value);
+    for (uint32_t i = 0; i < array->length; i++) {
+      char buffer[32];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_array_push(result, xt_string_from_cstr(buffer));
+    }
+    return result;
+  }
+  if (XT_IS_STRING(value)) {
+    xt_string *s = xt_as_string(value);
+    for (uint32_t i = 0; i < s->length; i++) {
+      char buffer[32];
+      snprintf(buffer, sizeof(buffer), "%u", i);
+      xt_array_push(result, xt_string_from_cstr(buffer));
+    }
+    return result;
+  }
+  return result;
+}
+
+/* Convenience used by codegen for `obj.prop`. */
+xt_value xt_object_get_cstr(xt_value value, const char *key) {
+  xt_value k = xt_string_from_cstr(key);
+  return xt_object_get(value, k);
+}
+
+/* ------------------------------------------------------------------------- */
+/* Arrays                                                                    */
+/* ------------------------------------------------------------------------- */
+
+void xt_array_reserve(xt_array *array, uint32_t needed) {
+  if (needed <= array->capacity) return;
+  uint32_t capacity = array->capacity ? array->capacity * 2 : 8;
+  while (capacity < needed) capacity *= 2;
+  array->items = (xt_value *)realloc(array->items, sizeof(xt_value) * capacity);
+  if (!array->items) {
+    fprintf(stderr, "xbintsc: out of memory growing array\n");
+    abort();
+  }
+  for (uint32_t i = array->capacity; i < capacity; i++) array->items[i] = XT_UNDEFINED;
+  array->capacity = capacity;
+}
+
+xt_value xt_array_new(int32_t count, xt_value *items) {
+  xt_array *array = (xt_array *)xt_alloc(sizeof(xt_array), XT_OBJECT_KIND_ARRAY);
+  array->length = 0;
+  array->capacity = 0;
+  array->items = NULL;
+  if (count > 0) {
+    xt_array_reserve(array, (uint32_t)count);
+    for (int32_t i = 0; i < count; i++) array->items[i] = items[i];
+    array->length = (uint32_t)count;
+  }
+  return XT_FROM_PTR(XT_TAG_ARRAY, array);
+}
+
+xt_value xt_array_get(xt_value value, xt_value index) {
+  if (!XT_IS_ARRAY(value)) return XT_UNDEFINED;
+  xt_array *array = (xt_array *)XT_GET_PTR(value);
+  int32_t i = xt_to_int32(index);
+  if (i < 0 || (uint32_t)i >= array->length) return XT_UNDEFINED;
+  return array->items[i];
+}
+
+xt_value xt_array_set(xt_value value, xt_value index, xt_value newValue) {
+  if (!XT_IS_ARRAY(value)) return newValue;
+  xt_array *array = (xt_array *)XT_GET_PTR(value);
+  int32_t i = xt_to_int32(index);
+  if (i < 0) return newValue;
+  xt_array_reserve(array, (uint32_t)i + 1);
+  for (uint32_t j = array->length; j < (uint32_t)i; j++) array->items[j] = XT_UNDEFINED;
+  array->items[i] = newValue;
+  if ((uint32_t)i >= array->length) array->length = (uint32_t)i + 1;
+  return newValue;
+}
+
+xt_value xt_array_push(xt_value value, xt_value newValue) {
+  if (!XT_IS_ARRAY(value)) return xt_number(0);
+  xt_array *array = (xt_array *)XT_GET_PTR(value);
+  xt_array_reserve(array, array->length + 1);
+  array->items[array->length++] = newValue;
+  return xt_number((double)array->length);
+}
+
+xt_value xt_array_length(xt_value value) {
+  if (XT_IS_ARRAY(value)) return xt_number((double)((xt_array *)XT_GET_PTR(value))->length);
+  if (XT_IS_STRING(value)) return xt_number((double)xt_string_length(xt_as_string(value)));
+  return XT_UNDEFINED;
+}
+
+xt_value xt_array_spread(xt_value target, xt_value source) {
+  if (!XT_IS_ARRAY(target) || !XT_IS_ARRAY(source)) return target;
+  xt_array *dst = (xt_array *)XT_GET_PTR(target);
+  xt_array *src = (xt_array *)XT_GET_PTR(source);
+  xt_array_reserve(dst, dst->length + src->length);
+  for (uint32_t i = 0; i < src->length; i++) dst->items[dst->length++] = src->items[i];
+  return target;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* Generic member access                                                     */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_get(xt_value target, xt_value key) {
+  if (XT_IS_ARRAY(target)) return xt_array_get(target, key);
+  if (XT_IS_OBJECT(target)) return xt_object_get(target, key);
+  if (XT_IS_STRING(target)) {
+    /* Property access on a string: `.length` and numeric indexing. */
+    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);
+    }
+    int32_t index = xt_to_int32(key);
+    if (index >= 0 && (uint32_t)index < s->length) return xt_string_new(s->data + index, 1);
+    return XT_UNDEFINED;
+  }
+  return XT_UNDEFINED;
+}
+
+xt_value xt_set(xt_value target, xt_value key, xt_value value) {
+  if (XT_IS_ARRAY(target)) return xt_array_set(target, key, value);
+  if (XT_IS_OBJECT(target)) return xt_object_set(target, key, value);
+  return value;
+}
+
+/* ------------------------------------------------------------------------- */
+/* Boxes                                                                     */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_box_new(xt_value value) { return xt_array_new(1, &value); }
+
+xt_value xt_box_get(xt_value box) { return xt_array_get(box, xt_number(0)); }
+
+xt_value xt_box_set(xt_value box, xt_value value) { return xt_array_set(box, xt_number(0), value); }
+
+xt_value xt_is_nullish(xt_value value) { return xt_bool(value == XT_UNDEFINED || value == XT_NULL); }
+

package/runtime/xt_io.c

@@ -0,0 +1,133 @@
+/*
+ * xbintsc runtime — exceptions and output.
+ *
+ * `try`/`catch` is a stack of setjmp frames; `xt_throw` longjmps into the
+ * innermost frame when one is active and otherwise prints + exits. Also holds
+ * `print`/`console` output and the Node-like value inspector.
+ */
+
+#include "rt_internal.h"
+
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------------- */
+/* Exceptions and output                                                     */
+/* ------------------------------------------------------------------------- */
+
+/*
+ * `try`/`catch` is implemented with a stack of setjmp frames. The compiler
+ * allocates a frame with `xt_try_enter`, calls `_setjmp` on it, and pops it
+ * with `xt_try_leave`. `xt_throw` longjmps into the innermost frame when one
+ * is active, and only prints + exits when the exception is uncaught.
+ */
+typedef struct xt_try_frame {
+  jmp_buf buf;
+  struct xt_try_frame *prev;
+  xt_value exception;
+} xt_try_frame;
+
+static xt_try_frame *g_try_top = NULL;
+
+void *xt_try_enter(void) {
+  xt_try_frame *frame = (xt_try_frame *)calloc(1, sizeof(xt_try_frame));
+  if (!frame) abort();
+  frame->prev = g_try_top;
+  frame->exception = XT_UNDEFINED;
+  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;
+}
+
+void xt_try_leave(void *framePtr) {
+  xt_try_frame *frame = (xt_try_frame *)framePtr;
+  if (frame && g_try_top == frame) g_try_top = frame->prev;
+}
+
+void xt_throw(xt_value v) {
+  if (g_try_top) {
+    g_try_top->exception = v;
+    _longjmp(g_try_top->buf, 1);
+  }
+  xt_value message = xt_to_string(v);
+  xt_string *s = xt_as_string(message);
+  fprintf(stderr, "Uncaught %s\n", s->data);
+  exit(1);
+}
+
+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);
+    return;
+  }
+  xt_value text = xt_to_string(v);
+  xt_string *s = xt_as_string(text);
+  fwrite(s->data, 1, s->length, out);
+}
+
+void xt_print(xt_value v) { xt_print_value(v, stdout); }
+void xt_println(xt_value v) {
+  xt_print_value(v, stdout);
+  fputc('\n', stdout);
+}
+
+/*
+ * console.log applies a Node-like inspection format: strings unquoted at the
+ * top level, arrays as `[ a, b ]` and objects as `{ key: value }`.
+ */
+static void xt_inspect(xt_value v, FILE *out) {
+  if (XT_IS_ARRAY(v)) {
+    xt_array *array = (xt_array *)XT_GET_PTR(v);
+    fputc('[', out);
+    for (uint32_t i = 0; i < array->length; i++) {
+      if (i > 0) fputs(", ", out);
+      else fputc(' ', out);
+      xt_inspect(array->items[i], out);
+    }
+    if (array->length > 0) fputc(' ', out);
+    fputc(']', out);
+    return;
+  }
+  if (XT_IS_OBJECT(v)) {
+    xt_object *obj = (xt_object *)XT_GET_PTR(v);
+    fputc('{', out);
+    for (uint32_t i = 0; i < obj->count; i++) {
+      if (i > 0) fputs(", ", out);
+      else fputc(' ', out);
+      fwrite(obj->properties[i].key->data, 1, obj->properties[i].key->length, out);
+      fputs(": ", out);
+      xt_inspect(obj->properties[i].value, out);
+    }
+    if (obj->count > 0) fputc(' ', out);
+    fputc('}', out);
+    return;
+  }
+  xt_print_value(v, out);
+}
+
+void xt_console_log(int32_t argc, xt_value *argv) {
+  for (int32_t i = 0; i < argc; i++) {
+    if (i > 0) fputc(' ', stdout);
+    xt_inspect(argv[i], stdout);
+  }
+  fputc('\n', stdout);
+}
+
+static void xt_console_write(int32_t argc, xt_value *argv, FILE *out) {
+  for (int32_t i = 0; i < argc; i++) {
+    if (i > 0) fputc(' ', out);
+    xt_inspect(argv[i], out);
+  }
+  fputc('\n', out);
+}
+
+void xt_console_info(int32_t argc, xt_value *argv) { xt_console_write(argc, argv, stdout); }
+void xt_console_warn(int32_t argc, xt_value *argv) { xt_console_write(argc, argv, stderr); }
+void xt_console_error(int32_t argc, xt_value *argv) { xt_console_write(argc, argv, stderr); }