@scriptc/cli-darwin-arm64 0.2.4 → 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;
 }