@scriptc/cli-darwin-arm64 0.2.5 → 0.2.6

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

@@ -609,13 +609,13 @@ struct ScrNetSocket {
 };
 
 #ifdef SCR_RC_AUDIT
-static long scr_net_live = 0;
+static SCR_TL long scr_net_live = 0;
 long scr_net_live_count(void) { return scr_net_live; }
 #endif
 
-static ScrNetServer *scr_net_servers = NULL; /* registry: +1 each, tail-appended */
-static ScrNetSocket *scr_net_socks = NULL;
-static ScrPoller *scr_net_poller = NULL;
+static SCR_TL ScrNetServer *scr_net_servers = NULL; /* registry: +1 each, tail-appended */
+static SCR_TL ScrNetSocket *scr_net_socks = NULL;
+static SCR_TL ScrPoller *scr_net_poller = NULL;
 
 /* ── RC ──────────────────────────────────────────────────────────────── */
 
@@ -1649,7 +1649,7 @@ void scr_net_server_close_direct(ScrNetServer *s, ScrClosure *cb /*moves, nullab
     scr_net_ls_drop(&s->listening_cbs);
   }
   if (!s->closing) {
-    static size_t scr_net_close_seq = 0;
+    static SCR_TL size_t scr_net_close_seq = 0;
     s->close_seq = ++scr_net_close_seq;
   }
   s->closing = true; /* the sweep fires 'close' once nconns drains */
@@ -2222,6 +2222,7 @@ void scr_net_sock_write_str(ScrNetSocket *s, ScrStr *data /*borrowed*/) {
 }
 
 void scr_net_sock_write_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   scr_net_sock_write_raw(s, (const char *)data->data, (data->len * scr_bytes_elem_size(data->elem)));
 }
 
