@scriptc/cli-darwin-x64 0.2.3 → 0.2.5

package/dist/lib/runtime-sources/src/scr_bytes.test.c

@@ -0,0 +1,85 @@
+#include "scr_runtime.h"
+#include <assert.h>
+#include <math.h>
+#include <string.h>
+
+long scr_bytes_live_count(void);
+
+/* Foreign wrappers may alias without a shared owner and may be unaligned. */
+static ScrBytes *external(uint8_t *data, ScrBytesElem elem, size_t count) {
+  ScrBytes *view = scr_bytes_from_external(data, count * scr_bytes_elem_size(elem));
+  view->elem = elem;
+  view->len = count;
+  return view;
+}
+
+static void external_set(void) {
+  const size_t starts[] = {1, 9, 41, 3001};
+  uint8_t storage[6000], expected[6000];
+  for (ScrBytesElem from = SCR_BYTES_U8; from <= SCR_BYTES_U8C; from++) {
+    for (ScrBytesElem to = SCR_BYTES_U8; to <= SCR_BYTES_U8C; to++) {
+      for (size_t j = 0; j < sizeof starts / sizeof starts[0]; j++) {
+        memset(storage, 0x5a, sizeof storage);
+        ScrBytes *src = external(storage + 9, from, 259);
+        ScrBytes *dst = external(storage + starts[j], to, 263);
+        for (size_t i = 0; i < src->len; i++) scr_bytes_set(src, i, (double)i * 3.5 - 257);
+        memcpy(expected, storage, sizeof storage);
+        ScrBytes *want = external(expected + starts[j], to, 263);
+        for (size_t i = 0; i < src->len; i++) scr_bytes_set(want, i + 2, scr_bytes_get(src, i));
+        scr_bytes_set_from(dst, src, 2);
+        assert(!scr_exc_pending());
+        assert(memcmp(storage, expected, sizeof storage) == 0);
+        scr_bytes_release(want);
+        scr_bytes_release(dst);
+        scr_bytes_release(src);
+      }
+    }
+  }
+}
+
+static void copied_storage(void) {
+  /* Same-kind copies preserve NaN payloads, signed zero and ownership. */
+  const uint64_t bits[] = {UINT64_C(0x7ff8000000000042), UINT64_C(0x8000000000000000),
+                           UINT64_C(0xfff0000000000000)};
+  ScrBytes *src = scr_bytes_new(SCR_BYTES_F64, 3);
+  memcpy(src->data, bits, sizeof bits);
+  ScrBytes *copy = scr_bytes_convert(SCR_BYTES_F64, src);
+  ScrBytes *slice = scr_bytes_slice(src, 0, 3);
+  assert(copy->data != src->data && slice->data != src->data);
+  assert(memcmp(copy->data, bits, sizeof bits) == 0);
+  assert(memcmp(slice->data, bits, sizeof bits) == 0);
+  ScrBytes *view = scr_bytes_subarray(copy, 1, 3);
+  scr_bytes_release(copy);
+  scr_bytes_release(src);
+  assert(memcmp(view->data, bits + 1, sizeof bits - sizeof bits[0]) == 0);
+  scr_bytes_release(view);
+  scr_bytes_release(slice);
+}
+
+static void filled_storage(void) {
+  uint8_t storage[2200], expected[2200];
+  const double values[] = {-0.0, -1.5, 2.5, 255.5, 4294967297.0, NAN, INFINITY};
+  for (ScrBytesElem elem = SCR_BYTES_U8; elem <= SCR_BYTES_U8C; elem++) {
+    for (size_t j = 0; j < sizeof values / sizeof values[0]; j++) {
+      memset(storage, 0xa5, sizeof storage);
+      memcpy(expected, storage, sizeof storage);
+      ScrBytes *dst = external(storage + 1, elem, 263);
+      ScrBytes *want = external(expected + 1, elem, 263);
+      for (size_t i = 2; i < 261; i++) scr_bytes_set(want, i, values[j]);
+      ScrBytes *result = scr_bytes_fill_elem(dst, values[j], 2, 261);
+      assert(result == dst && dst->rc == 2);
+      assert(memcmp(storage, expected, sizeof storage) == 0);
+      scr_bytes_release(result);
+      scr_bytes_release(dst);
+      scr_bytes_release(want);
+    }
+  }
+}
+
+void scr_bytes_test_bulk_storage(void) {
+  long before = scr_bytes_live_count();
+  external_set();
+  copied_storage();
+  filled_storage();
+  assert(scr_bytes_live_count() == before);
+}

