yeptris 0.6.30.1-powerpc64le-linux → 0.6.31.2-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57222d99a292ca313a29dd6e849ce9bf42881805c61888c4b554e472b6c9b780
-  data.tar.gz: 9cb6e71e7e624320f131eddf9d1a702d9a9471948e4a3d7ae04cef8657d6a54b
+  metadata.gz: 0e9688f533c0a29fb0ab4447d915cebc3b49b2ef4b7fd89ccd01b8987ac306e9
+  data.tar.gz: 505362de7b095d280bd29d664d4bac1111743d70eec13a391937c4425dc77a38
 SHA512:
-  metadata.gz: a98785e26ecf1c2d9b4390b93a027045281664f3ff085165b2f80d471e47ce9825d8d92ba872f3232ee3cb8f47b14e34e24f37ab43556b45f2c917111117427a
-  data.tar.gz: 04f99c910d23c9c354382a53dc47f535019e0f841859c9d9e3eb5ade1892d5df2b69d98421239aaf8de9d1ea5d39ce440a224c9a98121cd9baff6500effef71b
+  metadata.gz: 4fd7a0e32448ae590f0656fc46f5fcccabd80a6253fffcf57a730de3ab6453fa92d6750532bfedacea398ddc9d865e3e7743afd1356f82f7c34387f5b66cb3a5
+  data.tar.gz: b9c26e0e5c8f20d0b688bead87ce58f3c9ce9ffbe9634393732ca2f45713f999b29e356aecc09df7a364cf3d2278e9c2e2eec1f9e289cb35272522999463da5f

data/lib/yeptris/yaml.rb

@@ -263,7 +263,7 @@ module Yeptris
           return true
         end
         return false if s.empty? || s != s.strip
-        return false if s.match?(/[\n\t]/)
+        return false if s.match?(/[\n\t\u0085\u2028\u2029\uFEFF]/)
         c = s[0]
         return false if "#,[]{}&*!|>'\"%@`".include?(c)
         return false if "-?:".include?(c) && (s.length == 1 || s[1] =~ /[ \t]/)
@@ -309,7 +309,12 @@ module Yeptris
         return :double if !s.empty? && !s.include?('"') && s.match?(/\A[^[:word:]]/)
         return :single if s.match?(/\A0[0-7]*[89]/)
         return :plain if plain_string?(s)
+        # the Unicode breaks are YAML breaks like \n (raw, re-parse
+        # folds them) and U+FEFF raw is the BOM (re-parse strips it) —
+        # only the double-quoted escapes carry them byte-stably; psych
+        # double-quotes them all (Psych.dump("b\u0085c") == "b\\Nb")
         return :double if s.each_byte.any? { |b| b < 0x20 || b == 0x7f }
+        return :double if s.match?(/[\u0085\u2028\u2029\uFEFF]/)
         :single
       end
 

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.30.1".freeze
+  VERSION = "0.6.31.2".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.30
+    VERSION 0.6.31
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )
@@ -100,8 +100,12 @@ endif()
 
 # libFuzzer implies ASAN (libleptris TODO 40 pattern).
 if(YEPTRIS_ENABLE_FUZZING)
+    # instrument everything, but link the fuzzer MAIN only into the
+    # harnesses: a global -fsanitize=fuzzer link option demands
+    # LLVMFuzzerTestOneInput from every executable (the CLI and the
+    # test binaries died on it once CXX also pinned to clang++)
     add_compile_options(-fsanitize=fuzzer-no-link,address -fno-omit-frame-pointer -g)
-    add_link_options(-fsanitize=fuzzer,address)
+    add_link_options(-fsanitize=address)
     message(STATUS "libFuzzer: ENABLED (implies ASAN)")
 endif()
 

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

@@ -179,6 +179,11 @@ static ptrdiff_t yep_avx2_quote_scan(const char* s, size_t len, char q, int* has
             }
             return (ptrdiff_t)(i + k);
         }
