yeptris 0.6.60.1-arm-linux-eabihf → 0.6.61.1-arm-linux-eabihf

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e078deaa97a27d09dc305c57e5d879ec727b506c0edfd6c1ef27a3fa7bb8d98
-  data.tar.gz: 9d3a325cba29a0c5c51f33be9c99ccca3ce4febdb46dd4595d2e7d3dbb73988e
+  metadata.gz: 62af06f8d7d9384dde77c3cca415da00be7d70f65505119fd43a82fa9e0c9e1f
+  data.tar.gz: afc2489139cdc52bb5d7f2a96382150c9cb78eca767741a806cbdd2c231b66bd
 SHA512:
-  metadata.gz: fa97a7e1b0332bcd8106b1c244d5a1b11641ff28c5be0fba465a84095cfc120a87e469a23e32acd7e19c6f1dbddabb2ce0c6b7eb372e3848a0866140d0771670
-  data.tar.gz: a54e2f72f58ef07db3ef50755aa03bfbc41381770f252387bc331e7c71ead5818bb8b352197960336f69056ebe04e25a3dc272ee43032645facddd7658239a30
+  metadata.gz: f7d3ecc7415faae434ffb16d3bf6578d5aa9130c98dc6057a5dca4ceecf2a5d6737a213f70c8fd2538a9a8e5a4015b80b526e557d8382ca0800ca61b1a235f2b
+  data.tar.gz: 114d8c80fb7ada38b45b9bba05b44c6b7087c3b6dde852bcdc0004fabaaa13211742122f557adc6f21a1c2b61e0e7e0eda135bb5f1beafebdacf7f07f7585823

data/ext/yeptris_native/version.h

@@ -11,8 +11,8 @@
 
 #define YEPTRIS_VERSION_MAJOR 0
 #define YEPTRIS_VERSION_MINOR 6
-#define YEPTRIS_VERSION_PATCH 60
-#define YEPTRIS_VERSION_STRING "0.6.60"
+#define YEPTRIS_VERSION_PATCH 61
+#define YEPTRIS_VERSION_STRING "0.6.61"
 
 #ifdef __cplusplus
 extern "C" {

data/lib/yeptris/yaml.rb

@@ -350,6 +350,16 @@ module Yeptris
                      Yeptris::FFI::BUILD_END => END_ENTRY }.freeze
 
       def dump(obj, canonical: false, header: false, width: nil)
+        # The nil root rides the bare form (psych's dump(nil) == "\n",
+        # #290): the engine's r201 quoted-form law ("a document-root
+        # empty scalar rides the quoted form" -- the plain form does not
+        # re-parse, the roundtrip invariant) renders the built empty
+        # scalar as "" -- correct for the engine's generic serializer,
+        # wrong for the psych surface. The binding maps an empty stream
+        # back to nil on load (load\#docs.empty?\#nil), so the bare form
+        # round-trips THROUGH THE BINDING while keeping the engine's
+        # invariant untouched.
+        return header ? "--- \n" : "\n" if obj.nil? && !canonical
         parts = []
         blob = String.new(encoding: Encoding::BINARY)
         off = [0]

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.60.1".freeze
+  VERSION = "0.6.61.1".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.60
+    VERSION 0.6.61
     DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
     LANGUAGES C CXX
 )

data/vendor/libyeptris/src/include/yeptris/parse.h

