@scriptc/cli-darwin-x64 0.2.3 → 0.2.4

package/dist/lib/runtime-sources/src/scr_runtime.h

@@ -297,7 +297,7 @@ void scr_library_bytes_out(ScrBytes *b, const uint8_t **out, size_t *out_len);
  * The collector is synchronous Bacon–Rajan trial deletion: a release that
  * leaves a candidate's rc above zero buffers it as a possible cycle root;
  * collection walks the buffer (markGray: trial-decrement internal edges;
- * scan: restore externally-referenced subgraphs; collectWhite: free the
+ * scan: restore externally-referenced subgraphs; gather: free the
  * dead cycle members, releasing only edges that LEAVE the white set).
  * It is GENERATIONAL: each header carries a generation, a pass names the
  * oldest one it will walk, and objects that survive a pass are promoted out
@@ -322,9 +322,9 @@ typedef void (*ScrTraceVisit)(void *child, void *ctx);
 typedef void (*ScrTraceFn)(void *obj, ScrTraceVisit visit, void *ctx);
 typedef void (*ScrCycFreeFn)(void *obj);
 
-/* DOOMED is WHITE that collectWhite has already gathered: it stops the
- * gather recursing twice, and distinguishes "about to be freed" from a
- * survivor for the re-buffering step (see scr_cycle.c). */
+/* DOOMED identifies the gathered dead set during re-buffering and weak
+ * observer teardown. WHITE candidates may still become black when a later
+ * outside root restores them; only the settled white set becomes DOOMED. */
 enum {
   SCR_CYC_BLACK = 0, SCR_CYC_PURPLE = 1, SCR_CYC_GRAY = 2, SCR_CYC_WHITE = 3,
   SCR_CYC_DOOMED = 4
@@ -437,7 +437,7 @@ typedef struct ScrVt {
  *
  * cap is the usable byte capacity of data[] excluding the NUL (allocation
  * is sizeof(ScrStr) + cap + 1); cap == len for interned literals and plain
- * allocations. Spare capacity (cap > len) exists only on concat results so
+ * allocations. Builders and concat results may have spare capacity so
  * scr_str_concat can append in place when the left operand is uniquely
  * owned (rc == 1) — observable immutability is preserved: a string with
  * rc > 1 or rc == SIZE_MAX is never mutated.
@@ -454,7 +454,7 @@ ScrStr *scr_str_new(const char *bytes, size_t len); /* returns +1 */
  * malformed subsequences with U+FFFD. NULL with len == 0 is an empty span. */
 ScrStr *scr_str_from_utf8_lossy(const uint8_t *bytes, size_t len); /* +1 */
 
-/* Internal allocators for buffer builders (scr_json.c): a +1 string with
+/* Internal allocators for buffer builders: a +1 string with
  * UNINITIALIZED data (the builder fills bytes, then len and the NUL), and
  * an rc==1-only realloc that grows capacity in place. Both keep the RC
  * audit's live count exact. */
@@ -470,6 +470,8 @@ void scr_str_release(ScrStr *s); /* NULL-tolerant (uninitialized locals) */
 
 /* Borrow both args, return +1. */
 ScrStr *scr_str_concat(ScrStr *a, ScrStr *b);
+/* Borrow each part without mutation; return one independently owned result. */
+ScrStr *scr_str_concat_parts(ScrStr *const *parts, size_t count);
 
 bool scr_str_eq(ScrStr *a, ScrStr *b);
 
@@ -1321,10 +1323,10 @@ ScrArr *scr_regex_match_all_into(ScrStr *s, ScrRegex *re, ScrArr *indices);
  * are visited (they append), deleted entries are skipped (tombstones), and
  * a delete + re-add moves the key to the end (Node-verified).
  *
- * Keys are identity references, string (content), or number with SameValueZero: NaN equals NaN
- * (canonicalized before hashing) and -0 is normalized to +0 at insertion,
- * exactly like JS (a stored -0 key reads back as +0). Hash is FNV-1a over
- * the reference address, string bytes, or canonicalized f64 bit pattern.
+ * Primitive keys compare by value and reference keys by identity. Numbers
+ * use SameValueZero: NaN equals NaN and -0 is stored as +0. Union wrappers
+ * are representations, never identities; their arm descriptors select
+ * the primitive or reference comparison, including null and undefined.
  *
  * Values are one uniform kind per map (like ScrArr elements): f64, bool, or
  * a refcounted pointer whose RC entry points arrive as function pointers at
@@ -1351,13 +1353,17 @@ ScrArr *scr_regex_match_all_into(ScrStr *s, ScrRegex *re, ScrArr *indices);
  * DYN owns a checked-value box and compares its JavaScript value using
  * SameValueZero, including reference identity for object payloads.
  * These key kinds serve both Maps and Sets. */
-typedef enum { SCR_MAP_KEY_F64, SCR_MAP_KEY_STR, SCR_MAP_KEY_REF, SCR_MAP_KEY_UNION_REF, SCR_MAP_KEY_DYN } ScrMapKeyKind;
+typedef enum {
+  SCR_MAP_KEY_F64, SCR_MAP_KEY_STR, SCR_MAP_KEY_REF, SCR_MAP_KEY_UNION_REF, SCR_MAP_KEY_DYN,
+  SCR_MAP_KEY_BIGINT, SCR_MAP_KEY_BOOL, SCR_MAP_KEY_UNION_VALUE,
+  SCR_MAP_KEY_NULL, SCR_MAP_KEY_UNDEFINED /* tag-only union arms */
+} ScrMapKeyKind;
 typedef enum { SCR_MAP_VAL_F64, SCR_MAP_VAL_BOOL, SCR_MAP_VAL_REF } ScrMapValKind;
 
 typedef struct {
   uint64_t key; /* double bits (normalized), ScrStr* (owned), or ref ptr (owned) */
   uint64_t val; /* double bits, bool, or owned pointer */
-  bool live;    /* false = tombstone (key/val already released) */
+  uint64_t hash; /* nonzero cached hash; zero = tombstone (key/val released) */
 } ScrMapEntry;
 
 /* Checked views use the original storage. Slot converters borrow on reads
@@ -1380,7 +1386,7 @@ typedef struct ScrMap {
   void *(*val_retain)(void *);
   void (*val_release)(void *);
   ScrTraceFn val_trace;
-  /* SCR_MAP_KEY_REF, SCR_MAP_KEY_UNION_REF and SCR_MAP_KEY_DYN only. */
+  /* Reference-represented keys, including bigint and union values. */
   void *(*key_retain)(void *);
   void (*key_release)(void *);
   ScrTraceFn key_trace;
@@ -1392,8 +1398,17 @@ typedef struct ScrMap {
   size_t *buckets;  /* entry indices; SIZE_MAX = empty */
   size_t iter_depth; /* > 0: an iteration is active — no compaction */
   const ScrMapDynOps *dyn_ops;
+  const uint8_t *union_keys; /* immutable key-kind table indexed by union tag */
 } ScrMap;
 
+/* Called once on a fresh UNION_VALUE collection, before its first insert. */
+void scr_map_union_keys(ScrMap *map, const uint8_t *kinds);
+/* Fresh shallow copies with compact storage and independent mutation.
+ * keys_only selects a Set; checked views materialize their boxed values. */
+ScrMap *scr_map_clone(const ScrMap *source, bool keys_only);
+ScrMap *scr_map_clone_dyn(const ScrMap *source, bool keys_only);
+void scr_map_values_into(ScrMap *set, const ScrMap *source, bool checked);
+
 void scr_map_dyn_attach(ScrMap *map, const ScrMapDynOps *ops);
 struct ScrDyn *scr_map_dyn_key(const ScrMap *map, double index);
 struct ScrDyn *scr_map_dyn_value(const ScrMap *map, double index);
@@ -1426,9 +1441,11 @@ double scr_map_size(const ScrMap *m); /* live entries (Map.size) */
 void scr_map_clear(ScrMap *m);
 
 bool scr_map_has_f64(const ScrMap *m, double key);
+bool scr_map_has_bool(const ScrMap *m, bool key);
 bool scr_map_has_str(const ScrMap *m, const ScrStr *key);
 bool scr_map_has_ref(const ScrMap *m, const void *key);
 bool scr_map_delete_f64(ScrMap *m, double key);
+bool scr_map_delete_bool(ScrMap *m, bool key);
 bool scr_map_delete_str(ScrMap *m, const ScrStr *key);
 bool scr_map_delete_ref(ScrMap *m, const void *key);
 
@@ -1438,6 +1455,9 @@ bool scr_map_delete_ref(ScrMap *m, const void *key);
 void scr_map_set_f64_f64(ScrMap *m, double key, double v);
 void scr_map_set_f64_bool(ScrMap *m, double key, bool v);
 void scr_map_set_f64_ref(ScrMap *m, double key, void *v);
+void scr_map_set_bool_f64(ScrMap *m, bool key, double v);
+void scr_map_set_bool_bool(ScrMap *m, bool key, bool v);
+void scr_map_set_bool_ref(ScrMap *m, bool key, void *v);
 void scr_map_set_str_f64(ScrMap *m, ScrStr *key, double v);
 void scr_map_set_str_bool(ScrMap *m, ScrStr *key, bool v);
 void scr_map_set_str_ref(ScrMap *m, ScrStr *key, void *v);
@@ -1452,6 +1472,9 @@ void scr_map_set_ref_ref(ScrMap *m, void *key, void *v);
 bool scr_map_get_f64_f64(const ScrMap *m, double key, double *out);
 bool scr_map_get_f64_bool(const ScrMap *m, double key, bool *out);
 void *scr_map_get_f64_ref(const ScrMap *m, double key);
+bool scr_map_get_bool_f64(const ScrMap *m, bool key, double *out);
+bool scr_map_get_bool_bool(const ScrMap *m, bool key, bool *out);
+void *scr_map_get_bool_ref(const ScrMap *m, bool key);
 bool scr_map_get_str_f64(const ScrMap *m, const ScrStr *key, double *out);
 bool scr_map_get_str_bool(const ScrMap *m, const ScrStr *key, bool *out);
 void *scr_map_get_str_ref(const ScrMap *m, const ScrStr *key);
@@ -1467,6 +1490,7 @@ void *scr_map_get_ref_ref(const ScrMap *m, const void *key);
 double scr_map_iter_count(const ScrMap *m); /* entries incl. tombstones */
 bool scr_map_iter_live(const ScrMap *m, double i);
 double scr_map_iter_key_f64(const ScrMap *m, double i);
+bool scr_map_iter_key_bool(const ScrMap *m, double i);
 ScrStr *scr_map_iter_key_str(const ScrMap *m, double i); /* +1 */
 void *scr_map_iter_key_ref(const ScrMap *m, double i);     /* +1 */
 double scr_map_iter_val_f64(const ScrMap *m, double i);
@@ -1484,6 +1508,7 @@ void scr_set_add_all(ScrMap *set, ScrArr *values);
 /* `[...set]` (scr_lib.c): the live entries drained into a fresh +1 elem[]
  * in insertion order. Borrows the set; string elements retained in. */
 ScrArr *scr_set_to_arr_f64(const ScrMap *s);
+ScrArr *scr_set_to_arr_bool(const ScrMap *s);
 ScrArr *scr_set_to_arr_str(const ScrMap *s);
 ScrArr *scr_set_to_arr_ref(const ScrMap *s);
 ScrArr *scr_set_to_arr_dyn(const ScrMap *s);
@@ -3397,6 +3422,7 @@ ScrBigInt *scr_bigint_xor(ScrBigInt *a, ScrBigInt *b);
 ScrBigInt *scr_bigint_shl(ScrBigInt *a, ScrBigInt *count);
 ScrBigInt *scr_bigint_shr(ScrBigInt *a, ScrBigInt *count);
 bool scr_bigint_eq(ScrBigInt *a, ScrBigInt *b);
+uint64_t scr_bigint_hash(const ScrBigInt *value); /* normalized value, no allocation */
 bool scr_bigint_eq_string(ScrBigInt *a, ScrStr *b); /* StringToBigInt failure is false */
 double scr_bigint_cmp_string(ScrBigInt *a, ScrStr *b); /* 2 = invalid StringToBigInt */
 double scr_bigint_cmp_f64(ScrBigInt *a, ScrBigInt *b); /* -1, 0, 1 */

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

@@ -271,6 +271,7 @@ ScrStr *scr_str_alloc_raw(size_t len, size_t cap) {
 }
 
 ScrStr *scr_str_regrow(ScrStr *s, size_t newcap) {
+  if (newcap < s->len || newcap > SIZE_MAX - sizeof(ScrStr) - 1) scr_oom();
   scr_short_forget(s);
   scr_sidx_purge(s); /* realloc may move; the old address may be recycled */
   ScrStr *r = realloc(s, sizeof(ScrStr) + newcap + 1);
@@ -300,6 +301,8 @@ void scr_str_release(ScrStr *s) {
 }
 
 ScrStr *scr_str_concat(ScrStr *a, ScrStr *b) {
+  if (a->len == 0) return scr_str_retain(b);
+  if (b->len == 0) return scr_str_retain(a);
   if (a->len > SIZE_MAX - b->len - sizeof(ScrStr) - 1) scr_oom();
   size_t newlen = a->len + b->len;
   /* In-place append: a is uniquely owned by the caller's borrow (rc == 1 —
@@ -343,6 +346,32 @@ ScrStr *scr_str_concat(ScrStr *a, ScrStr *b) {
   return s;
 }
 
+ScrStr *scr_str_concat_parts(ScrStr *const *parts, size_t count) {
+  const size_t limit = SIZE_MAX - sizeof(ScrStr) - 1;
+  size_t len = 0;
+  ScrStr *only = NULL;
+  size_t nonempty = 0;
+  for (size_t i = 0; i < count; i++) {
+    const size_t n = parts[i]->len;
+    if (n > limit - len) scr_oom();
+    len += n;
+    if (n != 0) {
+      only = parts[i];
+      nonempty++;
+    }
+  }
+  if (nonempty == 1) return scr_str_retain(only);
+  ScrStr *out = scr_str_alloc_raw(len, len);
+  size_t offset = 0;
+  for (size_t i = 0; i < count; i++) {
+    const ScrStr *part = parts[i];
+    memcpy(out->data + offset, part->data, part->len);
+    offset += part->len;
+  }
+  out->data[len] = '\0';
+  return out;
+}
+
 bool scr_str_eq(ScrStr *a, ScrStr *b) {
   return a == b || (a->len == b->len && memcmp(a->data, b->data, a->len) == 0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/cli-darwin-x64",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Native scriptc compiler for darwin-x64",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",