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

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

@@ -53,6 +53,11 @@ int yep_engine_step(yep_engine* e, const char* chunk, size_t len, int final, con
  * allocates a fresh one if reused). Returns NULL when absent. */
 yep_pool* yep_engine_detach_pool(yep_engine* e);
 
+/* Detaches the run's break-normalizer copy (ownership moves to the
+ * caller; the caller owns the returned buffer once detached). Returns
+ * NULL when the run kept the input zero-copy. */
+char* yep_engine_detach_norm_buf(yep_engine* e, size_t* len_out);
+
 /* Implicit-typing schema for the next run (NULL: 1.2 core), and the
  * runtime nesting limit. */
 struct yep_resolver;

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

@@ -67,6 +67,9 @@ struct yeptris_stream_iter {
     YeptrisStatus last_status;       /* the LAST next()'s per-document verdict */
     uint32_t last_line;
     uint32_t last_col;
+    size_t last_off; /* the last SUCCESSFUL document's slice
+                      * in the (post-gate) buffer space */
+    size_t last_len;
 };
 
 yeptris_stream_iter* yeptris_stream_iter_new(const char* buf, size_t len,
@@ -127,6 +130,8 @@ static void it_fail(struct yeptris_stream_iter* it, YeptrisStatus st, uint32_t l
     it->last_status = st;
     it->last_line = line;
     it->last_col = col;
+    it->last_len = 0; /* the slice accessor must not serve a stale frame
+                       * (the success path sets off/len right after) */
 }
 
 static int engine_opts(yep_engine* eng, const YeptrisParseOptions* opts) {
@@ -290,12 +295,14 @@ YeptrisStatus yeptris_stream_iter_next(struct yeptris_stream_iter* it, YeptrisDo
             }
             return it->last_status;
         }
+        it_fail(it, YEPTRIS_OK, 0, 0);
+        it->last_off = it->cursor;
+        it->last_len = pos;
         it->cursor += pos;
         it->index++;
         if (index != NULL) {
             *index = it->index - 1;
         }
-        it_fail(it, YEPTRIS_OK, 0, 0);
         *out = doc;
         return YEPTRIS_OK;
     }
@@ -315,6 +322,31 @@ YeptrisStatus yeptris_stream_iter_status(const struct yeptris_stream_iter* it, u
     return it->last_status;
 }
 