@@ -91,6 +91,27 @@ YEPTRIS_API YeptrisStatus yeptris_stream_iter_next(yeptris_stream_iter* it, Yept
 YEPTRIS_API YeptrisStatus yeptris_stream_iter_status(const yeptris_stream_iter* it, uint32_t* line,
                                                      uint32_t* col);
 
+/* The last successful step's document SLICE inside the iterator's
+ * buffer space (post-gate: BOM/transcode/normalization may have moved
+ * the buffer — the offsets are relative to the CURRENT buf the
+ * iterator holds, which is the space `yeptris_stream_iter_next`'s
+ * documents live in). Hosts that materialize through their own value
+ * route (the Python/Rust/TS drains) re-parse exactly these bytes and
+ * inherit the engine's framing without a DOM walk: one typing SSOT —
+ * the drain — and scanner-accurate frames. ARG on NULL; ARG when the
+ * last step was not a successful document. */
+YEPTRIS_API YeptrisStatus yeptris_stream_iter_slice(const yeptris_stream_iter* it, size_t* off,
+                                                    size_t* len);
+
+/* The iterator's ACTIVE buffer (the caller's bytes, or the post-gate
+ * owned copy after a BOM strip / UTF-16-32 transcode / NEL-LS-PS
+ * normalization) and its length. `yeptris_stream_iter_slice`'s offsets
+ * index THIS buffer — hosts copy their frame bytes out of here
+ * (ctypes.string_at / Rust slice / TS Buffer) and re-parse them through
+ * their own drain. Borrowed: valid until yeptris_stream_iter_free. */
+YEPTRIS_API YeptrisStatus yeptris_stream_iter_buffer(const yeptris_stream_iter* it,
+                                                     const char** buf, size_t* len);
+
 YEPTRIS_API void yeptris_stream_iter_free(yeptris_stream_iter* it);
 
 #ifdef __cplusplus

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

@@ -158,7 +158,18 @@ static yep_sview dom_str_in(yep_dom* d, const yep_view* v, int borrowed) {
         yep_sview sv = {0, 0};
         return sv;
     }
-    if (borrowed && v->p != NULL && d->input_base != NULL && (const char*)v->p >= d->input_base) {
+    /* The zero-copy law: borrow ONLY a view demonstrably inside the
+     * recorded input window. The old heap-order probe (v->p >=
+     * input_base) misfiled every engine-owned buffer that happened to
+     * sit above the caller's input — the r171 normalizer copy path
+     * (norm_buf) hands exactly such views to the pair/event builders —
+     * and the resulting input-relative offset was then layout luck per
+     * platform/build (the ubuntu-gcc / MSVC-arm / TSan / UBSan CI
+     * divergences of PR #1042). The upper bound makes the decision a
+     * pure function of the view's location class: both engines of a
+     * differential run now store identically on every platform. */
+    if (borrowed && v->p != NULL && d->input_base != NULL &&
+        (size_t)((const char*)v->p - d->input_base) + v->len <= d->input_len) {
         return yep_sv_input(d, *v);
     }
     return yep_dom_str_put(d, (const char*)v->p, v->len);

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

@@ -1640,15 +1640,64 @@ static int yt_f_run(yt_fused* F) {
                         col + 1 != st[depth].content_col && st[depth].phantom) {
                         yt_f_close(F, st[depth].kind);
                         st[depth].phantom = 0;
+                        st[depth].content_col =
+                            0; /* the content map is gone:
+                                * its column must not greet later pairs (the
+                                * stale-frame law, run 38179552341) — after the
+                                * chained-pending arm resumes here, a stale
+                                * column rode yt_f_open_form's sibling test and
+                                * misfiled the next pending's container as a
+                                * key-SCALAR ("b:\n c: d\nq:\n b:\n  c: d\n"
+                                * lost q's map; the nightly's run 42488986434) */
                     }
                     if (depth > 0 && st[depth].pending) {
-                        /* chained same-column pending ("a:\na:"): resolving
-                         * the first via yt_f_open corrupts the frame mapping
-                         * when the second's container carries valued pairs —
-                         * the OPEN'd map swallows the second key as the
-                         * first pair's value (the nightly's run 38110714729
-                         * tree corruption). The engine owns the shape */
-                        return 1;
+                        /* a chained pending ("a:\na:", the deep-nesting
+                         * "k:\n  k:\n    k:" ladder): resolve the outer
+                         * one before the sibling's frame takes the slot.
+                         * A same-column sibling key (col == the pending's
+                         * own column) gives the pending a NULL value —
+                         * the null pair MUST land now, or the OPEN'd
+                         * container swallows the sibling key as its
+                         * first pair's value (the nightly's run
+                         * 38110714729 tree corruption: {a: a, ?{b: c}:
+                         * h} instead of {a: null, a: {b: c}, h: v}).
+                         * When the OPEN form fired, the null pairs
+                         * INSIDE the opened container (parent → {k:
+                         * null}); under the key-SCALAR form it completes
+                         * the key's pair in the parent's map. A deeper
+                         * line (col > indent) opens the pending's
+                         * container and the chain nests. Anchored
+                         * pendings keep the engine: their anchor rides
+                         * the event path (yt_f_open drops the name) */
+                        if (st[depth].aid != 0) {
+                            return 1;
+                        }
+                        uint8_t of = yt_f_open_form(&st[depth - 1], depth == 1, st[depth].indent);
+                        if (aid != 0 && of == 0) {
+                            /* the outer pending resolved as a SIBLING
+                             * key-SCALAR: its value container is "the pair's",
+                             * materialized by the next OPEN-class record — but
+                             * the anchored pending resolves through the event
+                             * path, which emits its KEY SCALAR *before* the
+                             * anchored MAP_START. That key pairs with the
+                             * stranded outer key (the pair's value slot) and
+                             * the anchored map strands as a sibling key of the
+                             * parent: "2: e\n4:\n  5: &5\n    5: e\n7: s"
+                             * built {2:e, 4:"5", {5:e}&5:"7", s:null} instead
+                             * of {2:e, 4:{5:{5:e}&5}, 7:s} (the nightly's
+                             * crash-d8e3b3f392c37a62257576ce20d5a19b351f66ad,
+                             * round 213 — the first shape where a completed
+                             * pair arms root_pair_col BEFORE the chain). The
+                             * engine resolves the composition. */
+                            return 1;
+                        }
+                        yt_f_open(F, &st[depth], of);
+                        root_open = 1;
+                        if (col == st[depth].indent) {
+                            (void)yt_put(t, yt_props(YTP_SCALAR, 0, 0x0904u));
+                            yt_f_empty_span(F);
+                        }
+                        st[depth].pending = 0;
                     }
                     /* a spent key-SCALAR frame (resolved, phantom closed,
                      * no map of its own) gives its slot to the sibling —

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

@@ -112,6 +112,7 @@ YEPTRIS_API size_t yeptris_serialize_into_ex(YeptrisDocument handle,
     em.w.col = 0;
     em.w.sv_input = handle ? ((const yeptris_document*)handle)->dom->input_base : NULL;
     em.w.sv_arena = handle ? ((const yeptris_document*)handle)->dom->str : NULL;
+    em.w.resolver = handle ? ((const yeptris_document*)handle)->dom->resolver : NULL;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -181,6 +182,7 @@ YEPTRIS_API size_t yeptris_serialize_into_trusted(YeptrisDocument handle,
     em.w.col = 0;
     em.w.sv_input = ((const yeptris_document*)handle)->dom->input_base;
     em.w.sv_arena = ((const yeptris_document*)handle)->dom->str;
+    em.w.resolver = ((const yeptris_document*)handle)->dom->resolver;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -249,6 +251,7 @@ YEPTRIS_API char* yeptris_serialize_ex(YeptrisDocument handle, const yeptris_emi
     em.w.col = 0;
     em.w.sv_input = handle ? ((const yeptris_document*)handle)->dom->input_base : NULL;
     em.w.sv_arena = handle ? ((const yeptris_document*)handle)->dom->str : NULL;
+    em.w.resolver = handle ? ((const yeptris_document*)handle)->dom->resolver : NULL;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -390,6 +393,7 @@ YEPTRIS_API char* yeptris_serialize_json(YeptrisDocument handle, size_t* len) {
     em.w.col = 0;
     em.w.sv_input = handle ? ((const yeptris_document*)handle)->dom->input_base : NULL;
     em.w.sv_arena = handle ? ((const yeptris_document*)handle)->dom->str : NULL;
+    em.w.resolver = handle ? ((const yeptris_document*)handle)->dom->resolver : NULL;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -434,6 +438,7 @@ YEPTRIS_API char* yeptris_serialize_json_ex(YeptrisDocument handle, size_t* len,
     em.w.col = 0;
     em.w.sv_input = handle ? ((const yeptris_document*)handle)->dom->input_base : NULL;
     em.w.sv_arena = handle ? ((const yeptris_document*)handle)->dom->str : NULL;
+    em.w.resolver = handle ? ((const yeptris_document*)handle)->dom->resolver : NULL;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -480,6 +485,7 @@ char* yep_serialize_json_compact(const yeptris_document* doc, size_t* len) {
     em.w.col = 0;
     em.w.sv_input = doc->dom->input_base;
     em.w.sv_arena = doc->dom->str;
+    em.w.resolver = doc->dom->resolver;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -528,6 +534,7 @@ char* yep_serialize_json_pretty_ex(const yeptris_document* doc, size_t* len, con
     em.w.col = 0;
     em.w.sv_input = doc->dom->input_base;
     em.w.sv_arena = doc->dom->str;
+    em.w.resolver = doc->dom->resolver;
     em.w.sink = NULL;
     em.w.watermark = 0;
     em.w.sink_aborted = 0;
@@ -604,6 +611,7 @@ YEPTRIS_API size_t yeptris_serialize_stream(YeptrisDocument handle,
     em.w.col = 0;
     em.w.sv_input = handle ? ((const yeptris_document*)handle)->dom->input_base : NULL;
     em.w.sv_arena = handle ? ((const yeptris_document*)handle)->dom->str : NULL;
+    em.w.resolver = handle ? ((const yeptris_document*)handle)->dom->resolver : NULL;
     em.w.sink = sink;
     em.w.sink_ctx = ctx;
     em.w.watermark = YEP_EMIT_WATERMARK;

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

@@ -539,7 +539,33 @@ static void emit_literal(yep_writer* w, const yep_dnode* n, int parent_col) {
 /* Canonical scalar (13B): typed words and numbers plain, everything
  * else double-quoted; floats re-print through the shortest printer so
  * canonical output is a fixed point (parse of canonical re-prints
- * identically — the byte-stability gate). */
+ * identically — the byte-stability gate). The DOM stores only the tag
+ * + source text, so the typed arms re-derive the VALUE from the
+ * resolver's own tables (#937): the bool table decides true/false
+ * (the old length guess spelled every non-4-char true-word false), the
+ * int decode spells JSON-unspellable forms (0x1F/0o7) in decimal, and
+ * the inf/nan words ride quoted in JSON mode (no JSON infinity). */
+static int json_int_token(const char* p, uint32_t n) {
+    /* the strict JSON int token: -?(0|[1-9][0-9]*) — leading zeros
+     * and a '+' are YAML-spellable but not JSON (those decode) */
+    uint32_t i = 0;
+    if (i < n && p[0] == '-') {
+        i = 1;
+    }
+    if (i >= n) {
+        return 0;
+    }
+    if (p[i] == '0') {
+        return i + 1 == n;
+    }
+    for (uint32_t k = i; k < n; k++) {
+        if (p[k] < '0' || p[k] > '9') {
+            return 0;
+        }
+    }
+    return 1;
+}
+
 static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
     yep_view vdec = wv(w, n->value);
     const char* p = (const char*)vdec.p;
@@ -553,17 +579,24 @@ static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
                 wr_put(w, "~", 1);
             }
             return;
