yeptris 0.6.52.0-arm-linux-eabihf → 0.6.54.0-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51f4561549b05fa1678bc7e062857da1c85052810e8db0e4c692182d0c802287
-  data.tar.gz: 44857029399d44d6c4086c7051da03976c59b5003e4bc2918d91f9df9b4aef07
+  metadata.gz: 98eb93f4bcbc15ae9cdbb27ca0c0df3f713f339e5d31a47223410f395b92cb86
+  data.tar.gz: 567addfbae19c7b3b3dcf59ff9e073bc3a04372343b965cdd618bea92cbf6cae
 SHA512:
-  metadata.gz: faa399d6e06326d9c0a5acddd56f66f200e5263dde33907662108fe5353926e696530e7eaabf11d8a107c32d06134b352b69e0a468bb0fe1d276639897153f9c
-  data.tar.gz: 428fb4d7027de7f1993e30e3c3bb11e0c2369dee6757f74a9dc2f4fda841527a60e5cebad1b143c936af5de75149b7fe1464477d5d27e452e8dda048ba70064a
+  metadata.gz: 6b582fa561076e339b246acac3d9ede1d1b67f31543617df6760c14fe88540938183f4f19ebc5c58a20ff85a288edd993fe39f1a0be6191fd8c78d004b1f42a3
+  data.tar.gz: efaf2d6acdc439d85f9a098e4a1dc6b989d8861f25589dd1587bee33a272e41d5e1c8944908d363ab32f1493db6ecd337a06232e574d6247ae1242a34ada17f5

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 51
-#define YEPTRIS_VERSION_STRING "0.6.51"
+#define YEPTRIS_VERSION_PATCH 54
+#define YEPTRIS_VERSION_STRING "0.6.54"
 
 #ifdef __cplusplus
 extern "C" {

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.52.0".freeze
+  VERSION = "0.6.54.0".freeze
 
   # Informational notices are OPT-IN (yeptris-ruby#217): consumers
   # embed yeptris inside CLIs that assert clean stderr, and a

data/vendor/libyeptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(yeptris
-    VERSION 0.6.51
+    VERSION 0.6.54
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/yeptris/cbor/from_marshal.c

@@ -687,6 +687,13 @@ static int cm_value(cm_ctx* c, cm_buf* out) {
             return cm_fail(c, YEPTRIS_ERROR_UNSUPPORTED); /* the host loop raises */
         }
         double d = strtod(tmp, NULL);
+        if (!isfinite(d)) {
+            /* the literal spellings gate above; a strtod OVERFLOW
+             * ("1e999") manufactures the same non-finite without
+             * spelling it — the same strict reject (Ruby streams only
+             * ever carry finites or the literal inf/nan spellings) */
+            return cm_fail(c, YEPTRIS_ERROR_UNSUPPORTED);
+        }
         uint8_t fw = yep_cbor_float_width(d);
         if (cm_reserve(c, out, 9) != 0) {
             return -1;

data/vendor/libyeptris/src/yeptris/common/simd_text_avx2.c

@@ -92,7 +92,9 @@ static void yep_avx2_copy_count3(char* dst, const char* src, size_t len, char c0
         memcpy(dst + i, src + i, len - i);
     }
     size_t ta = 0, tb = 0, td = 0;
-    yep_text_count3_scalar(dst + i, len - i, c0, c1, c2, &ta, &tb, &td);
+    if (i < len) { /* NULL dst + 0 offset is still UB to form */
+        yep_text_count3_scalar(dst + i, len - i, c0, c1, c2, &ta, &tb, &td);
+    }
     *n0 = a + ta;
     *n1 = b + tb;
     *n2 = d + td;

data/vendor/libyeptris/src/yeptris/dom/dom.c

@@ -142,14 +142,16 @@ static yep_sview dom_str_in(yep_dom* d, const yep_view* v, int borrowed) {
  * given metadata; tag/anchor views encode through dom_str_in (tags and
  * event-path anchors copy to the arena; input-backed views borrow).
  * tag_id stays 0 — the caller resolves (scalars) or leaves 0. */
-/* Value assign + the emit-side fact bit (issue #352 lane 2): the bit
- * is "verified clean" of the dq-forced byte set — the serializer's
- * sc_route then skips its per-derive rescan. The scan is the SSOT
- * predicate (yep_scan_dq_forced); every value assignment routes
+/* Value assign + the emit-side fact bits (issues #352 lanes 2-3):
+ * no_exotic is "verified clean" of the dq-forced byte set (sc_route
+ * skips its rescan); plain_ok is the full plain-safety verdict (the
+ * emitter skips its walk — the block kernel's 35% frame). Both facts
+ * ride the scan/'s SSOT predicates; every value assignment routes
  * through here so no path can leave a dirty scalar marked clean. */
 static void dom_set_value(yep_dom* d, uint32_t id, const yep_view* v, int borrowed) {
     d->nodes[id].value = dom_str_in(d, v, borrowed);
     d->nodes[id].no_exotic = !yep_scan_dq_forced(v->p, v->len);
+    d->nodes[id].plain_ok = (uint8_t)yep_scan_plain_safe(v->p, v->len);
 }
 
 uint32_t dom_open_node(yep_dom* d, uint8_t kind, const yep_view* tag, const yep_view* anchor,
@@ -221,8 +223,13 @@ static int dom_anchor_set(yep_dom* d, uint32_t ordinal, uint32_t node) {
         if (d->anchor_nodes != NULL) {
             memcpy(na, d->anchor_nodes, d->anchor_nodes_cap * sizeof(*na));
             yep_free(d->sys, d->anchor_nodes);
-            yep_free(d->sys, d->mut_att);
-            yep_free(d->sys, d->mut_depth);
+            /* ONLY the anchor table: the mut side tables belong to
+             * dom_mut_grow alone (it allocates, copies and frees them
+             * together with the cap that tracks their size). These two
+             * frees were copy-paste debris from that path -- harmless
+             * today only because the mutation tables cannot exist
+             * during a parse -- but the ownership must not rely on
+             * that accident (audit 2026-10-31). */
         }
         d->anchor_nodes = na;
         d->anchor_nodes_cap = cap;
@@ -1139,7 +1146,7 @@ void dom_on_flow_rollback(void* ctx) {
  * call — the DOM stack mirrors what the MAP_START event would have
  * pushed. 0 only for the depth cap (the engine then takes the events,
  * which own the error). */
-int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col) {
+int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint32_t key_col) {
     yep_dom* d = (yep_dom*)ctx;
     if (d->depth >= YEP_DOM_MAX_DEPTH) {
         return 0;
@@ -1187,7 +1194,7 @@ int dom_on_block_item(void* ctx, const yep_block_value* v) {
  * happen when the engine resolved the name) falls back to the two
  * events with nothing built. */
 int dom_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v, uint32_t line,
-                      uint16_t key_col, uint16_t val_col) {
+                      uint32_t key_col, uint32_t val_col) {
     yep_dom* d = (yep_dom*)ctx;
     uint32_t target = 0;
     if (v->cls == YEP_LVAL_ALIAS) {

data/vendor/libyeptris/src/yeptris/dom/dom.h

@@ -68,6 +68,12 @@ typedef struct yep_dnode {
                             * byte set (#352 lane 2): the serializer's
                             * sc_route skips its rescan. Set at every
                             * value assignment; 0 = unknown = scan. */
+    uint8_t plain_ok;      /* value bytes verified yep_scan_plain_safe
+                            * (#352 lane 3): the emitter skips its
+                            * plain-safety walk (the block kernel's 35%
+                            * frame). Same invariant as no_exotic: set
+                            * at every dom_set_value; 0 = unknown =
+                            * derive. */
     uint8_t tag_id;        /* resolved tag (resolve/resolver.h) */
     uint32_t first_child;  /* child link (mappings: key,value,key,value…) */
     uint32_t last_child;
@@ -283,8 +289,8 @@ int dom_on_scalar(void* ctx, const yep_view* value, const yep_view* tag, const y
                   int borrowed);
 
 int dom_on_block_pair(void* ctx, const yep_view* key, const struct yep_block_value* v,
-                      uint32_t line, uint16_t key_col, uint16_t val_col);
-int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col);
+                      uint32_t line, uint32_t key_col, uint32_t val_col);
+int dom_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint32_t key_col);
 int dom_on_block_item(void* ctx, const yep_block_value* v);
 
 /* Direct DOM construction from a strict-validated JSON buffer

data/vendor/libyeptris/src/yeptris/dom/ytape.c

@@ -241,7 +241,7 @@ static int yt_on_scalar(void* ctx, const yep_view* value, const yep_view* tag,
 }
 
 static int yt_on_block_pair(void* ctx, const yep_view* key, const yep_block_value* v, uint32_t line,
-                            uint16_t key_col, uint16_t val_col) {
+                            uint32_t key_col, uint32_t val_col) {
     (void)line;
     (void)key_col;
     (void)val_col; /* yep_dnode carries no positions (64-2c) */
@@ -278,7 +278,7 @@ static int yt_on_block_pair(void* ctx, const yep_view* key, const yep_block_valu
     return 1; /* handled: the engine skips the two events */
 }
 
-static int yt_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col) {
+static int yt_on_block_open(void* ctx, const yep_view* key, uint32_t line, uint32_t key_col) {
     (void)line;
     (void)key_col;
     yep_ytape* t = (yep_ytape*)ctx;

data/vendor/libyeptris/src/yeptris/emit/emit.c

@@ -551,6 +551,10 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
         return 0;
     }
     em.w.p = window;
+    /* the writer owns the window size now: wr_put's chunked path and
+     * the fused member write bounds-check against it (a scalar larger
+     * than the window used to memcpy straight past it) */
+    em.w.cap = YEP_EMIT_WATERMARK * 2;
     em.w.sink_aborted = 0;
     size_t total = yep_emit_run(&em, 0);
     if (em.w.len > 0 && !em.w.sink_aborted) {

data/vendor/libyeptris/src/yeptris/emit/style.c

@@ -1,203 +1,21 @@
-/* style.c — the style rule table (TODO.impl/13). */
+/* style.c — the style rule table (TODO.impl/13).
+ *
+ * The plain-safety predicate LIVES in scan/scan.c (yep_scan_plain_safe,
+ * #352 lane 3): bytes→facts is scan/'s alone, and the DOM's parse-time
+ * fact bit and this emitter side read the ONE walk so the verdicts
+ * cannot drift. These are the emit-side names over it. */
 
 #include "style.h"
 
-#include <string.h>
-
-static int is_blank(char c) {
-    return c == ' ' || c == '\t';
-}
-
-static int is_break(char c) {
-    return c == '\n' || c == '\r';
-}
+#include "../scan/scan.h"
 
 int yep_style_plain_safe(const char* p, uint32_t len) {
-    if (len == 0) {
-        return 0; /* empty needs quotes or an empty-value slot */
-    }
-    if (is_blank(p[0]) || is_blank(p[len - 1])) {
-        return 0;
-    }
-    if (len >= 3 && (unsigned char)p[0] == 0xef && (unsigned char)p[1] == 0xbb &&
-        (unsigned char)p[2] == 0xbf) {
-        /* a LEADING U+FEFF re-parses as a document BOM and vanishes —
-         * the emitted form must carry its escape ("\uFEFF", the
-         * nightly's run 38258674337); mid-token BOMs ride plain */
-        return 0;
-    }
-    switch (p[0]) {
-    case ':':
-        /* libyaml (Psych symbol dumps ":name"): a leading colon only
-         * indicates when followed by a blank/EOL — the interior rule
-         * below covers it; ":name" stays plain */
-        break;
-    case '-':
-    case '?':
-        /* indicators only before a blank or EOL: "-5" and "?x" are
-         * plain (libyaml emits negative numbers plain; Psych, too) —
-         * but fall through: the document-marker check below owns
-         * the bare "---"/"..." (libyaml quotes those) */
-        if (len == 1 || is_blank(p[1])) {
-            return 0;
-        }
-        break;
-    case ',':
-    case '[':
-    case ']':
-    case '{':
-    case '}':
-    case '#':
-    case '&':
-    case '*':
-    case '!':
-    case '|':
-    case '>':
-    case '\'':
-    case '"':
-    case '%':
-    case '@':
-    case '`':
-        return 0;
-    default:
-        break;
-    }
-    /* The interior scan in SWAR words: every reject condition is a
-     * byte-class adjacency, so one masked word test is exact —
-     * break/tab bytes reject directly; ':' rejects with a blank at its
-     * NEXT lane (or the span's EOL); '#' with a blank at its PREVIOUS
-     * lane (the span's first byte is exempt — the head switch already
-     * handled a leading '#'). Cross-word adjacency rides one carried
-     * byte per boundary; the tail runs the byte loop, whose rules read
-     * real neighbors and need no carries. */
-    {
-        const uint64_t ONES = 0x0101010101010101ull;
-        const uint64_t HIGH = 0x8080808080808080ull;
-#define YST_ZDET(w, ch)                                                                            \
-    ((((w) ^ (uint64_t)(ch) * ONES) - ONES) & ~((w) ^ (uint64_t)(ch) * ONES) & HIGH)
-        /* the all-boring accept (#742): a span of pure [0-9A-Za-z_]
-         * makes EVERY rule in this function vacuous — no indicators
-         * (the head switch), no blanks at the ends, no BOM, no
-         * ': '/' #' adjacency, no breaks, and no ---/... marker — so
-         * one range test per word accepts without the six-mask walk.
-         * Anything else falls through to the exact scan below. */
-        {
-            uint32_t bi = 0;
-            int boring = 1;
-            while (bi + 8 <= len) {
-                uint64_t bw;
-                memcpy(&bw, p + bi, 8);
-                if (bw & HIGH) {
-                    boring = 0;
-                    break;
-                }
-                /* per-lane unsigned range checks via borrow bits: alpha
-                 * is (t - 'a') and ('z' - t) both borrow-free with
-                 * t = w|0x20 (A-Z fold); digits bound 0x30..0x39 */
-                uint64_t t = bw | (ONES * 0x20);
-                uint64_t bad = ((t - ONES * 0x61) | (ONES * 0x7A - t)) & HIGH; /* alpha */
-                bad |= ((bw - ONES * 0x30) | (ONES * 0x39 - bw)) & HIGH;       /* digit */
-                bad &= ~YST_ZDET(bw, '_'); /* the one extra boring byte */
-                if (bad != 0) {
-                    boring = 0;
-                    break;
-                }
-                bi += 8;
-            }
-            if (boring) {
-                for (; bi < len; bi++) {
-                    char c = p[bi];
-                    int a = (c | 0x20);
-                    if (!((c >= '0' && c <= '9') || (a >= 'a' && a <= 'z') || c == '_')) {
-                        boring = 0;
-                        break;
-                    }
-                }
-                if (boring) {
-                    return 1;
-                }
-            }
-        }
-        uint32_t i = 0;
-        int prev_blank7 = 0;
-        while (i + 8 <= len) {
-            uint64_t w;
-            memcpy(&w, p + i, 8);
-            if (w & HIGH) {
-                /* multibyte content: the byte loop owns the rest — a raw
-                 * LS/PS/NEL rides in a scalar value since the quote-aware
-                 * normalizer (#638) and is a line break on re-parse, so
-                 * the value must be quoted, not plain (the nightly's
-                 * round 18, crash-1e79b2e3) */
-                break;
-            }
-            uint64_t space = YST_ZDET(w, ' ');
-            uint64_t tab = YST_ZDET(w, '\t');
-            uint64_t blank = space | tab;
-            uint64_t colon = YST_ZDET(w, ':');
-            uint64_t hash = YST_ZDET(w, '#');
-            /* tab and the breaks reject outright */
-            if (tab | YST_ZDET(w, '\n') | YST_ZDET(w, '\r')) {
-                return 0;
-            }
-            /* ':' + blank next: (blank >> 8) pulls lane i+1's flag down
-             * into lane i; the word's last lane takes the peeked byte
-             * (EOL at the span end counts as blank — the rule rejects
-             * there) */
-            if (colon) {
-                int next_blank = i + 8 < len ? is_blank(p[i + 8]) : 1;
-                if (colon & ((blank >> 8) | (next_blank ? (uint64_t)0x80 << 56 : 0))) {
-                    return 0;
-                }
-            }
-            /* '#' + blank prev: (blank << 8) lifts lane i-1's flag up
-             * into lane i; lane 0 takes the carried last-lane flag */
-            if (hash && (hash & ((blank << 8) | (prev_blank7 ? 0x80 : 0)))) {
-                return 0;
-            }
-            prev_blank7 = (int)((blank >> 63) & 1); /* lane 7's flag is its top bit */
-            i += 8;
-        }
-#undef YST_ZDET
-        for (; i < len; i++) {
-            char c = p[i];
-            if (is_break(c) || c == '\t') {
-                return 0;
-            }
-            if ((unsigned char)c == 0xE2 && i + 2 < len && (unsigned char)p[i + 1] == 0x80 &&
-                ((unsigned char)p[i + 2] & 0xFE) == 0xA8) {
-                return 0; /* a raw LS/PS re-parses as a line break */
-            }
-            if ((unsigned char)c == 0xC2 && i + 1 < len && (unsigned char)p[i + 1] == 0x85) {
-                return 0; /* a raw NEL ditto */
-            }
-            if (c == ':') {
-                if (i + 1 >= len || is_blank(p[i + 1])) {
-                    return 0;
-                }
-            }
-            if (c == '#') {
-                if (i > 0 && is_blank(p[i - 1])) {
-                    return 0;
-                }
-            }
-        }
-    }
-    /* document markers */
-    if (len >= 3 && (memcmp(p, "---", 3) == 0 || memcmp(p, "...", 3) == 0) &&
-        (len == 3 || p[3] == ' ' || p[3] == '\t' || p[3] == '\n' || p[3] == '\r')) {
-        /* a PREFIX marker is worse than the bare one: emitted plain at
-         * line start, "--- ..." re-reads as a document marker (the
-         * nightly's "--- --- >" folded-plain crasher) — libyaml quotes
-         * both */
-        return 0;
-    }
-    return 1;
+    return yep_scan_plain_safe(p, len);
 }
 
 int yep_style_plain_key_safe(const char* p, uint32_t len) {
     /* plain_safe's colon rule is the key rule too: a colon only ends a
      * key when followed by a blank/EOL, so "a:b" and ":name" are plain
      * keys (libyaml emits Psych's symbol dumps exactly this way) */
-    return yep_style_plain_safe(p, len);
+    return yep_scan_plain_safe(p, len);
 }