xbintsc 0.1.6 → 0.1.9

package/runtime/rt_internal.h

@@ -0,0 +1,169 @@
+/*
+ * 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
+#define XT_OBJECT_KIND_PROMISE 5
+#define XT_OBJECT_KIND_MAP 6
+#define XT_OBJECT_KIND_SET 7
+#define XT_OBJECT_KIND_DATE 8
+#define XT_OBJECT_KIND_REGEXP 9
+#define XT_OBJECT_KIND_SYMBOL 10
+
+/* 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_value prototype;
+  uint8_t frozen;
+  uint8_t is_array_base;
+  uint16_t reserved2;
+} 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_value prototype;
+} 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);
+
+/* Object helpers used by the standard library. */
+xt_object *xt_as_object(xt_value value);
+xt_property *xt_object_find_property(xt_object *obj, xt_string *key);
+
+/* Map / Set / Promise / Date / RegExp live in xt_stdlib.c and xt_promise.c. */
+int xt_is_promise(xt_value value);
+int xt_is_map(xt_value value);
+int xt_is_set(xt_value value);
+int xt_is_date(xt_value value);
+int xt_is_regexp(xt_value value);
+int32_t xt_map_size(xt_value value);
+int32_t xt_set_size(xt_value value);
+
+/* -- collection / date / regexp representations --------------------------- */
+typedef struct {
+  xt_header header;
+  xt_value *keys;
+  xt_value *values;
+  uint32_t count;
+  uint32_t capacity;
+} xt_map;
+
+typedef struct {
+  xt_header header;
+  xt_value *values;
+  uint32_t count;
+  uint32_t capacity;
+} xt_set_object;
+
+typedef struct {
+  xt_header header;
+  double time;
+} xt_date;
+
+typedef struct {
+  xt_header header;
+  xt_value source;
+  xt_value flags;
+} xt_regexp;
+
+/* Extended method dispatch (xt_stdlib2.c). `*handled` is set when the method
+ * was recognised, allowing an intentional `undefined` result to be returned. */
+xt_value xt_ext_array_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_string_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_number_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_object_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_ext_container_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+xt_value xt_promise_method(xt_value target, const char *method, int32_t argc, xt_value *argv, int *handled);
+
+/* JSON helpers used by Promise / Map immutability checks. */
+int xt_value_equals(xt_value a, xt_value b);
+
+/* 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,238 @@
+/*
+ * 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;
+  function->prototype = XT_UNDEFINED;
+  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) {
+  return xt_call_with_this(value, XT_UNDEFINED, argc, argv);
+}
+
+xt_value xt_call_with_this(xt_value value, xt_value thisValue, 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(thisValue, value, argc, argv);
+}
+
+xt_value xt_this(void) { return XT_UNDEFINED; }
+
+xt_value xt_function_set_prototype(xt_value value, xt_value proto) {
+  if (XT_IS_FUNCTION(value)) ((xt_function *)XT_GET_PTR(value))->prototype = proto;
+  return value;
+}
+
+xt_value xt_function_get_prototype(xt_value value) {
+  if (XT_IS_FUNCTION(value)) return ((xt_function *)XT_GET_PTR(value))->prototype;
+  return XT_UNDEFINED;
+}
+
+xt_value xt_new(xt_value ctor, int32_t argc, xt_value *argv) {
+  if (!XT_IS_FUNCTION(ctor)) {
+    xt_throw(xt_string_from_cstr("TypeError: constructor is not a function"));
+    return XT_UNDEFINED;
+  }
+  xt_function *function = (xt_function *)XT_GET_PTR(ctor);
+  xt_value proto = function->prototype;
+  xt_value instance = xt_object_new_with_proto(XT_IS_OBJECT(proto) ? proto : XT_UNDEFINED);
+  xt_value result = function->code(instance, ctor, argc, argv);
+  if (XT_IS_OBJECT(result) || XT_IS_ARRAY(result)) return result;
+  return instance;
+}
+
+xt_value xt_instance_of(xt_value value, xt_value ctor) {
+  if (!XT_IS_FUNCTION(ctor)) return XT_FALSE;
+  xt_value proto = ((xt_function *)XT_GET_PTR(ctor))->prototype;
+  if (!XT_IS_OBJECT(proto)) return XT_FALSE;
+  if (!XT_IS_OBJECT(value)) return XT_FALSE;
+  xt_object *cur = (xt_object *)XT_GET_PTR(value);
+  xt_object *target = (xt_object *)XT_GET_PTR(proto);
+  cur = (xt_object *)XT_GET_PTR(XT_IS_OBJECT(cur->prototype) ? cur->prototype : XT_UNDEFINED);
+  while (cur) {
+    if (cur == target) return XT_TRUE;
+    if (!XT_IS_OBJECT(cur->prototype)) break;
+    cur = (xt_object *)XT_GET_PTR(cur->prototype);
+  }
+  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);
+  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;
+}
+