-        case YEPTRIS_TAG_BOOL:
-            if (len == 4) { /* true/TRUE/True/null-ish variants */
-                wr_put(w, (p[0] == 't' || p[0] == 'T') ? "true" : "null", 4);
-            } else { /* false family (5 chars) */
-                wr_put(w, "false", 5);
+        case YEPTRIS_TAG_BOOL: {
+            int bv = yep_tag_bool_value(p, len);
+            if (bv < 0) {
+                break; /* not a bool word: quoted (the resolver only
+                          tags the table's words; defense) */
             }
+            wr_put(w, bv ? "true" : "false", bv ? 4u : 5u);
             return;
+        }
         case YEPTRIS_TAG_FLOAT: {
             const char* word = yep_tag_float_word(p, len);
             if (word != NULL) {
-                wr_put(w, word, (uint32_t)strlen(word));
+                uint32_t wl = (uint32_t)strlen(word);
+                if (w->json) {
+                    emit_dq_json(w, word, wl);
+                } else {
+                    wr_put(w, word, wl);
+                }
                 return;
             }
             char buf[40];
@@ -584,8 +617,23 @@ static void emit_canonical_scalar(yep_writer* w, const yep_dnode* n) {
             break; /* unparseable view: fall through to quoting */
         }
         case YEPTRIS_TAG_INT:
-            wr_put(w, p, len);
-            return;
+            if (!w->json || json_int_token(p, len)) {
+                /* YAML keeps the source text (stable, lossless); JSON
+                 * keeps JSON-number-shaped text (big ints stay exact) */
+                wr_put(w, p, len);
+                return;
+            }
+            {
+                int compat = w->resolver == yep_resolver_compat11();
+                int64_t v;
+                if (yep_tag_int64(p, len, compat, &v) == 0) {
+                    char buf[24];
+                    int nl = snprintf(buf, sizeof buf, "%lld", (long long)v);
+                    wr_put(w, buf, (uint32_t)nl);
+                    return;
+                }
+            }
+            break; /* undecodable int text: quoted keeps JSON valid */
         default:
             break;
         }
@@ -1602,6 +1650,24 @@ static void emit_node(yep_emitter* em, uint32_t id, int parent_col, int as_key)
     }
     emit_tag(w, n);
     emit_anchor_ex(em, n);