@@ -2430,6 +2431,7 @@ ScrBytes *scr_net_sock_read_bytes(ScrNetSocket *s, double n) {
  * buffer — every consumer (data listeners, an http parser, a TLS bio)
  * sees them before anything still in the kernel. */
 void scr_net_sock_unshift_bytes(ScrNetSocket *s, ScrBytes *data /*borrowed*/) {
+  SCR_BYTES_SNAPSHOT(data);
   if (data->len == 0) return;
   size_t avail = s->rlen - s->rhead;
   if (s->rhead >= data->len) {
@@ -2784,9 +2786,9 @@ void scr_net_server_get_native_conn(ScrNetServer *s, ScrNetNativeConnFn *fn, voi
  * pass after the work that flagged them — Node's later-than-the-handler
  * emits). Registered once by scr_http install-time code. */
 enum { SCR_NET_PROTO_SLOTS = 4 };
-static bool (*scr_net_proto_pendings[SCR_NET_PROTO_SLOTS])(void);
-static void (*scr_net_proto_sweeps[SCR_NET_PROTO_SLOTS])(void);
-static size_t scr_net_proto_n = 0;
+static SCR_TL bool (*scr_net_proto_pendings[SCR_NET_PROTO_SLOTS])(void);
+static SCR_TL void (*scr_net_proto_sweeps[SCR_NET_PROTO_SLOTS])(void);
+static SCR_TL size_t scr_net_proto_n = 0;
 
 /* ADDITIVE registration (each protocol unit — scr_http.c, scr_http2.c —
  * claims a slot at its install; both can co-link in one binary). */
@@ -3180,10 +3182,10 @@ static void scr_net_cleanup_atexit(void) {
 }
 
 void scr_net_install(void) {
-  static bool installed = false;
+  static SCR_TL bool installed = false;
   if (installed) return;
   installed = true;
-  atexit(scr_net_cleanup_atexit);
+  scr_atexit(scr_net_cleanup_atexit);
   scr_loop_set_net(&scr_net_pending, &scr_net_dispatch, &scr_net_pollfd);
 }
 
@@ -3204,7 +3206,7 @@ static void scr_net_dynh_unsupported(const char *member, const char *why) {
 /* The TLS-member hooks (scr_tls.c registers them when linked): TLSSocket
  * property reads, event names, and method names layer over the plain
  * socket dispatch without this unit naming that one's symbols. */
-static const ScrNetDynhTlsHooks *scr_net_dynh_tls = NULL;
+static SCR_TL const ScrNetDynhTlsHooks *scr_net_dynh_tls = NULL;
 void scr_net_set_dynh_tls(const ScrNetDynhTlsHooks *hooks) { scr_net_dynh_tls = hooks; }
 
 static bool scr_net_dynh_name_is(const ScrDyn *name, const char *lit) {
@@ -3457,7 +3459,7 @@ static const ScrDynHandleOps scr_net_dynh_sock_ops = {
  * at its dyn install — this unit cannot name http entry points without
  * breaking the link gate. */
 
-static bool (*scr_net_dynh_http_on)(ScrNetServer *s, const char *event, const ScrDyn *cb,
+static SCR_TL bool (*scr_net_dynh_http_on)(ScrNetServer *s, const char *event, const ScrDyn *cb,
                                     bool once);
 void scr_net_set_dynh_http_on(bool (*fn)(ScrNetServer *, const char *, const ScrDyn *, bool)) {
   scr_net_dynh_http_on = fn;

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

@@ -142,6 +142,40 @@ size_t scr_f64_to_str(double x, char *buf) {
     x = -x;
   }
 
+  /* Every integer through 2^53-1 has an unambiguous exact decimal spelling.
+   * Larger doubles keep the shortest-roundtrip algorithm: their rounded
+   * integer value can differ from JavaScript's chosen decimal digits. */
+  if (x <= 9007199254740991.0) {
+    uint64_t integer = (uint64_t)x;
+    if ((double)integer == x) {
+      static const char pairs[] =
+          "00010203040506070809" "10111213141516171819"
+          "20212223242526272829" "30313233343536373839"
+          "40414243444546474849" "50515253545556575859"
+          "60616263646566676869" "70717273747576777879"
+          "80818283848586878889" "90919293949596979899";
+      char digits[16];
+      char *begin = digits + sizeof digits;
+      while (integer >= 100) {
+        uint64_t quotient = integer / 100;
+        unsigned remainder = (unsigned)(integer - quotient * 100);
+        begin -= 2;
+        memcpy(begin, pairs + remainder * 2, 2);
+        integer = quotient;
+      }
+      if (integer < 10) *--begin = (char)('0' + integer);
+      else {
+        begin -= 2;
+        memcpy(begin, pairs + integer * 2, 2);
+      }
+      size_t count = (size_t)(digits + sizeof digits - begin);
+      memcpy(out, begin, count);
+      out += count;
+      *out = '\0';
+      return (size_t)(out - buf);
+    }
+  }
+
   char digits[18];
   int n;
   int k = scr_f64_digits(x, digits, &n);

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

@@ -32,14 +32,19 @@ ScrClassObj *scr_classobj_new(const ScrClassObj *template, size_t ncaps) {
   return c;
 }
 
+static void scr_classobj_destroy(void *object) {
+  ScrClassObj *c = object;
+  for (size_t i = 0; i < c->ncaps; i++) scr_box_release(c->caps[i]);
+  scr_box_release(c->prototype_data);
+  scr_box_release(c->static_data);
+  scr_classobj_gcfree(c);
+}
+
 void scr_classobj_release(ScrClassObj *c) {
   if (!c || c->rc == SIZE_MAX) return;
   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->prototype_data);
-    scr_box_release(c->static_data);
-    scr_classobj_gcfree(c);
+    scr_rc_destroy(c, scr_classobj_destroy);
   } else {
     scr_cyc_on_release(c);
   }

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

@@ -845,7 +845,7 @@ ScrStr *scr_path_win32_resolve(ScrArr *parts) {
        * the resolved drive. resolvedDevice is always a 2-byte drive here
        * (UNC devices are absolute and broke out of the loop). */
       char name[4] = {'=', dev.data[0], dev.data[1], 0};
-      const char *dcwd = getenv(name);
+      const char *dcwd = scr_getenv(name);
       if (dcwd && *dcwd) pb_append(&pathb, dcwd, strlen(dcwd));
       else scr_path_cwd(&pathb);
       if (!(pathb.len >= 2 && scr_path_w32_ieq(pathb.data, dev.data, 2)) &&

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

@@ -48,12 +48,12 @@ typedef struct ScrRl {
   struct ScrRl *next;
 } ScrRl;
 
-static ScrRl *scr_rls = NULL;
-static double scr_rl_next_id = 1;
-static size_t scr_rl_open = 0;        /* un-closed, un-dead interfaces */
-static ScrClosure *scr_rl_data_cb = NULL; /* the shared consumer (borrowed
+static SCR_TL ScrRl *scr_rls = NULL;
+static SCR_TL double scr_rl_next_id = 1;
+static SCR_TL size_t scr_rl_open = 0;        /* un-closed, un-dead interfaces */
+static SCR_TL ScrClosure *scr_rl_data_cb = NULL; /* the shared consumer (borrowed
                                             * mirror; the registry owns) */
-static bool scr_rl_end_registered = false;
+static SCR_TL bool scr_rl_end_registered = false;
 
 static ScrRl *scr_rl_find(double id) {
   for (ScrRl *rl = scr_rls; rl; rl = rl->next) {
@@ -146,7 +146,7 @@ static void scr_rl_data_adapter(ScrClosure *cb, ScrBytes *chunk) {
       rl->buf = realloc(rl->buf, rl->cap);
       if (!rl->buf) scr_rl_oom();
     }
-    memcpy(rl->buf + rl->len, chunk->data, chunk->len);
+    scr_bytes_read(chunk, 0, rl->buf + rl->len, chunk->len);
     rl->len += chunk->len;
     scr_rl_drain(rl);
     if (scr_exc_pending()) return;
@@ -197,10 +197,10 @@ static void scr_rl_cleanup_atexit(void) {
 }
 
 double scr_rl_create(void) {
-  static bool cleanup_registered = false;
+  static SCR_TL bool cleanup_registered = false;
   if (!cleanup_registered) {
     cleanup_registered = true;
-    atexit(scr_rl_cleanup_atexit);
+    scr_atexit(scr_rl_cleanup_atexit);
   }
   ScrRl *rl = calloc(1, sizeof *rl);
   if (!rl) scr_rl_oom();

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

@@ -791,6 +791,119 @@ ScrStr *scr_regex_replace(ScrStr *s, ScrRegex *re, ScrStr *rep) {
   return scr_replace_impl(s, re, rep);
 }
 
+typedef struct {
+  ScrDyn *arguments;
+  int start, end;
+} ScrReplacementMatch;
+
+static ScrDyn *scr_regex_capture_value(const ScrRegexInput *input,
+                                       const uint8_t *start, const uint8_t *end) {
+  if (!start || !end) return scr_dyn_retain(scr_dyn_undefined());
+  ScrStr *span = scr_regex_span(input, scr_capture_index(input, start),
+                                scr_capture_index(input, end));
+  ScrDyn *value = scr_dyn_new_str(span);
+  scr_str_release(span);
+  return value;
+}
+
+/* Symbol.replace collects matches before invoking any replacement. A callback
+ * can execute the same regex, change lastIndex, or throw; none of those actions
+ * may affect which matches were collected. Capture values and groups therefore
+ * belong to each snapshot, not to the engine's reused capture buffer. */
+ScrStr *scr_regex_replace_callback(ScrStr *s, ScrRegex *re, ScrDyn *callback, bool all) {
+  uint8_t *bc = scr_regex_bc(re);
+  int flags = lre_get_flags(bc);
+  bool global = (flags & LRE_FLAG_GLOBAL) != 0;
+  if (all && !global) {
+    static const char message[] = "String.prototype.replaceAll called with a non-global RegExp argument";
+    scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    return NULL;
+  }
+  if (!scr_dyn_is_callable(callback)) {
+    ScrStr *template = scr_dyn_string_coerce_js(callback);
+    if (!template) return NULL;
+    ScrStr *result = scr_replace_impl(s, re, template);
+    scr_str_release(template);
+    return result;
+  }
+  bool sticky = (flags & LRE_FLAG_STICKY) != 0;
+  bool unicode = (flags & (LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS)) != 0;
+  int capture_count = lre_get_capture_count(bc);
+  const char *groupnames = lre_get_groupnames(bc);
+  ScrRegexInput input;
+  scr_regex_input_init(&input, bc, s);
+  int len = input.len;
+  ScrReplacementMatch *matches = NULL;
+  size_t count = 0, capacity = 0;
+  ScrDyn *subject = scr_dyn_new_str(s);
+  if (global) re->last_index = 0;
+  int position = sticky ? scr_regex_start(re, len) : 0;
+  if (position < 0) position = len + 1;
+  if (sticky && !global) re->last_index = 0;
+  while (position <= len && scr_exec(&input, bc, position) == 1) {
+    uint8_t **capture = input.capture;
+    int start = scr_capture_index(&input, capture[0]);
+    int end = scr_capture_index(&input, capture[1]);
+    if (sticky && !global) re->last_index = end;
+    ScrDyn *arguments = scr_dyn_new_arr();
+    for (int group = 0; group < capture_count; group++)
+      scr_dyn_arr_push(arguments, scr_regex_capture_value(&input, capture[group * 2], capture[group * 2 + 1]));
+    scr_dyn_arr_push(arguments, scr_dyn_new_num((double)start));
+    scr_dyn_arr_push(arguments, scr_dyn_retain(subject));
+    if (groupnames) {
+      ScrDyn *groups = scr_dyn_new_obj_null_proto();
+      const char *name = groupnames;
+      for (int group = 1; group < capture_count; group++) {
+        size_t length = strlen(name);
+        if (length && (capture[group * 2] || !scr_dyn_obj_get(groups, name, length)))
+          scr_dyn_obj_set(groups, name, length,
+            scr_regex_capture_value(&input, capture[group * 2], capture[group * 2 + 1]));
+        name += length + LRE_GROUP_NAME_TRAILER_LEN;
+      }
+      scr_dyn_arr_push(arguments, groups);
+    }
+    if (count == capacity) {
+      size_t next = capacity ? capacity * 2 : 8;
+      if (next < capacity || next > SIZE_MAX / sizeof(*matches)) scr_regex_oom();
+      ScrReplacementMatch *grown = realloc(matches, next * sizeof(*matches));
+      if (!grown) scr_regex_oom();
+      matches = grown;
+      capacity = next;
+    }
+    matches[count++] = (ScrReplacementMatch){ arguments, start, end };
+    if (!global) break;
+    position = start == end ? scr_advance(&input, end, unicode) : end;
+  }
+  scr_dyn_release(subject);
+  ScrJsonBuf output;
+  scr_jb_init(&output);
+  int next = 0;
+  for (size_t i = 0; i < count; i++) {
+    ScrReplacementMatch *match = &matches[i];
+    ScrDyn *arguments = match->arguments;
+    scr_dyn_this_push_dyn(NULL);
+    ScrDyn *raw = scr_dyn_call(callback, arguments->v.arr.items, arguments->v.arr.len, "replacement");
+    scr_dyn_this_pop();
+    ScrStr *replacement = scr_exc_pending() ? NULL : scr_dyn_string_coerce_js(raw);
+    scr_dyn_release(raw);
+    if (!replacement) break;
+    scr_regex_put_span(&output, &input, next, match->start);
+    scr_jb_put_str(&output, replacement);
+    scr_str_release(replacement);
+    next = match->end;
+  }
+  for (size_t i = 0; i < count; i++) scr_dyn_release(matches[i].arguments);
+  free(matches);
+  if (scr_exc_pending()) {
+    free(output.data);
+    scr_regex_input_dispose(&input);
+    return NULL;
+  }
+  scr_regex_put_span(&output, &input, next, len);
+  scr_regex_input_dispose(&input);
+  return scr_jb_finish(&output);
+}
+
 
 /* The pinned Node ANSI matcher derives from ansi-regex, copyright (c)
  * Sindre Sorhus <sindresorhus@gmail.com>, used under the MIT license: