@scriptc/cli-darwin-x64 0.2.5 → 0.2.6

package/dist/lib/runtime-sources/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scriptc/runtime",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "scriptc native runtime sources and vendored dependencies",
   "license": "Apache-2.0",
   "homepage": "https://scriptc.dev",

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

@@ -548,51 +548,56 @@ ScrArr *scr_arr_new_ref(void *(*elem_retain)(void *),
   return a;
 }
 
-void scr_arr_release(ScrArr *a) {
-  if (!a || a->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
-  if (--a->rc == 0) {
-    if (a->elem_trace) scr_cyc_on_dead(a);
-    scr_dyn_release(a->metadata);
-    a->metadata = NULL;
-    if (scr_elem_is_ref(a->elem)) {
-      for (size_t i = 0, end = a->len < a->cap ? a->len : a->cap; i < end; i++) {
-        if (a->present[i] != SCR_ARR_HOLE) {
-          uint64_t old = a->data[i];
-          uint8_t state = a->present[i];
-          a->present[i] = 0;
-          a->data[i] = 0;
-          if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
-        }
-      }
-      while (a->sparse_len > 0) {
-        size_t i = a->sparse_len - 1;
-        uint64_t old = a->sparse[i].slot;
-        uint8_t state = a->sparse[i].state;
-        a->sparse_len = i;
-        if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
-      }
-      while (a->prop_len > 0) {
-        size_t i = a->prop_len - 1;
-        uint64_t old = a->props[i].slot;
-        uint8_t state = a->props[i].state;
-        free(a->props[i].key);
-        a->prop_len = i;
+static void scr_arr_destroy(void *object) {
+  ScrArr *a = object;
+  scr_dyn_release(a->metadata);
+  a->metadata = NULL;
+  if (scr_elem_is_ref(a->elem)) {
+    for (size_t i = 0, end = a->len < a->cap ? a->len : a->cap; i < end; i++) {
+      if (a->present[i] != SCR_ARR_HOLE) {
+        uint64_t old = a->data[i];
+        uint8_t state = a->present[i];
+        a->present[i] = 0;
+        a->data[i] = 0;
         if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
       }
     }
-    if (a->elem_trace) {
-      scr_arr_gc_free(a);
-    } else {
-      free(a->data);
-      free(a->sparse);
-      for (size_t i = 0; i < a->prop_len; i++) free(a->props[i].key);
-      free(a->props);
+    while (a->sparse_len > 0) {
+      size_t i = a->sparse_len - 1;
+      uint64_t old = a->sparse[i].slot;
+      uint8_t state = a->sparse[i].state;
+      a->sparse_len = i;
+      if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
+    }
+    while (a->prop_len > 0) {
+      size_t i = a->prop_len - 1;
+      uint64_t old = a->props[i].slot;
+      uint8_t state = a->props[i].state;
+      free(a->props[i].key);
+      a->prop_len = i;
+      if (state == SCR_ARR_VALUE) scr_elem_release(a, old);
+    }
+  }
+  if (a->elem_trace) {
+    scr_arr_gc_free(a);
+  } else {
+    free(a->data);
+    free(a->sparse);
+    for (size_t i = 0; i < a->prop_len; i++) free(a->props[i].key);
+    free(a->props);
 #ifdef SCR_RC_AUDIT
-      scr_live_arrays--;
+    scr_live_arrays--;
 #endif
-      scr_weak_dispose(a);
-      free(a);
-    }
+    scr_weak_dispose(a);
+    free(a);
+  }
+}
+
+void scr_arr_release(ScrArr *a) {
+  if (!a || a->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */
+  if (--a->rc == 0) {
+    if (a->elem_trace) scr_cyc_on_dead(a);
+    scr_rc_destroy(a, scr_arr_destroy);
   } else if (a->elem_trace) {
     scr_cyc_on_release(a); /* possible cycle root; may collect */
   }
@@ -983,6 +988,10 @@ void *scr_arr_get_ref(ScrArr *a, double i) {
   return p;
 }
 
+void *scr_arr_borrow_ref(ScrArr *a, double i) {
+  return scr_slot_to_ptr(scr_arr_require_slot(a, i));
+}
+
 /* ── writes: i == len appends ──────────────────────────────────────────── */
 
 static void scr_arr_set_slot(ScrArr *a, double i, uint64_t slot) {
@@ -1657,6 +1666,169 @@ ScrArr *scr_arr_slice(ScrArr *a, double start, double end) {
   return out;
 }
 
+/* Default ordering of primitive arrays cannot call user code. Keep each
+ * payload owned by its source while sorting raw slots, then publish the
+ * complete permutation without per-comparison retains or releases. */
+typedef struct {
+  uint64_t value;
+  char text[32];
+} ScrNumberSortKey;
+
+typedef struct {
+  ScrElemKind kind;
+  const ScrNumberSortKey *numbers;
+} ScrPrimitiveOrder;
+
+static int scr_arr_primitive_compare(uint64_t left, uint64_t right,
+                                      const ScrPrimitiveOrder *order) {
+  if (order->kind == SCR_ELEM_STR)
+    return scr_str_cmp_u16(scr_slot_to_ptr(left), scr_slot_to_ptr(right));
+  if (order->kind == SCR_ELEM_BOOL) return (left > right) - (left < right);
+  return strcmp(order->numbers[left].text, order->numbers[right].text);
+}
+
+/* Natural runs preserve ordered inputs. Reverse strictly descending runs
+ * only, insert after ties, and merge from the left on equality. Allocate
+ * scratch only when there is more than one completed run. */
+static void scr_arr_primitive_order(uint64_t *values, size_t count,
+                                     const ScrPrimitiveOrder *order) {
+  if (count < 2) return;
+  size_t local_runs[64], *runs = local_runs, run_cap = 64, run_count = 1;
+  runs[0] = 0;
+  for (size_t start = 0; start < count;) {
+    size_t end = start + 1;
+    if (end < count) {
+      bool descending = scr_arr_primitive_compare(values[start], values[end], order) > 0;
+      end++;
+      while (end < count &&
+             (scr_arr_primitive_compare(values[end - 1], values[end], order) > 0) == descending)
+        end++;
+      if (descending) {
+        for (size_t left = start, right = end - 1; left < right; left++, right--) {
+          uint64_t value = values[left];
+          values[left] = values[right];
+          values[right] = value;
+        }
+      }
+    }
+    size_t limit = count - start < 16 ? count : start + 16;
+    while (end < limit) {
+      uint64_t value = values[end];
+      size_t low = start, high = end;
+      while (low < high) {
+        size_t mid = low + (high - low) / 2;
+        if (scr_arr_primitive_compare(values[mid], value, order) > 0) high = mid;
+        else low = mid + 1;
+      }
+      memmove(values + low + 1, values + low, (end - low) * sizeof(*values));
+      values[low] = value;
+      end++;
+    }
+    if (run_count == run_cap) {
+      if (run_cap > SIZE_MAX / 2 / sizeof(*runs)) scr_arr_oom();
+      size_t *next = malloc(run_cap * 2 * sizeof(*runs));
+      if (!next) scr_arr_oom();
+      memcpy(next, runs, run_count * sizeof(*runs));
+      if (runs != local_runs) free(runs);
+      runs = next;
+      run_cap *= 2;
+    }
+    runs[run_count++] = end;
+    start = end;
+  }
+  if (run_count > 2) {
+    if (count > SIZE_MAX / sizeof(*values)) scr_arr_oom();
+    uint64_t *scratch = malloc(count * sizeof(*scratch));
+    if (!scratch) scr_arr_oom();
+    uint64_t *src = values, *dst = scratch;
+    while (run_count > 2) {
+      size_t next_run = 1;
+      for (size_t run = 0; run + 1 < run_count; run += 2) {
+        size_t start = runs[run], mid = runs[run + 1];
+        size_t end = run + 2 < run_count ? runs[run + 2] : count;
+        if (mid == end || scr_arr_primitive_compare(src[mid - 1], src[mid], order) <= 0) {
+          memcpy(dst + start, src + start, (end - start) * sizeof(*dst));
+        } else {
+          size_t left = start, right = mid, out = start;
+          while (left < mid && right < end) {
+            dst[out++] = scr_arr_primitive_compare(src[left], src[right], order) > 0
+                ? src[right++] : src[left++];
+          }
+          if (left < mid) memcpy(dst + out, src + left, (mid - left) * sizeof(*dst));
+          else if (right < end) memcpy(dst + out, src + right, (end - right) * sizeof(*dst));
+        }
+        runs[next_run++] = end;
+      }
+      run_count = next_run;
+      uint64_t *swap = src; src = dst; dst = swap;
+    }
+    if (src != values) memcpy(values, src, count * sizeof(*values));
+    free(scratch);
+  }
+  if (runs != local_runs) free(runs);
+}
+
+ScrArr *scr_arr_sort_primitive(ScrArr *a, bool copy) {
+  if (a->elem != SCR_ELEM_STR && a->elem != SCR_ELEM_F64 && a->elem != SCR_ELEM_BOOL)
+    scr_trap("scriptc: invalid primitive array ordering\n");
+  if (a->len == 0) return copy ? scr_arr_new(a->elem, 0) : scr_arr_retain(a);
+  size_t dense = a->len < a->cap ? a->len : a->cap;
+  size_t count = 0, undefined_count = 0;
+  for (size_t i = 0; i < dense; i++) {
+    count += a->present[i] == SCR_ARR_VALUE;
+    undefined_count += a->present[i] == SCR_ARR_UNDEFINED;
+  }
+  for (size_t i = 0; i < a->sparse_len; i++) {
+    count += a->sparse[i].state == SCR_ARR_VALUE;
+    undefined_count += a->sparse[i].state == SCR_ARR_UNDEFINED;
+  }
+  if (count > SIZE_MAX / sizeof(uint64_t)) scr_arr_oom();
+  uint64_t *values = count ? malloc(count * sizeof(*values)) : NULL;
+  if (count && !values) scr_arr_oom();
+  size_t used = 0;
+  for (size_t i = 0; i < dense; i++)
+    if (a->present[i] == SCR_ARR_VALUE) values[used++] = a->data[i];
+  for (size_t i = 0; i < a->sparse_len; i++)
+    if (a->sparse[i].state == SCR_ARR_VALUE) values[used++] = a->sparse[i].slot;
+  ScrNumberSortKey *numbers = NULL;
+  if (a->elem == SCR_ELEM_F64 && count > 1) {
+    if (count > SIZE_MAX / sizeof(*numbers)) scr_arr_oom();
+    numbers = malloc(count * sizeof(*numbers));
+    if (!numbers) scr_arr_oom();
+    for (size_t i = 0; i < count; i++) {
+      numbers[i].value = values[i];
+      scr_f64_to_str(scr_slot_to_f64(values[i]), numbers[i].text);
+      values[i] = i;
+    }
+  }
+  ScrPrimitiveOrder order = {a->elem, numbers};
+  scr_arr_primitive_order(values, count, &order);
+  if (numbers) {
+    for (size_t i = 0; i < count; i++) values[i] = numbers[values[i]].value;
+    free(numbers);
+  }
+  size_t present = copy ? a->len : count + undefined_count;
+  ScrArr *out = copy ? scr_arr_new(a->elem, present) : a;
+  if (copy) out->len = a->len;
+  if (!copy && scr_arr_is_dense(a)) {
+    if (count) memcpy(a->data, values, count * sizeof(*values));
+    memset(a->present, SCR_ARR_VALUE, count);
+    memset(a->present + count, SCR_ARR_UNDEFINED, undefined_count);
+    scr_arr_clear_dense(a, count + undefined_count, a->len - count - undefined_count);
+    if (undefined_count) memset(a->data + count, 0, undefined_count * sizeof(*a->data));
+  } else {
+    ScrArrStorage old = {0};
+    if (!copy) old = scr_arr_take_storage(a);
+    for (size_t i = 0; i < count; i++)
+      scr_arr_store_owned(out, i, copy ? scr_elem_retain_slot(a, values[i]) : values[i]);
+    for (size_t i = count; i < present; i++)
+      scr_arr_store_state_owned(out, i, 0, SCR_ARR_UNDEFINED);
+    if (!copy) scr_arr_free_storage(&old);
+  }
+  free(values);
+  return copy ? out : scr_arr_retain(a);
+}
+
 ScrStr *scr_arr_join(ScrArr *a, ScrStr *sep) {
   size_t cap = 64;
   /* String widths are already known. Size once to avoid growth and copying

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

@@ -361,6 +361,7 @@ void scr_assert_deep_result(bool equal, bool negated, ScrStr *msg, bool has_msg)
  * by construction (the frontend's same-static-type gate), but the elem
  * check stays: a defensive answer beats a miscompare. */
 static bool scr_assert_bytes_content_eq(const ScrBytes *a, const ScrBytes *b) {
+  SCR_SHARED_GUARD(a, b);
   if (a->elem != b->elem || a->len != b->len) return false;
   size_t nbytes = a->len * scr_bytes_elem_size(a->elem);
   return nbytes == 0 || memcmp(a->data, b->data, nbytes) == 0;
@@ -542,8 +543,7 @@ static bool scr_assert_dyn_deep_eq(const ScrDyn *a, const ScrDyn *b) {
       if (a->buffer != b->buffer) return false; /* the prototype gate */
       const ScrBytes *x = a->v.bytes, *y = b->v.bytes;
       if (x->elem != y->elem || x->len != y->len) return false;
-      size_t nbytes = x->len * scr_bytes_elem_size(x->elem);
-      return nbytes == 0 || memcmp(x->data, y->data, nbytes) == 0;
+      return scr_assert_bytes_content_eq(x, y);
     }
     case SCR_DYN_ARR: {
       if (a->v.arr.len != b->v.arr.len) return false;
@@ -712,7 +712,7 @@ static void scr_assert_cf_value(ScrAssertBuf *b, const ScrDyn *d, size_t indent,
         ab_char(b, '\n');
         scr_assert_cf_pad(b, indent + 2);
         char tmp[40];
-        size_t n = scr_assert_inspect_f64((double)((const unsigned char *)bs->data)[i], tmp);
+        size_t n = scr_assert_inspect_f64(scr_bytes_get(bs, (double)i), tmp);
         ab_bytes(b, tmp, n);
         if (i + 1 < bs->len) ab_char(b, ',');
       }