+    if (parent_col < 0 && !w->canonical && !w->json && n->kind == 0 && n->style <= 1) {
+        /* A DOCUMENT-ROOT empty scalar rides the quoted form: libyaml
+         * renders "--- ''" and never a bare marker with nothing after
+         * it. A plain-empty root emitted as NOTHING (the value law of
+         * issue #290, "k:" — kept below for non-root contexts) sheds
+         * the root node entirely; the re-parse of that stream produced
+         * an ANY-styled empty root whose render is "" — and the bytes
+         * diverged on round two (the nightly's r201 fuzz_roundtrip
+         * byte-instability catch, ">\n! \n !<aaa: bbb\n...\n<NEL><NEL>",
+         * whose second document's break-only content parses to a
+         * plain-empty root). Quoting the root's emptiness makes every
+         * empty-root spelling converge on the same fixpoint bytes. */
+        yep_view vdec = wv(w, n->value);
+        if (vdec.len == 0) {
+            emit_dq(w, (const char*)vdec.p, vdec.len);
+            return;
+        }
+    }
     if (parent_col < 0) {
         parent_col = 0; /* root scalar: block body at column 2 */
     }
@@ -1755,7 +1821,16 @@ size_t yep_emit_run(yep_emitter* em, int dry) {
                 yep_view tdec3 = wv(w, root->tag);
                 wr_tag_token(w, &tdec3);
             }