+/* The last successful document's slice (parse.h): the host's value
+ * route re-parses exactly these bytes — one typing SSOT. */
+YeptrisStatus yeptris_stream_iter_slice(const struct yeptris_stream_iter* it, size_t* off,
+                                        size_t* len) {
+    if (it == NULL || off == NULL || len == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    if (it->last_status != YEPTRIS_OK || it->last_len == 0) {
+        return YEPTRIS_ERROR_ARG; /* a failure or the stream end was the last step */
+    }
+    *off = it->last_off;
+    *len = it->last_len;
+    return YEPTRIS_OK;
+}
+
+YeptrisStatus yeptris_stream_iter_buffer(const struct yeptris_stream_iter* it, const char** buf,
+                                         size_t* len) {
+    if (it == NULL || buf == NULL || len == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    *buf = it->buf;
+    *len = it->len;
+    return YEPTRIS_OK;
+}
+
 void yeptris_stream_iter_free(struct yeptris_stream_iter* it) {
     if (it == NULL) {
         return;

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

@@ -458,6 +458,11 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
     int norm_kept_raw = 0; /* raw NEL/LS/PS survived the quote-aware
                             * walk: the engine route owns the document
                             * (the tape runner predates the cut) */
+    char* nbuf = NULL;     /* the engine's break-normalizer copy (#953):
+                            * DOM and tape scalar slices point INTO it,
+                            * so the document must own it like the
+                            * finish pool and transcoded */
+    size_t nblen = 0;
 
     if (parse_frontend(buf, len, sys, json_mode, &data, &data_len, &transcoded, &transcoded_len,
                        &norm_kept_raw, &st) != 0) {
@@ -600,8 +605,11 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
     }
     /* Resolved tags, folded and escaped scalars live in the engine's
      * finish pool; the document must own it or every such string would
-     * dangle at engine teardown (found by ASAN). */
+     * dangle at engine teardown (found by ASAN). The break-normalizer
+     * copy is the same law (#953): scalar value slices in the DOM and
+     * the packed tape point INTO it. */
     yep_pool* finish = yep_engine_detach_pool(eng);
+    nbuf = yep_engine_detach_norm_buf(eng, &nblen);
     yep_engine_destroy(eng);
 
     /* Empty stream (no documents): NULL document with YEPTRIS_OK. */
@@ -613,6 +621,9 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
         }
         yep_pool_destroy(finish);
         yep_free(sys, transcoded);
+        if (nbuf != NULL) {
+            yep_free(sys, nbuf); /* not parked: no document survives */
+        }
         if (status != NULL) {
             *status = YEPTRIS_OK;
         }
@@ -631,6 +642,9 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
         yep_dom_destroy(dom);
         yep_pool_destroy(finish);
         yep_free(sys, transcoded);
+        if (nbuf != NULL) {
+            yep_free(sys, nbuf); /* not parked: no document survives */
+        }
         st = YEPTRIS_ERROR_MEMORY;
         goto fail;
     }
@@ -640,6 +654,31 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
                                                                            : YEPTRIS_SCHEMA_12_CORE;
     doc->transcoded = transcoded;
     doc->transcoded_len = transcoded_len;
+    if (nbuf != NULL) {
+        /* #953: the engine re-normalized THIS run (raw NEL/LS/PS rode
+         * quoted regions past the front-end), so every engine event
+         * view points INTO nbuf — and the lazy tape stored those
+         * pointers ABSOLUTE (they fall outside yt.input's range, so
+         * the span recorder kept them verbatim). The document owns
+         * nbuf like the finish pool, whichever copy the slot held. */
+        if (have_tape) {
+            /* rebase the tape's span base onto the doc-owned copy:
+             * materialization's input_base offsets against LIVE bytes.
+             * `transcoded` is referenced by no record (the engine
+             * parsed nbuf only) — release it. */
+            yt.input = nbuf;
+            yt.input_len = nblen;
+            yep_free(sys, transcoded);
+            transcoded = NULL;
+            doc->transcoded = (unsigned char*)nbuf;
+            doc->transcoded_len = nblen;
+        } else {
+            /* eager: the dom copied every scalar during the run (the
+             * borrowed views offset against input_base = transcoded);
+             * nbuf has no post-run reader — the slot keeps transcoded */
+            yep_free(sys, nbuf);
+        }
+    }
     doc->input = buf;
     doc->finish_pool = finish; /* NULL on the eager route */
     doc->lazy_tape = NULL;
@@ -650,6 +689,9 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
             ytap_free(&yt);
             yep_pool_destroy(finish);
             yep_free(sys, transcoded);
+            if (nbuf != NULL) {
+                yep_free(sys, nbuf); /* not parked: no document survives */
+            }
             yep_free(sys, doc);
             st = YEPTRIS_ERROR_MEMORY;
             goto fail;

data/vendor/libyeptris/src/yeptris/resolve/compat11.c

@@ -65,11 +65,8 @@ static yep_tag_id compat11(void* ctx, const char* p, uint32_t n) {
     if (n == 0 || eq(p, n, "~") || ci_eq3(p, n, "null")) {
         return 4; /* null: psych nil for ""/"~"/null (any case) */
     }
-    if (ci_eq3(p, n, "yes") || ci_eq3(p, n, "true") || ci_eq3(p, n, "on") || ci_eq3(p, n, "y")) {
-        return 3;
-    }
-    if (ci_eq3(p, n, "no") || ci_eq3(p, n, "false") || ci_eq3(p, n, "off") || ci_eq3(p, n, "n")) {
-        return 3;
+    if (yep_tag_bool_value(p, n) >= 0) {
+        return 3; /* the one bool table (tags.c): true/false sets ci */
     }
     if (eq(p, n, "=")) {
         return 10; /* value */

data/vendor/libyeptris/src/yeptris/resolve/resolver.h

@@ -82,4 +82,22 @@ yep_tag_id yep_tag_from_uri(const char* p, uint32_t len);
  * portably). */
 const char* yep_tag_float_word(const char* p, uint32_t len);
 
+/* The BOOL truth table for a resolved-bool view: 1 true, 0 false,
+ * -1 not a bool word. One table, two consumers: compat11's classify
+ * and the canonical/JSON emitter's BOOL arm — the DOM stores only the
+ * tag + source text, so the emitter re-asks the table (#937: guessing
+ * the value from the text's length spelled every non-4-char true-word
+ * false). The ci union of the families' sets (core's true/false forms
+ * are in the compat superset), so no family fact is needed. */
+int yep_tag_bool_value(const char* p, uint32_t len);
+
+/* Decode a resolved-INT view to its value through the family's own
+ * accepted forms: radix prefixes 0x/0o in both (0b and the leading-0
+ * octal + _/,/sexagesimal forms only when compat — core spells
+ * leading-0 decimal), digits otherwise. Overflow beyond the int64
+ * range returns nonzero and *out is untouched. The canonical/JSON
+ * emitter's INT arm (#937: source text like 0x1F is not a JSON
+ * token). */
+int yep_tag_int64(const char* p, uint32_t len, int compat, int64_t* out);
+
 #endif /* YEP_RESOLVER_H */

data/vendor/libyeptris/src/yeptris/resolve/tags.c

@@ -56,3 +56,195 @@ const char* yep_tag_float_word(const char* p, uint32_t len) {
     }
     return NULL;
 }
+
+static int ci_eq(const char* p, uint32_t n, const char* s) {
+    uint32_t m = 0;
+    while (s[m] != '\0') {
+        m++;
+    }
+    if (n != m) {
+        return 0;
+    }
+    for (uint32_t k = 0; k < n; k++) {
+        char a = p[k], b = s[k];
+        if (a >= 'A' && a <= 'Z') {
+            a = (char)(a - 'A' + 'a');
+        }
+        if (b >= 'A' && b <= 'Z') {
+            b = (char)(b - 'A' + 'a');
+        }
+        if (a != b) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+int yep_tag_bool_value(const char* p, uint32_t len) {
+    static const char* const words[8] = {"y", "yes", "true", "on", "n", "no", "false", "off"};
+    for (unsigned i = 0; i < 8; i++) {
+        if (ci_eq(p, len, words[i])) {
+            return i < 4 ? 1 : 0;
+        }
+    }
+    return -1;
+}
+
+/* One base-denominated digit with overflow detection (uint64 keeps
+ * the INT64_MIN magnitude representable). */
+static int acc_digit(uint64_t* acc, int base, int dv) {
+    uint64_t na = *acc * (uint64_t)base;
+    if (na / (uint64_t)base != *acc) {
+        return 1;
+    }
+    na += (uint64_t)dv;
+    if (na < *acc) {
+        return 1;
+    }
+    *acc = na;
+    return 0;
+}
+
+int yep_tag_int64(const char* p, uint32_t n, int compat, int64_t* out) {
+    uint32_t i = 0;
+    int neg = 0;
+    if (n == 0) {
+        return 1;
+    }
+    if (p[0] == '-' || p[0] == '+') {
+        neg = p[0] == '-';
+        i = 1;
+        if (i >= n) {
+            return 1;
+        }
+    }
+    /* radix prefixes first (both families, lowercase only — "0X1A"
+     * rides a string in core AND compat; 0o is core's spelling, 0b
+     * compat's), then compat's leading-0 octal, then the plain
+     * decimal/sexagesimal walk */
+    uint64_t acc = 0;
+    int digits = 0;
+    int base = 10;
+    uint32_t d = i;
+    if (n - i > 2 && p[i] == '0' && p[i + 1] == 'x') {
+        base = 16;
+        d = i + 2;
+        if (compat && p[d] == '_') {
+            d++;
+            if (p[d] == '_') {
+                return 1;
+            }
+        }
+    } else if (n - i > 2 && p[i] == '0' && p[i + 1] == 'o') {
+        if (compat) {
+            return 1; /* 0o is not a compat form (psych) */
+        }
+        base = 8;
+        d = i + 2;
+    } else if (compat && n - i > 2 && p[i] == '0' && p[i + 1] == 'b') {
+        base = 2;
+        d = i + 2;
+        if (p[d] == '_') {
+            d++;
+            if (p[d] == '_') {
+                return 1;
+            }
+        }
+    } else if (compat && p[i] == '0' && n - i >= 2) {
+        /* leading-0 octal (psych): 0[_]*[0-7][0-7_]* — the radix
+         * prefixes above never reach this arm */
+        base = 8;
+        d = i + 1;
+        while (d < n && p[d] == '_') {
+            d++;
+        }
+        if (d >= n) {
+            *out = 0; /* plain "0" / "000" */
+            return 0;
+        }
+    } else if (compat && p[i] == '0' && n - i == 1) {
+        *out = 0;
+        return 0;
+    } else if (compat && p[i] >= '0' && p[i] <= '9') {
+        /* sexagesimal int (compat only): d[d_,]*(:[0-5]?d){1,2} — the
+         * fractional form is float-tagged and never reaches here, but
+         * a '.' still refuses (the decode must not guess). '_' and ','
+         * are the compat separators (psych legacy). */
+        uint32_t k = i;
+        while (k < n && ((p[k] >= '0' && p[k] <= '9') || p[k] == '_' || p[k] == ',')) {
+            if (p[k] != '_' && p[k] != ',') {
+                if (acc_digit(&acc, 10, p[k] - '0')) {
+                    return 1;
+                }
+                digits = 1;
+            }
+            k++;
+        }
+        if (k < n && p[k] == ':') {
+            while (k < n && p[k] == ':') {
+                k++;
+                int gd = 0;
+                int g = 0;
+                while (k < n && p[k] >= '0' && p[k] <= '9' && gd < 2) {
+                    g = g * 10 + (p[k] - '0');
+                    gd++;
+                    k++;
+                }
+                if (gd < 1 || g > 59) {
+                    return 1;
+                }
+                if (acc_digit(&acc, 60, g)) {
+                    return 1;
+                }
+            }
+            if (k == n) {
+                *out = neg ? -(int64_t)acc : (int64_t)acc;
+                return 0;
+            }
+            return 1;
+        }
+        /* a ':'-less digit span: the plain decimal path below would
+         * re-read it — answer directly */
+        if (k == n && digits) {
+            *out = neg ? -(int64_t)acc : (int64_t)acc;
+            return 0;
+        }
+        return 1;
+    }
+    acc = 0;
+    digits = 0;
+    for (uint32_t k = d; k < n; k++) {
+        char c = p[k];
+        int dv;
+        if (c >= '0' && c <= '9') {
+            dv = c - '0';
+        } else if (base == 16 && c >= 'a' && c <= 'f') {
+            dv = c - 'a' + 10;
+        } else if (base == 16 && c >= 'A' && c <= 'F') {
+            dv = c - 'A' + 10;
+        } else if (compat && (c == '_' || c == ',')) {
+            continue;
+        } else {
+            return 1;
+        }
+        if (base != 16 && dv >= base) {
+            return 1;
+        }
+        if (acc_digit(&acc, base, dv)) {
+            return 1;
+        }
+        digits = 1;
+    }
+    if (!digits) {
+        return 1;
+    }
+    if (neg && acc == (uint64_t)INT64_MAX + 1u) {
+        *out = INT64_MIN;
+        return 0;
+    }
+    if (acc > (uint64_t)INT64_MAX) {
+        return 1;
+    }
+    *out = neg ? -(int64_t)acc : (int64_t)acc;
+    return 0;
+}

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

@@ -689,18 +689,33 @@ yep_span yep_scan_plain(const char* p, size_t len, size_t pos, int flow) {
         size_t at = (hit < 0) ? len : i + (size_t)hit;
         /* a multibyte break inside the piece ends it like an EOL: the
          * byte stopset cannot see NEL/LS/PS, and the continuation
-         * would ride across the break into the next line's tokens */
-        if (at > i) {
-            const char* lead = (const char*)memchr(p + i, 0xC2, at - i);
-            const char* lead2 = (const char*)memchr(p + i, 0xE2, at - i);
+         * would ride across the break into the next line's tokens.
+         * EVERY lead byte in the piece must be tested: the first lead
+         * can be an ordinary multibyte character (the r169 yen U+00A5
+         * leading a NEL run) while a later one is a break — testing
+         * the first lead only declined the check there and rode the
+         * break raw into the scalar (the false-lead ride, the r74
+         * plain-ends-at-NEL law defeated by the lead's own position). */
+        int mb_broken = 0;
+        for (size_t scan = i; at > scan;) {
+            const char* lead = (const char*)memchr(p + scan, 0xC2, at - scan);
+            const char* lead2 = (const char*)memchr(p + scan, 0xE2, at - scan);
             const char* first =
                 (lead && lead2) ? (lead < lead2 ? lead : lead2) : (lead ? lead : lead2);
-            if (first != NULL && yep_scan_mb_break_len(p, len, (size_t)(first - p)) > 0) {
+            if (first == NULL) {
+                break;
+            }
+            if (yep_scan_mb_break_len(p, len, (size_t)(first - p)) > 0) {
                 at = (size_t)(first - p);
-                i = at;
-                s.term = YEP_TERM_EOL;
+                mb_broken = 1;
                 break;
             }
+            scan = (size_t)(first - p) + 1; /* a false lead: advance past it */
+        }
+        if (mb_broken) {
+            i = at;
+            s.term = YEP_TERM_EOL;
+            break;
         }
         unsigned char c = (at < len) ? (unsigned char)p[at] : 0;
 

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

@@ -1278,13 +1278,32 @@ ldone:
      * Y79Y#4 error: defer to the engine, whose e_flow_ws owns the law
      * -- the walk's whitespace loops treat the tab as separation, which
      * accepted exactly the span the marshal drain's engine rejected,
-     * splitting parseable from marshalable (the nightly's round 120) */
-    for (size_t k = open + 1; k < len; k++) {
-        if (p[k] == '\n' && k + 1 < len && p[k + 1] == '\t') {
-            yeptris_tape_free(t);
-            return YEPTRIS_ERROR_PARSE;
+     * splitting parseable from marshalable (the nightly's round 120).
+     * clean_only skips the scan: its byte guarantees already rejected
+     * every tab in the span (LWS stops on one, the string c0 sweeps
+     * and the tail reject it), so the pair cannot exist there. The
+     * lenient lane rides memchr — a '\n'-hit vector pass instead of a
+     * two-compare byte loop over the whole span (13% of json-doc). */
+    if (!cl) {
+        size_t k = open + 1;
+        while (k < len) {
+            const char* nl = (const char*)memchr(p + k, '\n', len - k);
+            if (nl == NULL) {
+                break;
+            }
+            k = (size_t)(nl - p) + 1;
+            if (k < len && p[k] == '\t') {
+                yeptris_tape_free(t);
+                return YEPTRIS_ERROR_PARSE;
+            }
         }
     }
+    /* the >1024 simple-key verdict settles HERE when no key crossed the
+     * raw cap in lmapcolon: chars <= bytes closes the char budget too,
+     * so no key can violate the law — without this, every clean
+     * document paid yep_tape_long_simple_key's full-tape re-walk (16%
+     * of json-doc parse, the #739 residual) */
+    t->_long_key_known = 1;
     t->count = count;
     t->_src = p;
     t->_srclen = len;

metadata

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