+        if (i >= len) {
+            break; /* an escape at the boundary consumed the rest: unterminated
+                    * (a lone '\' as the last byte pushed i past len; the tail
+                    * call would underflow len - i and read out of bounds) */
+        }
         if (i + YEP_AVX2_CHUNK > len) {
             int tail_esc = 0;
             ptrdiff_t r = yep_text_quote_scan_scalar(s + i, len - i, q, &tail_esc);

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

@@ -1422,7 +1422,8 @@ static int yt_f_run(yt_fused* F) {
                        (line_stop + 1 >= line_end || p[line_stop + 1] == ' ' ||
                         p[line_stop + 1] == '\t') &&
                        !(c == '&' || c == '!' || c == '*' || c == '\'' || c == '"' || c == '[' ||
-                         c == '{' || c == '|' || c == '>' || c == '%' || c == '?' || c == '-')) {
+                         c == '{' || c == '|' || c == '>' || c == '%' || c == '?' || c == '-') &&
+                       yep_plain_first_ok((unsigned char)c)) {
                 uint32_t kend = line_stop;
                 while (kend > t0 && (p[kend - 1] == ' ' || p[kend - 1] == '\t')) {
                     kend--;
@@ -1450,6 +1451,10 @@ static int yt_f_run(yt_fused* F) {
                     }
                     aoff = (uint32_t)(vt + 1);
                     alen = (uint32_t)(ne - vt - 1);
+                    if (alen == 0) {
+                        return 1; /* an anchor needs a name (libyaml):
+                                     the engine owns the error */
+                    }
                     F->anchor_seq++;
                     aid = F->anchor_seq;
                     if (!yt_anchor_table(F)) {
@@ -1810,13 +1815,20 @@ static int yt_f_run(yt_fused* F) {
                         goto line_done;
                     }
                     if (vc == '"' || vc == '\'' || vc == '|' || vc == '>' || vc == '[' ||
-                        vc == '{' || vc == '!' || vc == '%') {
-                        return 1; /* quoted/block/flow/tag values: the engine */
+                        vc == '{' || vc == '!' || vc == '%' || vc == '&' || vc == '*') {
+                        return 1; /* quoted/block/flow/tag/anchor/alias values:
+                                     the engine */
                     }
                     if ((vc == '-' || vc == '?') && (vt + 1 >= line_end || p[vt + 1] == ' ' ||
                                                      p[vt + 1] == '\t' || p[vt + 1] == '#')) {
                         return 1; /* an indicator-as-value: the engine errors */
                     }
+                    if (!yep_plain_first_ok(vc)) {
+                        return 1; /* '}' ']' ',' '@' '`' '%': no node
+                                   * content can start there (the nightly's
+                                   * fuzz_roundtrip crasher, "u: }") — the engine
+                                   * errors cleanly */
+                    }
                     /* a terminating ':' inside the value is the
                      * mapping-values error — the engine owns it */
                     for (const char* h = (const char*)memchr(p + vt, ':', line_end - vt);

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

@@ -142,6 +142,45 @@ static void emit_dq(yep_writer* w, const char* p, uint32_t n) {
     uint32_t run = 0;
     for (uint32_t i = 0; i < n; i++) {
         unsigned char c = (unsigned char)p[i];
+        /* U+0085 (NEL) is a BREAK in YAML: raw it would fold on
+         * re-parse. Escape it ('\N' replaces the exact UTF-8 pair, so
+         * lengths stay equal). The nightly's fuzz_roundtrip
+         * byte-instability crasher, "\"1 \\N\"". */
+        if (c == 0xc2 && i + 1 < n && (unsigned char)p[i + 1] == 0x85) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, "\\N", 2);
+            i++;
+            continue;
+        }
+        /* LS/PS (U+2028/U+2029) are libyaml breaks: raw, re-parse
+         * folds them (the nightly's ";\\P" catch). 2-char escapes of
+         * 3-byte sequences: the one-pass dry count sizes them. */
+        if (c == 0xe2 && i + 2 < n && (unsigned char)p[i + 1] == 0x80 &&
+            ((unsigned char)p[i + 2] == 0xa8 || (unsigned char)p[i + 2] == 0xa9)) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, (unsigned char)p[i + 2] == 0xa8 ? "\\L" : "\\P", 2);
+            i += 2;
+            continue;
+        }
+        /* U+FEFF must never ride raw: at the buffer head it IS the
+         * BOM and re-parse would strip it (the nightly's UTF-32LE
+         * catch); Psych escapes it everywhere ("") */
+        if (c == 0xef && i + 2 < n && (unsigned char)p[i + 1] == 0xbb &&
+            (unsigned char)p[i + 2] == 0xbf) {
+            if (run) {
+                wr_put(w, p + i - run, run);
+                run = 0;
+            }
+            wr_put(w, "\\uFEFF", 6);
+            i += 2;
+            continue;
+        }
         if (c >= 0x20 && c != '"' && c != '\\' && c != 0x7f) {
             run++;
             continue;
@@ -330,6 +369,34 @@ enum { YEP_SC_NOTHING = 0, YEP_SC_PLAIN, YEP_SC_SQ, YEP_SC_DQ, YEP_SC_LITERAL };
 
 static uint8_t sc_route(yep_writer* w, const char* p, uint32_t len, int as_key, uint8_t sty_in,
                         int has_tag) {
+    /* U+0085 is a break (only its \\N escape is byte-stable) and U+FEFF
+     * raw is the BOM (re-parse would strip it): both force the
+     * double-quoted route BEFORE the plain fast path can take them
+     * (the nightly's fuzz_roundtrip crashers). The NEL scan matches
+     * the UTF-8 PAIR only — a lone 0x85 is a continuation byte
+     * (U+315B = E3 85 9B). */
+    int has_nel = 0;
+    int has_bom = 0;
+    for (uint32_t k = 0; k + 1 < len; k++) {
+        if ((unsigned char)p[k] == 0xc2 && (unsigned char)p[k + 1] == 0x85) {
+            has_nel = 1;
+            break;
+        }
+        /* LS/PS are breaks like NEL: only their escapes are stable */
+        if ((unsigned char)p[k] == 0xe2 && k + 2 < len && (unsigned char)p[k + 1] == 0x80 &&
+            ((unsigned char)p[k + 2] == 0xa8 || (unsigned char)p[k + 2] == 0xa9)) {
+            has_nel = 1;
+            break;
+        }
+        if ((unsigned char)p[k] == 0xef && k + 2 < len && (unsigned char)p[k + 1] == 0xbb &&
+            (unsigned char)p[k + 2] == 0xbf) {
+            has_bom = 1;
+            break;
+        }
+    }
+    if (has_nel || has_bom) {
+        return YEP_SC_DQ;
+    }
     if ((sty_in == 1) && len > 0 &&
         (as_key ? yep_style_plain_key_safe(p, len) : yep_style_plain_safe(p, len))) {
         return YEP_SC_PLAIN; /* plain-safe implies no breaks: memchr skipped */

data/vendor/libyeptris/src/yeptris/parse/engine.c

@@ -119,6 +119,11 @@ struct yep_engine {
     char* norm_buf;                      /* owned input copy with exotic breaks normalized */
     const struct yep_resolver* resolver; /* implicit-typing schema (10) */
     int max_depth;                       /* runtime nesting limit (options) */
+    uint16_t rec;                        /* e_node<->e_parse_value call depth:
+                                            the props/value-line chain opens NO
+                                            container frame, so e->depth cannot
+                                            bound it (the nightly's stack
+                                            overflow crasher) */
     int last_root_flow;                  /* a root-level flow node just completed */
     int tag_undef;                       /* an unresolved !handle! was seen (QLJ7) */
     int doc_inline;                      /* content node opened on the --- line */
@@ -1090,16 +1095,32 @@ static void e_props(yep_engine* e, yep_view* anchor, yep_view* tag) {
             e->pos = yep_scan_prop_end(e->p, e->len, start);
             anchor->p = e->p + start;
             anchor->len = (uint32_t)(e->pos - start);
+            if (anchor->len == 0) {
+                /* libyaml requires one or more anchor characters
+                 * ("did not find expected alphabetic or numeric
+                 * character"); the nightly fuzz_roundtrip crasher,
+                 * a lone '&' */
+                e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
+                return;
+            }
         } else if (c == '!') {
             size_t start = e->pos;
             e->pos++;
             if (e->pos < e->len && e->p[e->pos] == '<') {
-                while (e->pos < e->len && e->p[e->pos] != '>') {
-                    e->pos++;
-                }
-                if (e->pos < e->len) {
-                    e->pos++;
-                }
+                /* a verbatim tag closes '>' on the same line, with no
+                 * interior space and non-empty content — libyaml errors
+                 * otherwise ("did not find expected '>'"; the nightly's
+                 * fuzz_roundtrip byte-instability crasher, "!<") */
+                size_t gt = e->pos + 1;
+                while (gt < e->len && e->p[gt] != '>' && e->p[gt] != '\n' && e->p[gt] != '\r' &&
+                       e->p[gt] != ' ' && e->p[gt] != '\t') {
+                    gt++;
+                }
+                if (gt >= e->len || e->p[gt] != '>' || gt == e->pos + 1) {
+                    e_fail(e, YEP_ERR_UNEXPECTED, start);
+                    return;
+                }
+                e->pos = gt + 1;
             } else {
                 while (e->pos < e->len && yep_scan_prop_char((unsigned char)e->p[e->pos])) {
                     e->pos++;
@@ -1282,6 +1303,9 @@ static int e_flow_node(yep_engine* e, yep_event* ev, int keyish) {
     ev->col = e_col(e, e->pos) + 1;
     yep_view anchor = {0}, tag = {0};
     e_props(e, &anchor, &tag);
+    if (e->err.code != YEP_ERR_NONE) {
+        return -1; /* e_props failed (empty anchor name, unresolved tag) */
+    }
     ev->anchor = anchor;
     ev->tag = tag;
     if (!yep_view_is_empty(anchor)) {
@@ -1290,10 +1314,17 @@ static int e_flow_node(yep_engine* e, yep_event* ev, int keyish) {
     if (e_flow_ws(e) != 0) {
         return -1;
     }
+    if (e->pos >= e->len) {
+        /* props at EOF: no node follows the properties (the entry
+         * guard above cannot cover this — e_props consumed to the
+         * end; found by fuzz_parse, input "[!<<\r\n!]" x8) */
+        return e_fail(e, YEP_ERR_UNEXPECTED, e->pos);
+    }
     c = (unsigned char)e->p[e->pos];
     if ((c == ',' || c == ']' || c == '}' || c == ':') &&
         (!yep_view_is_empty(anchor) || !yep_view_is_empty(tag))) {
         ev->implicit = 1; /* properties with no node: a tagged null */
+        ev->style = YEP_STYLE_PLAIN;
         e_pos_mark(e, e->pos, &ev->end_line, &ev->end_col);
         return 1;
     }
@@ -1813,6 +1844,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 /* '? : v' / '?' at the boundary: an EMPTY explicit key */
                 e_event_init(&ev, YEP_EV_SCALAR);
                 ev.implicit = 1;
+                ev.style = YEP_STYLE_PLAIN;
                 ev.line = e->line;
                 ev.col = e_col(e, e->pos) + 1;
                 rc = 1;
@@ -1984,6 +2016,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2026,6 +2059,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2059,6 +2093,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 yep_event nv;
                 e_event_init(&nv, YEP_EV_SCALAR);
                 nv.implicit = 1;
+                nv.style = YEP_STYLE_PLAIN;
                 if (emit_now(e, &nv) != 0) {
                     return -2;
                 }
@@ -2076,6 +2111,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2104,6 +2140,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                 yep_event nv;
                 e_event_init(&nv, YEP_EV_SCALAR);
                 nv.implicit = 1;
+                nv.style = YEP_STYLE_PLAIN;
                 if (emit_now(e, &nv) != 0) {
                     return -2;
                 }
@@ -2114,6 +2151,7 @@ static int e_flow(yep_engine* e, yep_view anchor, yep_view tag, uint32_t anchor_
                     yep_event nv;
                     e_event_init(&nv, YEP_EV_SCALAR);
                     nv.implicit = 1;
+                    nv.style = YEP_STYLE_PLAIN;
                     if (emit_now(e, &nv) != 0) {
                         return -2;
                     }
@@ -2657,7 +2695,13 @@ static int e_node(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
         e->pend_anchor_id = anchor_ordinal;
         e->pend_tag = node_t;
         e->doc_inline = 0; /* the node starts on a later line */
-        return e_parse_value(e, ctx, floor_col);
+        if (++e->rec >= e->max_depth) {
+            e->rec--;
+            return e_fail(e, YEP_ERR_DEPTH, e->pos);
+        }
+        int rc = e_parse_value(e, ctx, floor_col);
+        e->rec--;
+        return rc;
         /* (ctx stays: AFTER_COLON converts to VALUE_LINE at the break) */
     }
 
@@ -3069,7 +3113,15 @@ static int e_parse_value(yep_engine* e, yep_ctx ctx, uint16_t floor_col) {
             (vctx == YEP_CTX_VALUE_LINE && (li.first == '|' || li.first == '>') &&
              li.indent == floor_col)) {
             e->pos += li.indent;
-            return e_node(e, vctx, floor_col);
+            if (++e->rec >= e->max_depth) {
+                e->rec--;
+                return e_fail(e, YEP_ERR_DEPTH, e->pos);
+            }
+            {
+                int rc = e_node(e, vctx, floor_col);
+                e->rec--;
+                return rc;
+            }
         }
         /* indentless sequence as a mapping value; under a sequence frame
          * a dash at the same column is a SIBLING, not a continuation */

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

@@ -199,6 +199,10 @@ static void shape_value(const char* p, size_t len, const yep_line_info* li, size
     }
     if (c == '&') {
         size_t a_end = yep_scan_prop_end(p, len, vt + 1);
+        if (a_end == vt + 1) {
+            return; /* an anchor needs a name (libyaml): the general
+                     * chain owns the error */
+        }
         size_t t = a_end;
         while (t < len && (p[t] == ' ' || p[t] == '\t')) {
             t++;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.30.1
+  version: 0.6.31.2
 platform: powerpc64le-linux
 authors:
 - Ribose Inc.