-            if (root->anchor.len > 0) {
+            if (root->anchor.len > 0 && !anchor_name_unspellable(w, root)) {
+                /* the r235 law: the lead line writes the name UNQUOTED
+                 * and anchor names have no quoting -- a name the spell
+                 * law rejects has no safe lead-line spelling. The r235
+                 * nightly's riding-colon names ("&:" and the artifact's
+                 * "&k:\"" — run 42739927952, crash-5de6f9ff) re-parsed
+                 * as an anchored empty KEY of the follow-on collection
+                 * (the anchor lost, s1 != s2, byte growth); the
+                 * colon-tail law fails the serialize like every other
+                 * anchor write path (the r228 "&: |" law) */
                 if (root->tag.len > 0) {
                     wr_byte(w, ' '); /* props need the separator */
                 }

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

@@ -69,13 +69,16 @@ typedef struct yep_writer {
      * grow/flush checks run once per refill instead of once per byte;
      * 0 at run entry and whenever the guarantee lapses. */
     size_t reserve;
-    int in_flow;        /* scalars inside flow collections: plain must drop
-                           ',', '[', ']', '{', '}' — flow terminators */
-    int flow_item;      /* the NEXT scalar is a flow-SEQ item: a null must
-                           emit '~' (a bare nothing reads as "[, x]") */
-    int unserializable; /* an anchor name that cannot ride raw in flow
-                           context: the document has no safe spelling —
-                           serialize fails rather than corrupt */
+    int in_flow;                         /* scalars inside flow collections: plain must drop
+                                            ',', '[', ']', '{', '}' — flow terminators */
+    int flow_item;                       /* the NEXT scalar is a flow-SEQ item: a null must
+                                            emit '~' (a bare nothing reads as "[, x]") */
+    int unserializable;                  /* an anchor name that cannot ride raw in flow
+                                            context: the document has no safe spelling —
+                                            serialize fails rather than corrupt */
+    const struct yep_resolver* resolver; /* the document's implicit-typing
+        family (NULL = core12): the INT arm's decode needs the family's
+        own forms (leading-0 is octal in compat, decimal in core) */
 } yep_writer;
 
 typedef struct yep_emitter {

data/vendor/libyeptris/src/yeptris/events/values.c

@@ -452,6 +452,28 @@ int yep_values_from_input(const char* yaml, size_t len, int schema_compat, yep_v
             }
             /* fall through: engine */
         }
+        /* Unicode breaks (NEL/LS/PS) normalize to '\n' BEFORE the
+         * engine, exactly as the parse entry's front-end does
+         * (parse_frontend): this drain feeds the SAME compat-grammar
+         * engine, and a raw NEL it never normalized errors where
+         * parse accepts -- the nightly's round 239 roundtrip catch
+         * ("<NEL>...<NEL> >\n <NEL>...<NEL>\nt": marshal returned
+         * ERROR_PARSE on a document yeptris_parse_ex accepted and
+         * serialized cleanly). JSON stays above this: the JSON reader
+         * keeps U+0085 raw inside strings, only the YAML reader
+         * normalizes (the parse_frontend law). Ownership rides the
+         * same `transcoded` plumbing the transcode above installed. */
+        {
+            size_t nlen = 0;
+            int kept_raw = 0;
+            char* norm = yep_engine_normalize_breaks(sys, data, data_len, &nlen, &kept_raw);
+            if (norm != NULL) {
+                yep_free(sys, transcoded);
+                transcoded = (unsigned char*)norm;
+                data = (const char*)norm;
+                data_len = nlen;
+            }
+        }
         yep_engine* eng = yep_engine_create(yep_system_allocator());
         if (eng == NULL) {
             return -1;