yeptris 0.6.52.0-arm-linux-eabihf → 0.6.53.0-arm-linux-eabihf

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

@@ -97,7 +97,7 @@ void yep_scan_line_f(const char* p, size_t len, size_t pos, const yep_line_facts
     li.first = 0;
     li.end = f->end;
     size_t j = f->indent;
-    li.indent = (uint16_t)(j - pos);
+    li.indent = (uint32_t)(j - pos);
     if (j < li.end && p[j] == '\t') {
         size_t k = j;
         while (k < li.end && (p[k] == ' ' || p[k] == '\t')) {
@@ -162,6 +162,12 @@ static int yep_colon_terminates(const char* p, size_t len, size_t colon, int flo
     if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
         return 1;
     }
+    /* a raw NEL/LS/PS is a break like LF (libyaml's IS_BLANKZ): the
+     * value-position separator arm the #833 dig pinned — the LF twin
+     * terminated while the PS spelling kept the colon in the plain */
+    if (yep_scan_mb_break_len(p, len, next) > 0) {
+        return 1;
+    }
     if (flow && yep_ct_is(c, YEP_CT_FLOW_IND)) {
         return 1;
     }
@@ -198,6 +204,201 @@ int yep_scan_dq_forced(const char* p, uint32_t len) {
     return 0;
 }
 
+/* ---- the plain-safety truth table (moved from emit/style.c,
+ * #352 lane 3: scan owns bytes→facts; the emitter and the DOM's
+ * parse-time fact bit both read THIS walk so they cannot drift) ---- */
+
+static int is_blank(char c) {
+    return c == ' ' || c == '\t';
+}
+
+static int is_break(char c) {
+    return c == '\n' || c == '\r';
+}
+
+int yep_scan_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;
+}
+
 size_t yep_scan_prop_end(const char* p, size_t len, size_t pos) {
     while (pos < len) {
         unsigned char c = (unsigned char)p[pos];

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

@@ -20,7 +20,9 @@ extern "C" {
 typedef struct yep_line_info {
     uint32_t offset; /* byte offset of the line start */
     uint32_t end;    /* byte offset of the line break (exclusive content end) */
-    uint16_t indent; /* column of the first non-space (== end - offset when blank) */
+    uint32_t indent; /* column of the first non-space (== end - offset when blank);
+                      * 32-bit: a 65536-space line wrapped to 0 and read as a
+                      * dedent (the 2026-10-31 audit) */
     uint16_t flags;
     unsigned char first; /* first content byte ('\0' for blank lines) */
 } yep_line_info;
@@ -104,6 +106,15 @@ size_t yep_scan_prop_end(const char* p, size_t len, size_t pos);
  * AND the DOM's parse-time fact bit, so the two cannot drift. */
 int yep_scan_dq_forced(const char* p, uint32_t len);
 
+/* The plain-safety truth table (issue #352 lane 3): 1 when the span
+ * re-parses as a plain scalar in BLOCK context (value or key — the
+ * key wrapper is the same predicate; the colon rule covers keys).
+ * The bytes→facts home: the emitter's style chooser AND the DOM's
+ * parse-time fact bit read this one walk, so the verdicts cannot
+ * drift. Multibyte-aware (raw NEL/LS/PS reject; a leading U+FEFF
+ * rejects; mid-token BOMs ride). */
+int yep_scan_plain_safe(const char* p, uint32_t len);
+
 /* Tag-shorthand suffix byte: libyaml's URI set (";/?:@&=+$,_.!~*'()%"
  * plus alphanumerics; flow indicators and ',' terminate instead).
  * Stray non-set bytes stay visible as the props follower, which

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.52.0
+  version: 0.6.53.0
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.