package/dist/lib/runtime-sources/src/scr_bytes_io.c

@@ -37,40 +37,6 @@ static void scr_bytes_io_oom(void) {
 
 /* ── fs (the Buffer forms of scr_lib.c's utf8 pair) ────────────────────── */
 
-ScrBytes *scr_fs_read_file_bytes(ScrStr *path) {
-  FILE *f = fopen(path->data, "rb");
-  if (!f) {
-    scr_fs_throw(errno, "open", path);
-    return NULL;
-  }
-  size_t cap = 4096, len = 0;
-  uint8_t *buf = malloc(cap);
-  if (!buf) scr_bytes_io_oom();
-  for (;;) {
-    if (cap - len < 2048) {
-      cap *= 2;
-      uint8_t *grown = realloc(buf, cap);
-      if (!grown) scr_bytes_io_oom();
-      buf = grown;
-    }
-    size_t n = fread(buf + len, 1, cap - len, f);
-    len += n;
-    if (n == 0) break;
-  }
-  if (ferror(f)) {
-    int e = errno;
-    fclose(f);
-    free(buf);
-    scr_fs_throw(e, "read", path);
-    return NULL;
-  }
-  fclose(f);
-  ScrBytes *b = scr_bytes_new(SCR_BYTES_U8, (double)len);
-  memcpy(b->data, buf, len);
-  free(buf);
-  return b;
-}
-
 /* readFileSync's runtime-encoding form (a JS helper's untyped `enc`
  * parameter — test/common fixtures.js): undefined/null answer a Buffer,
  * utf8 answers a string, Node's other real encodings meet the loud

package/dist/lib/runtime-sources/src/scr_copying.c

@@ -125,9 +125,19 @@ ScrArr *scr_arr_with_undefined(ScrArr *a, double index) {
 
 ScrBytes *scr_bytes_to_reversed(const ScrBytes *b) {
   ScrBytes *out = scr_bytes_new(b->elem, (double)b->len);
+  size_t width = scr_bytes_elem_size(b->elem);
+  /* Copy the stored representation without numeric conversion. Views may
+   * be unaligned, so fixed-width memcpy preserves both alignment safety
+   * and floating-point payload bits. The width is invariant for the loop. */
   for (size_t i = 0; i < b->len; i++) {
-    scr_bytes_set(out, (double)i,
-                  scr_bytes_get(b, (double)(b->len - i - 1)));
+    const uint8_t *source = b->data + (b->len - i - 1) * width;
+    uint8_t *target = out->data + i * width;
+    switch (width) {
+    case 1: *target = *source; break;
+    case 2: memcpy(target, source, 2); break;
+    case 4: memcpy(target, source, 4); break;
+    case 8: memcpy(target, source, 8); break;
+    }
   }
   return out;
 }

package/dist/lib/runtime-sources/src/scr_cycle.c

@@ -9,7 +9,7 @@
  *   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
+ *   gather       filter the scanned white set, then 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).
@@ -26,9 +26,10 @@
  *   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).
+ * The main graph phases keep a bounded depth-first walk and defer deeper
+ * traces to reusable worklists. Ordinary RC destruction and cross-generation
+ * releases are separate paths. White candidates are recorded during scan
+ * and filtered after outside roots settle, avoiding a separate gather walk.
  *
  * ── generations ──────────────────────────────────────────────────────
  * A pass costs O(objects reachable from its candidates), and a candidate
@@ -154,6 +155,12 @@ static SCR_TL ScrVec scr_cands;
 /* Nursery survivors awaiting promotion (see scr_scan_black). */
 static SCR_TL ScrVec scr_promote;
 
