@scriptc/runtime 0.0.0 → 0.0.2

package/src/scr_closure.c

@@ -0,0 +1,214 @@
+#include "scr_runtime.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef SCR_RC_AUDIT
+static long scr_live_boxes = 0;
+static long scr_live_closures = 0;
+long scr_box_live_count(void) { return scr_live_boxes; }
+long scr_closure_live_count(void) { return scr_live_closures; }
+#endif
+
+/* ── boxes ──────────────────────────────────────────────────────────────
+ * Every box carries a cycle header (a captured binding can hold anything,
+ * including the closure that captures it — the canonical cycle). The box's
+ * trace visits its payload when the payload type itself carries a header:
+ * closures always do; SCR_BOX_OBJ payloads iff the compiler passed a trace
+ * (obj_trace doubles as that flag); strings/scalars never. SCR_BOX_ARR
+ * holds acyclic arrays only — a CYCLE-CAPABLE array (traced ref elements)
+ * rides a SCR_BOX_OBJ box with the array's `_v` adapters + scr_arr_trace_v,
+ * so its edge stays visible to the collector. */
+
+static void *scr_box_ptr(const ScrBox *b) {
+  void *p;
+  memcpy(&p, &b->slot, sizeof p);
+  return p;
+}
+
+static void scr_box_trace(void *o, ScrTraceVisit visit, void *ctx) {
+  ScrBox *b = (ScrBox *)o;
+  void *p = scr_box_ptr(b);
+  if (!p) return; /* freshly-created boxes hold NULL until first write */
+  switch (b->kind) {
+  case SCR_BOX_FUNC:
+    visit(p, ctx);
+    break;
+  case SCR_BOX_OBJ:
+    if (b->obj_trace) visit(p, ctx);
+    break;
+  default:
+    break;
+  }
+}
+
+/* Teardown for the collector: release exactly the payloads the trace does
+ * NOT visit (the complement — see the contract in scr_runtime.h). */
+static void scr_box_gcfree(void *o) {
+  ScrBox *b = (ScrBox *)o;
+  void *p = scr_box_ptr(b);
+  if (p) {
+    switch (b->kind) {
+    case SCR_BOX_STR:
+      scr_str_release((ScrStr *)p);
+      break;
+    case SCR_BOX_ARR:
+      scr_arr_release((ScrArr *)p);
+      break;
+    case SCR_BOX_OBJ:
+      if (!b->obj_trace) b->obj_release(p);
+      break;
+    default: /* FUNC is traced; scalars own nothing */
+      break;
+    }
+  }
+#ifdef SCR_RC_AUDIT
+  scr_live_boxes--;
+#endif
+  scr_cyc_free(b);
+}
+
+ScrBox *scr_box_new(ScrBoxKind kind) {
+  ScrBox *b = scr_cyc_alloc(sizeof(ScrBox), &scr_box_trace, &scr_box_gcfree);
+  b->rc = 1;
+  b->kind = kind;
+#ifdef SCR_RC_AUDIT
+  scr_live_boxes++;
+#endif
+  return b;
+}
+
+ScrBox *scr_box_new_obj(void *(*retain)(void *), void (*release)(void *),
+                         ScrTraceFn trace) {
+  ScrBox *b = scr_box_new(SCR_BOX_OBJ);
+  b->obj_retain = retain;
+  b->obj_release = release;
+  b->obj_trace = trace;
+  return b;
+}
+
+/* Release one payload pointer by the box's kind. Factored so set_ref can
+ * release the value it REPLACED after the slot is already overwritten
+ * (mutators must unlink before releasing — see scr_cycle.c). */
+static void scr_box_release_payload(ScrBox *b, void *p) {
+  if (!p) return;
+  switch (b->kind) {
+  case SCR_BOX_STR:
+    scr_str_release((ScrStr *)p);
+    break;
+  case SCR_BOX_ARR:
+    scr_arr_release((ScrArr *)p);
+    break;
+  case SCR_BOX_FUNC:
+    scr_closure_release((ScrClosure *)p);
+    break;
+  case SCR_BOX_OBJ:
+    b->obj_release(p);
+    break;
+  case SCR_BOX_F64:
+  case SCR_BOX_BOOL:
+    break;
+  }
+}
+
+void scr_box_release(ScrBox *b) {
+  if (!b || b->rc == SIZE_MAX) return; /* NULL: a switch jumped past the decl */
+  if (--b->rc == 0) {
+    scr_cyc_on_dead(b);
+    scr_box_release_payload(b, scr_box_ptr(b));
+#ifdef SCR_RC_AUDIT
+    scr_live_boxes--;
+#endif
+    scr_cyc_free(b);
+  } else {
+    scr_cyc_on_release(b); /* possible cycle root; may collect — b is done */
+  }
+}
+
+double scr_box_get_f64(ScrBox *b) {
+  double v;
+  memcpy(&v, &b->slot, sizeof v);
+  return v;
+}
+
+bool scr_box_get_bool(ScrBox *b) { return b->slot != 0; }
+
+void *scr_box_get_ref(ScrBox *b) {
+  void *p = scr_box_ptr(b);
+  switch (b->kind) {
+  case SCR_BOX_STR:
+    return scr_str_retain((ScrStr *)p);
+  case SCR_BOX_ARR:
+    return scr_arr_retain((ScrArr *)p);
+  case SCR_BOX_FUNC:
+    return scr_closure_retain((ScrClosure *)p);
+  case SCR_BOX_OBJ:
+    return b->obj_retain(p);
+  default:
+    fputs("scriptc: internal error: box_get_ref on a scalar box\n", stderr);
+    abort();
+  }
+}
+
+void scr_box_set_f64(ScrBox *b, double v) { memcpy(&b->slot, &v, sizeof v); }
+
+void scr_box_set_bool(ScrBox *b, bool v) { b->slot = v ? 1 : 0; }
+
+void scr_box_set_ref(ScrBox *b, void *v) {
+  /* Unlink-then-release: the slot must already hold the new value when the
+   * old one's release runs (it can trigger a collection, which must not
+   * walk the b→old edge whose count was just given up). */
+  void *old = scr_box_ptr(b);
+  memcpy(&b->slot, &v, sizeof v);
+  scr_box_release_payload(b, old);
+}
+
+/* ── closures ─────────────────────────────────────────────────────────── */
+
+static void scr_closure_trace(void *o, ScrTraceVisit visit, void *ctx) {
+  ScrClosure *c = (ScrClosure *)o;
+  for (size_t i = 0; i < c->ncaps; i++) visit(c->caps[i], ctx);
+}
+
+static void scr_closure_gcfree(void *o) {
+  /* Caps are all boxes — all traced. The own-property table (props) is
+   * an untraced box: released here like any external owned edge. */
+  scr_box_release(((ScrClosure *)o)->props);
+#ifdef SCR_RC_AUDIT
+  scr_live_closures--;
+#endif
+  scr_cyc_free(o);
+}
+
+ScrClosure *scr_closure_new(void *fn, size_t ncaps) {
+  ScrClosure *c = scr_cyc_alloc(sizeof(ScrClosure) + ncaps * sizeof(ScrBox *),
+                                 &scr_closure_trace, &scr_closure_gcfree);
+  c->rc = 1;
+  c->fn = fn;
+  c->ncaps = ncaps;
+  c->props = NULL; /* lazily allocated by Object.defineProperties */
+#ifdef SCR_RC_AUDIT
+  scr_live_closures++;
+#endif
+  return c;
+}
+
+void scr_closure_release(ScrClosure *c) {
+  if (!c || c->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
+  if (--c->rc == 0) {
+    scr_cyc_on_dead(c);
+    for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
+    scr_box_release(c->props); /* NULL-tolerant */
+#ifdef SCR_RC_AUDIT
+    scr_live_closures--;
+#endif
+    scr_cyc_free(c);
+  } else {
+    scr_cyc_on_release(c); /* possible cycle root; may collect — c is done */
+  }
+}
+
+void scr_closure_trace_v(void *c, ScrTraceVisit visit, void *ctx) {
+  scr_closure_trace(c, visit, ctx);
+}

package/src/scr_console.c

@@ -0,0 +1,143 @@
+#include "scr_runtime.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <fcntl.h> /* _O_BINARY */
+#include <io.h>    /* _setmode, _fileno */
+#endif
+
+/* Set by scr_async.c at loop exhaustion; lives here (unconditionally) so
+ * binaries that link the console without the async runtime still link, and
+ * plain builds satisfy scr_async's reference. */
+static long scr_abandoned_fibers = 0;
+void scr_note_abandoned_fibers(long n) { scr_abandoned_fibers = n; }
+
+#ifdef SCR_RC_AUDIT
+extern long scr_str_live_count(void);     /* scr_string.c */
+extern long scr_arr_live_count(void);     /* scr_array.c */
+extern long scr_map_live_count(void);     /* scr_map.c */
+extern long scr_box_live_count(void);     /* scr_closure.c */
+extern long scr_closure_live_count(void); /* scr_closure.c */
+extern long scr_obj_live_count(void);     /* scr_object.c */
+extern long scr_union_live_count(void);   /* scr_union.c */
+extern long scr_dyn_live_count(void);     /* scr_json.c */
+extern long scr_bytes_live_count(void);   /* scr_bytes.c */
+#ifdef SCR_DYNAMIC
+extern long scr_jsval_live_count(void); /* scr_island.c */
+#endif
+
+static void scr_rc_audit_at_exit(void) {
+  /* Fibers suspended forever at loop exhaustion (awaits nobody resolves —
+   * Node exits 0 there too) still hold their stacks and owned values by
+   * design; a strict audit would only report that deliberate abandonment. */
+  if (scr_abandoned_fibers > 0) {
+    fprintf(stderr, "scriptc RC audit skipped: %ld fiber(s) never resumed\n",
+            scr_abandoned_fibers);
+    return;
+  }
+  long strings = scr_str_live_count();
+  long arrays = scr_arr_live_count();
+  long maps = scr_map_live_count();
+  long boxes = scr_box_live_count();
+  long closures = scr_closure_live_count();
+  long objects = scr_obj_live_count();
+  long unions = scr_union_live_count();
+  long dyns = scr_dyn_live_count();
+  long bytes = scr_bytes_live_count();
+#ifdef SCR_DYNAMIC
+  long jsvals = scr_jsval_live_count();
+#else
+  long jsvals = 0;
+#endif
+  if (strings != 0 || arrays != 0 || maps != 0 || boxes != 0 || closures != 0 ||
+      objects != 0 || unions != 0 || dyns != 0 || bytes != 0 || jsvals != 0) {
+    fflush(stdout);
+    fprintf(stderr,
+            "scriptc RC AUDIT FAILED: %ld heap string(s), %ld array(s), "
+            "%ld map(s), %ld box(es), %ld closure(s), %ld object(s), "
+            "%ld union(s), %ld dyn value(s), %ld bytes value(s), "
+            "%ld island value(s) live at exit\n",
+            strings, arrays, maps, boxes, closures, objects, unions, dyns,
+            bytes, jsvals);
+    _Exit(99);
+  }
+}
+#endif
+
+static void scr_flush_at_exit(void) { fflush(stdout); }
+
+static void scr_collect_cycles_at_exit(void) { scr_collect_cycles(); }
+
+void scr_init(void) {
+#ifdef _WIN32
+  /* The CRT opens std streams in TEXT mode, which writes \n as \r\n. Node
+   * on Windows does NOT translate — console.log emits \n whether stdout is
+   * a pipe or the console (libuv writes the bytes as given) — so the
+   * streams switch to binary here or every line would differ from the
+   * oracle by a byte. stdin too: readFileSync(0) must see the bytes on the
+   * pipe, not a CRLF-collapsed view. */
+  _setmode(_fileno(stdout), _O_BINARY);
+  _setmode(_fileno(stderr), _O_BINARY);
+  _setmode(_fileno(stdin), _O_BINARY);
+#endif
+  /* Full buffering matches Node writing to a pipe (the differential harness
+   * never runs either side on a TTY) and makes output-heavy programs fast. */
+  static char outbuf[1 << 16];
+  setvbuf(stdout, outbuf, _IOFBF, sizeof outbuf);
+  /* atexit is LIFO; registration order makes exit run: library cleanup
+   * (registered later, in scr_lib_init) → cycle collection → RC audit →
+   * flush. The final collection frees cycles the program dropped, so the
+   * audit (and ASan's leak check) see them as freed, not leaked. */
+  atexit(scr_flush_at_exit);
+#ifdef SCR_RC_AUDIT
+  atexit(scr_rc_audit_at_exit);
+#endif
+  atexit(scr_collect_cycles_at_exit);
+}
+
+/* ONE formatter for both console streams — console.error/warn print
+ * byte-identically to console.log in Node (same inspect rendering), only
+ * the stream differs. */
+static void scr_console_write(FILE *out, size_t n, const ScrLogArg *args) {
+  char numbuf[32];
+  for (size_t i = 0; i < n; i++) {
+    if (i > 0) fputc(' ', out);
+    const ScrLogArg *a = &args[i];
+    switch (a->tag) {
+    case SCR_ARG_F64: {
+      /* console.log renders numbers via inspect, which distinguishes -0
+       * (String(-0) is "0", but console.log(-0) prints "-0"). */
+      if (a->v.f == 0 && signbit(a->v.f)) {
+        fputs("-0", out);
+        break;
+      }
+      size_t len = scr_f64_to_str(a->v.f, numbuf);
+      fwrite(numbuf, 1, len, out);
+      break;
+    }
+    case SCR_ARG_STR:
+      fwrite(a->v.s->data, 1, a->v.s->len, out);
+      break;
+    case SCR_ARG_BOOL:
+      fputs(a->v.b ? "true" : "false", out);
+      break;
+    }
+  }
+  fputc('\n', out);
+}
+
+void scr_console_log(size_t n, const ScrLogArg *args) {
+  scr_console_write(stdout, n, args);
+}
+
+/* console.error and console.warn. stderr is UNBUFFERED (C's default; Node
+ * writes stderr synchronously too), and stdout FLUSHES first so a merged
+ * redirection (2>&1) sees writes in source order despite stdout's full
+ * buffering — Node's piped stdout/stderr preserve write order the same
+ * way. */
+void scr_console_error(size_t n, const ScrLogArg *args) {
+  fflush(stdout);
+  scr_console_write(stderr, n, args);
+}

package/src/scr_cycle.c

@@ -0,0 +1,218 @@
+/* Reference-cycle collector: synchronous Bacon–Rajan trial deletion (see
+ * "Concurrent Cycle Collection in Reference Counted Systems", the
+ * synchronous algorithm) over cycle-headered objects only — the object
+ * model and the trace/teardown contract live in scr_runtime.h.
+ *
+ * Life of a candidate: a release that leaves rc > 0 buffers the object
+ * (purple). Collection walks the buffer in three phases over the graph
+ * reachable from it:
+ *   markGray     trial-delete: decrement rc once per internal edge;
+ *   scan         nodes still rc > 0 are externally referenced — re-blacken
+ *                their subgraph and restore the trial decrements;
+ *   collectWhite everything left white is a dead cycle: free it, releasing
+ *                only edges that LEAVE the white set (each member's
+ *                teardown releases its untraced children; traced edges were
+ *                already accounted by markGray).
+ * The white set is gathered first and freed after the walk — freeing
+ * during the walk would leave dangling sibling edges for later visits.
+ *
+ * Correctness leans on two global invariants (docs/memory.md):
+ * - every strong reference is counted: stacks, locals, and runtime-owned
+ *   buffers (timer callbacks, unhandled-rejection tracking) all hold +1,
+ *   so trial deletion can never free something a root still reaches;
+ * - mutators unlink before they release: a heap object's stored pointer is
+ *   overwritten BEFORE the old value's release runs, so a threshold
+ *   collection triggered inside that release never sees an edge whose
+ *   count was already given up (which would over-decrement and free live
+ *   data).
+ *
+ * Recursion depth equals the traced structure's depth — same property as
+ * the existing recursive releases (deep lists recurse deeply; acceptable
+ * for now, revisit with an explicit stack if it ever traps).
+ */
+#include "scr_runtime.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Every heap object's first member is `size_t rc`. */
+#define SCR_RC(obj) (*(size_t *)(obj))
+
+static void scr_cyc_oom(void) {
+  fputs("scriptc: out of memory\n", stderr);
+  abort();
+}
+
+void *scr_cyc_alloc(size_t size, ScrTraceFn trace, ScrCycFreeFn free_fn) {
+  ScrCycHdr *h = calloc(1, sizeof(ScrCycHdr) + size);
+  if (!h) scr_cyc_oom();
+  h->trace = trace;
+  h->free_fn = free_fn;
+  h->color = SCR_CYC_BLACK;
+  return h + 1;
+}
+
+void scr_cyc_free(void *obj) { free(scr_cyc_hdr(obj)); }
+
+/* ── the candidate-root buffer ────────────────────────────────────────── */
+
+static void **scr_roots = NULL;
+static size_t scr_nroots = 0, scr_roots_cap = 0;
+static bool scr_collecting = false;
+
+static size_t scr_cyc_threshold(void) {
+  static size_t cached = 0;
+  if (cached == 0) {
+    const char *env = getenv("SCR_CYCLE_THRESHOLD");
+    long v = env ? strtol(env, NULL, 10) : 0;
+    cached = v > 0 ? (size_t)v : 256;
+  }
+  return cached;
+}
+
+void scr_cyc_on_dead(void *obj) {
+  ScrCycHdr *h = scr_cyc_hdr(obj);
+  if (!h->buffered) return;
+  /* O(1) removal: swap the last entry into the hole. */
+  size_t i = h->buf_index;
+  void *last = scr_roots[--scr_nroots];
+  scr_roots[i] = last;
+  if (last != obj) scr_cyc_hdr(last)->buf_index = i;
+  h->buffered = 0;
+}
+
+void scr_cyc_on_release(void *obj) {
+  ScrCycHdr *h = scr_cyc_hdr(obj);
+  h->color = SCR_CYC_PURPLE;
+  if (!h->buffered) {
+    if (scr_nroots == scr_roots_cap) {
+      scr_roots_cap = scr_roots_cap ? scr_roots_cap * 2 : 64;
+      scr_roots = realloc(scr_roots, scr_roots_cap * sizeof *scr_roots);
+      if (!scr_roots) scr_cyc_oom();
+    }
+    h->buffered = 1;
+    h->buf_index = scr_nroots;
+    scr_roots[scr_nroots++] = obj;
+  }
+  /* Threshold trigger. Never re-entered: a teardown's releases of untraced
+   * children can buffer new candidates mid-collection, but they only wait
+   * for the next pass. */
+  if (!scr_collecting && scr_nroots >= scr_cyc_threshold()) {
+    scr_collect_cycles();
+  }
+}
+
+/* ── trial deletion ───────────────────────────────────────────────────── */
+
+/* Child filter shared by every phase: nothing to do for NULL (unassigned
+ * slots) or immortal (interned statics have no header at all). */
+#define SCR_CYC_SKIP(child) ((child) == NULL || SCR_RC(child) == SIZE_MAX)
+
+static void scr_mark_gray(void *obj);
+static void scr_mg_visit(void *child, void *ctx) {
+  (void)ctx;
+  if (SCR_CYC_SKIP(child)) return;
+  SCR_RC(child) -= 1; /* trial-delete this internal edge */
+  scr_mark_gray(child);
+}
+static void scr_mark_gray(void *obj) {
+  ScrCycHdr *h = scr_cyc_hdr(obj);
+  if (h->color == SCR_CYC_GRAY) return;
+  h->color = SCR_CYC_GRAY;
+  h->trace(obj, scr_mg_visit, NULL);
+}
+
+static void scr_scan_black(void *obj);
+static void scr_sb_visit(void *child, void *ctx) {
+  (void)ctx;
+  if (SCR_CYC_SKIP(child)) return;
+  SCR_RC(child) += 1; /* restore the trial decrement */
+  if (scr_cyc_hdr(child)->color != SCR_CYC_BLACK) scr_scan_black(child);
+}
+static void scr_scan_black(void *obj) {
+  scr_cyc_hdr(obj)->color = SCR_CYC_BLACK;
+  scr_cyc_hdr(obj)->trace(obj, scr_sb_visit, NULL);
+}
+
+static void scr_scan(void *obj);
+static void scr_scan_visit(void *child, void *ctx) {
+  (void)ctx;
+  if (SCR_CYC_SKIP(child)) return;
+  scr_scan(child);
+}
+static void scr_scan(void *obj) {
+  ScrCycHdr *h = scr_cyc_hdr(obj);
+  if (h->color != SCR_CYC_GRAY) return;
+  if (SCR_RC(obj) > 0) {
+    /* Externally referenced: this whole subgraph stays. */
+    scr_scan_black(obj);
+    return;
+  }
+  h->color = SCR_CYC_WHITE;
+  h->trace(obj, scr_scan_visit, NULL);
+}
+
+/* The gathered white set (freed after the walk completes). */
+static void **scr_white = NULL;
+static size_t scr_nwhite = 0, scr_white_cap = 0;
+
+static void scr_collect_white(void *obj);
+static void scr_cw_visit(void *child, void *ctx) {
+  (void)ctx;
+  if (SCR_CYC_SKIP(child)) return;
+  scr_collect_white(child);
+}
+static void scr_collect_white(void *obj) {
+  ScrCycHdr *h = scr_cyc_hdr(obj);
+  if (h->color != SCR_CYC_WHITE || h->buffered) return;
+  h->color = SCR_CYC_BLACK; /* visited marker — prevents re-gathering */
+  h->trace(obj, scr_cw_visit, NULL);
+  if (scr_nwhite == scr_white_cap) {
+    scr_white_cap = scr_white_cap ? scr_white_cap * 2 : 64;
+    scr_white = realloc(scr_white, scr_white_cap * sizeof *scr_white);
+    if (!scr_white) scr_cyc_oom();
+  }
+  scr_white[scr_nwhite++] = obj;
+}
+
+void scr_collect_cycles(void) {
+  if (scr_collecting || scr_nroots == 0) return;
+  scr_collecting = true;
+
+  /* markRoots: keep live candidates (still purple), drop the rest — an
+   * object re-retained since buffering is black; one grayed by an earlier
+   * candidate's walk is already covered by that candidate's subgraph. */
+  size_t out = 0;
+  for (size_t i = 0; i < scr_nroots; i++) {
+    void *obj = scr_roots[i];
+    ScrCycHdr *h = scr_cyc_hdr(obj);
+    if (h->color == SCR_CYC_PURPLE) {
+      scr_mark_gray(obj);
+      h->buf_index = out;
+      scr_roots[out++] = obj;
+    } else {
+      h->buffered = 0;
+    }
+  }
+  scr_nroots = out;
+
+  for (size_t i = 0; i < scr_nroots; i++) scr_scan(scr_roots[i]);
+
+  /* collectWhite over a drained buffer: clear every buffered flag first so
+   * the recursion can gather buffered members of an earlier root's cycle. */
+  size_t n = scr_nroots;
+  scr_nroots = 0;
+  for (size_t i = 0; i < n; i++) scr_cyc_hdr(scr_roots[i])->buffered = 0;
+  scr_nwhite = 0;
+  for (size_t i = 0; i < n; i++) scr_collect_white(scr_roots[i]);
+  /* Teardowns run after the full walk. They may release untraced children
+   * (plain RC) — which can re-buffer survivors for the NEXT pass — but
+   * never touch traced (white, already-accounted) edges. */
+  for (size_t i = 0; i < scr_nwhite; i++) {
+    void *obj = scr_white[i];
+    scr_cyc_hdr(obj)->free_fn(obj);
+  }
+  scr_nwhite = 0;
+
+  scr_collecting = false;
+}