+/* Deferred traces cap recursive traversal without changing the common
+ * depth-first walk. Restore can run inside scan, so it has its own stack. */
+static SCR_TL ScrVec scr_pending;
+static SCR_TL ScrVec scr_restore_pending;
+#define SCR_CYC_WALK_DEPTH 64
+
 /* The gathered white set (freed after the walk completes). */
 static SCR_TL ScrVec scr_white;
 
@@ -281,14 +288,15 @@ void scr_cyc_on_dead(void *obj) {
 void scr_cyc_on_release(void *obj) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
   h->color = SCR_CYC_PURPLE;
-  if (!h->buffered) {
-    ScrVec *b = &scr_roots[h->gen];
-    if (b->n == b->cap) scr_cyc_grow(b);
-    h->buffered = 1;
-    h->buf_index = b->n;
-    b->v[b->n++] = obj;
-    scr_cyc_nbuffered++;
-  }
+  /* Releasing an existing candidate cannot advance the trigger. A pass
+   * always re-arms after its teardowns, including any candidates they add. */
+  if (h->buffered) return;
+  ScrVec *b = &scr_roots[h->gen];
+  if (b->n == b->cap) scr_cyc_grow(b);
+  h->buffered = 1;
+  h->buf_index = b->n;
+  b->v[b->n++] = obj;
+  scr_cyc_nbuffered++;
   /* 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_cyc_nbuffered >= scr_cyc_trigger)
@@ -306,69 +314,68 @@ void scr_cyc_on_release(void *obj) {
   ((child) == NULL || SCR_RC(child) == SIZE_MAX \
    || scr_cyc_hdr(child)->gen > scr_gen_limit)
 
-static void scr_mark_gray(void *obj);
+/* Trace callbacks forward an integer depth through their opaque context;
+ * it is never dereferenced. The ABI already carries it through every edge. */
+static void scr_mark_gray(void *obj, uintptr_t depth);
 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);
+  SCR_RC(child) -= 1;
+  scr_mark_gray(child, (uintptr_t)ctx);
 }
-static void scr_mark_gray(void *obj) {
+static void scr_mark_gray(void *obj, uintptr_t depth) {
   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);
+  if (depth == SCR_CYC_WALK_DEPTH) {
+    scr_cyc_push(&scr_pending, obj);
+    return;
+  }
+  h->trace(obj, scr_mg_visit, (void *)(depth + 1));
 }
 
-static void scr_scan_black(void *obj);
+static void scr_scan_black(void *obj, uintptr_t depth);
 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);
+  SCR_RC(child) += 1;
+  if (scr_cyc_hdr(child)->color != SCR_CYC_BLACK)
+    scr_scan_black(child, (uintptr_t)ctx);
 }
-static void scr_scan_black(void *obj) {
+static void scr_scan_black(void *obj, uintptr_t depth) {
   ScrCycHdr *h = scr_cyc_hdr(obj);
   h->color = SCR_CYC_BLACK;
-  /* Blackening is what proves a walked object survives, so this is where
-   * promotion is decided — but it is only RECORDED here. Raising `gen` now
-   * would hide the object from SCR_CYC_SKIP partway through the pass, and
-   * this phase has trial decrements left to restore. */
-  if (h->gen < SCR_CYC_MATURE)
-    scr_cyc_push(&scr_promote, obj);
-  h->trace(obj, scr_sb_visit, NULL);
+  if (h->gen < SCR_CYC_MATURE) scr_cyc_push(&scr_promote, obj);
+  if (depth == SCR_CYC_WALK_DEPTH) {
+    scr_cyc_push(&scr_restore_pending, obj);
+    return;
+  }
+  h->trace(obj, scr_sb_visit, (void *)(depth + 1));
 }
 
-static void scr_scan(void *obj);
+static void scr_scan(void *obj, uintptr_t depth);
 static void scr_scan_visit(void *child, void *ctx) {
-  (void)ctx;
   if (SCR_CYC_SKIP(child)) return;
-  scr_scan(child);
+  scr_scan(child, (uintptr_t)ctx);
 }
-static void scr_scan(void *obj) {
+static void scr_scan(void *obj, uintptr_t depth) {
   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);
+    scr_scan_black(obj, 0);
+    while (scr_restore_pending.n) {
+      void *next = scr_restore_pending.v[--scr_restore_pending.n];
+      scr_cyc_hdr(next)->trace(next, scr_sb_visit, NULL);
+    }
     return;
   }
   h->color = SCR_CYC_WHITE;
-  h->trace(obj, scr_scan_visit, NULL);
-}
-
-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_DOOMED; /* gathered — don't gather twice */
-  h->trace(obj, scr_cw_visit, NULL);
+  /* Record each whitened object once. A later outside root can restore it;
+   * filter the list only after every scan finishes. No gather trace needed. */
   scr_cyc_push(&scr_white, obj);
+  if (depth == SCR_CYC_WALK_DEPTH) {
+    scr_cyc_push(&scr_pending, obj);
+    return;
+  }
+  h->trace(obj, scr_scan_visit, (void *)(depth + 1));
 }
 
 /* ── cross-generation edges ───────────────────────────────────────────── */
@@ -443,12 +450,10 @@ static size_t scr_cyc_pass(unsigned gen_limit) {
   scr_gen_limit = gen_limit;
 
   /* 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. The
-   * buffers are drained up front (markGray only touches counts directly,
-   * so nothing can re-buffer underneath us) which leaves collectWhite free
-   * to gather members of an earlier root's cycle. Candidates ABOVE the
-   * limit keep their buffer slots and wait for a full pass. */
+   * object re-retained since buffering is black. Drain the buffers before
+   * walking: tracing only adjusts counts and worklists, so nothing can
+   * re-buffer underneath us. Candidates ABOVE the limit keep their slots
+   * and wait for a full pass. */
   scr_cands.n = 0;
   for (unsigned g = 0; g <= gen_limit; g++) {
     for (size_t i = 0; i < scr_roots[g].n; i++) {
@@ -460,12 +465,31 @@ static size_t scr_cyc_pass(unsigned gen_limit) {
     }
     scr_roots[g].n = 0;
   }
-  for (size_t i = 0; i < scr_cands.n; i++) scr_mark_gray(scr_cands.v[i]);
-
-  for (size_t i = 0; i < scr_cands.n; i++) scr_scan(scr_cands.v[i]);
+  for (size_t i = 0; i < scr_cands.n; i++) scr_mark_gray(scr_cands.v[i], 0);
+  while (scr_pending.n) {
+    void *obj = scr_pending.v[--scr_pending.n];
+    scr_cyc_hdr(obj)->trace(obj, scr_mg_visit, NULL);
+  }
 
   scr_white.n = 0;
-  for (size_t i = 0; i < scr_cands.n; i++) scr_collect_white(scr_cands.v[i]);
+  for (size_t i = 0; i < scr_cands.n; i++) scr_scan(scr_cands.v[i], 0);
+  while (scr_pending.n) {
+    void *obj = scr_pending.v[--scr_pending.n];
+    /* A later outside root may have restored this deferred white node and
+     * its descendants already. Never scan a black node's edges again. */
+    if (scr_cyc_hdr(obj)->color == SCR_CYC_WHITE)
+      scr_cyc_hdr(obj)->trace(obj, scr_scan_visit, NULL);
+  }
+
+  size_t dead = 0;
+  for (size_t i = 0; i < scr_white.n; i++) {
+    void *obj = scr_white.v[i];
+    ScrCycHdr *h = scr_cyc_hdr(obj);
+    if (h->color != SCR_CYC_WHITE) continue;
+    h->color = SCR_CYC_DOOMED;
+    scr_white.v[dead++] = obj;
+  }
+  scr_white.n = dead;
 
   /* Pin the cross-generation targets of everything about to be freed, while
    * `gen` still holds the values the walk filtered on (promotion below is