yeptris 0.6.56.1-arm-linux-eabihf → 0.6.58.1-arm-linux-eabihf

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

@@ -4798,8 +4798,40 @@ typedef struct yep_stepstate {
                          * state the whole-stream walk holds at the ---
                          * cut, so per-document normalization is
                          * byte-identical to the one-buffer walk */
+    int gated;          /* the encoding front-end ran: BOM decisions
+                         * belong to the stream's first bytes, never to
+                         * a mid-stream chunk (a later U+FEFF is
+                         * content). While 0 the head may still be a
+                         * BOM prefix, and scanned is 0 by the same
+                         * law -- every hold returns before step_scan. */
 } yep_stepstate;
 
+/* True when buf[0..len) could still be the PREFIX of a BOM (the rest
+ * arrives with the next chunk): the sniff needs its full width, so a
+ * 1-3-byte head holds the gate instead of reading a mark's bytes as
+ * content. A buffer long enough for the sniff to decide never gets
+ * here. */
+static int step_bom_prefix(const char* buf, size_t len) {
+    const unsigned char* p = (const unsigned char*)buf;
+    switch (p[0]) {
+    case 0xEF:
+        return len == 1 || (len == 2 && p[1] == 0xBB);
+    case 0xFF:
+    case 0xFE:
+        return len == 1;
+    case 0x00:
+        if (len == 1) {
+            return 1;
+        }
+        if (p[1] != 0x00) {
+            return 0;
+        }
+        return len == 2 || p[2] == 0xFE;
+    default:
+        return 0;
+    }
+}
+
 static int engine_run_impl(yep_engine* e, const char* buf, size_t len, const yep_sink* sink,
                            int emit_start, int emit_end);
 
@@ -5344,6 +5376,33 @@ int yep_engine_step(yep_engine* e, const char* chunk, size_t len, int final, con
         memcpy(st->buf + st->len, chunk, len);
         st->len += len;
     }
+    /* the encoding front-end the one-shot owns (yep_engine_run): the
+     * stepping route (and the recorder riding it) had NONE, so UTF-16
+     * bytes fed through it parsed garbage silently. The gate runs
+     * once, on the stream's first bytes: the UTF-8 BOM strips (a lone
+     * one is an empty stream, not a U+FEFF scalar -- the one-shot's
+     * round-122 law), a UTF-16/32 BOM rejects (chunk-wise transcoding
+     * cannot carry state across feeds: a surrogate pair split by the
+     * chunk boundary has nowhere to live), and an undecided prefix
+     * holds until enough bytes decide it. */
+    if (!st->gated && st->len > 0) {
+        yep_encoding enc = YEP_ENC_UNKNOWN;
+        size_t bom = yep_bom_sniff((const unsigned char*)st->buf, st->len, &enc);
+        if (enc == YEP_ENC_UTF8) {
+            memmove(st->buf, st->buf + bom, st->len - bom);
+            st->len -= bom;
+            st->gated = 1;
+        } else if (enc == YEP_ENC_UTF16LE || enc == YEP_ENC_UTF16BE || enc == YEP_ENC_UTF32LE ||
+                   enc == YEP_ENC_UTF32BE) {
+            yep_error_set(&e->err, YEP_ERR_ENCODING, 1, 1, bom,
+                          "the chunked route cannot decode UTF-16/32 input");
+            return -1;
+        } else if (st->len >= 4 || !step_bom_prefix(st->buf, st->len)) {
+            st->gated = 1;
+        } else if (!final) {
+            return 0; /* the head may still complete a BOM: hold */
+        }
+    }
     if (!final) {
         size_t cut = step_scan(st);
         if (cut == 0 || cut >= st->len) {

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

@@ -325,9 +325,13 @@ static YeptrisDocument parse_impl(const char* buf, size_t len, const YeptrisPars
 engine_enter:
     eng = yep_engine_create(sys);
     if (opts != NULL) {
+        /* the typing SSOT: the family's resolver (compat11 when asked,
+         * json12 for the 12_JSON validation family, core12 otherwise) */
         yep_engine_set_resolver(eng, opts->schema == YEPTRIS_SCHEMA_11_COMPAT
                                          ? yep_resolver_compat11()
-                                         : yep_resolver_core12());
+                                         : (opts->schema == YEPTRIS_SCHEMA_12_JSON
+                                                ? yep_resolver_json12()
+                                                : yep_resolver_core12()));
         if (opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
             /* the compat schema is the psych/libyaml surface: its grammar
              * must accept what libyaml accepts (the flow floor is suite-
@@ -357,9 +361,13 @@ engine_enter:
         }
         /* the direct builders resolve with the engine's schema (the typing
          * SSOT — one resolver decision per scalar, whichever path builds) */
-        dom->resolver = (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
-                            ? yep_resolver_compat11()
-                            : yep_resolver_core12();
+        if (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT) {
+            dom->resolver = yep_resolver_compat11();
+        } else if (opts != NULL && opts->schema == YEPTRIS_SCHEMA_12_JSON) {
+            dom->resolver = yep_resolver_json12();
+        } else {
+            dom->resolver = yep_resolver_core12();
+        }
         /* BEFORE the run: input-slice strings borrow as views (zero copy)
          * — the document keeps `transcoded` alive for exactly this. Set
          * after, every scalar was arena-copied (found 2026-09-10). */
@@ -422,6 +430,8 @@ engine_enter:
     } else if (have_tape && !norm_kept_raw &&
                ytap_fused_run(&yt, (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
                                        ? yep_resolver_compat11()
+                                   : (opts != NULL && opts->schema == YEPTRIS_SCHEMA_12_JSON)
+                                       ? yep_resolver_json12()
                                        : yep_resolver_core12()) == 0) {
         /* the fused block runner owned the whole document — the engine
          * never runs (TODO.restructure/79). Its only cost was the parse
@@ -437,7 +447,12 @@ engine_enter:
     }
     if (rc != 0) {
         const yep_error* ee = yep_engine_error(eng);
-        yep_err_code code = ee ? ee->code : YEP_ERR_UNEXPECTED;
+        /* a CLEAN channel under a failed run means the SINK failed — a
+         * builder ran out of memory (the DOM's oom law), the bytes
+         * never were a parse error. Mapping it to PARSE let
+         * yep_dom_str_put's swallowed OOM surface as a syntax error
+         * (the audit's finding: silent doc corruption reads worse). */
+        yep_err_code code = (ee && ee->code != YEP_ERR_NONE) ? ee->code : YEP_ERR_MEMORY;
         if (ee) {
             yep_error* tls = yep_error_tls();
             *tls = *ee;
@@ -491,9 +506,8 @@ engine_enter:
     }
     yep_mutex_init(&doc->lazy_mu);
     doc->sys = sys;
-    doc->schema = (opts != NULL && opts->schema == YEPTRIS_SCHEMA_11_COMPAT)
-                      ? YEPTRIS_SCHEMA_11_COMPAT
-                      : YEPTRIS_SCHEMA_12_CORE;
+    doc->schema = (opts != NULL && opts->schema != YEPTRIS_SCHEMA_12_CORE) ? opts->schema
+                                                                           : YEPTRIS_SCHEMA_12_CORE;
     doc->transcoded = transcoded;
     doc->transcoded_len = transcoded_len;
     doc->input = buf;

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

@@ -0,0 +1,103 @@
+/* json12.c — the spec 10.2 JSON schema resolver (#882).
+ *
+ * The productions are the spec 10.2.2 table (1.2.2 erratum kept: the
+ * float regex needs NO digits after the dot — "0." is a float):
+ *   null:  null
+ *   bool:  true | false
+ *   int:   -? ( 0 | [1-9] [0-9]* )
+ *   float: -? ( 0 | [1-9] [0-9]* ) ( \. [0-9]* )? ( [eE] [-+]? [0-9]+ )?
+ *   *  -> Error (the validator's business; the resolver stays str)
+ *
+ * Deliberately NOT accepted (the core schema's extensions): "True"/
+ * "False"/"NULL" casings, "~"/empty nulls, +signs, 0o/0x radix, .inf/
+ * .nan, underscores. The example-10.8 Invalid list pins each one.
+ *
+ * Shape: yep_json12_plain is the ONE classifier — the resolver wraps
+ * it, and the validator re-asks it per plain scalar (no second truth
+ * table anywhere). Parse never errors here: a scalar outside the
+ * productions resolves str so the DOM stays family-neutral; the
+ * validation face turns the spec's Error row into diagnostics.
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "resolver.h"
+
+/* JSON int: -?(0|[1-9][0-9]*); optionally continues as the float
+ * production (the int regex is a prefix of the float one). Returns 1
+ * (int), 2 (float), 0 (no production). */
+int yep_json12_plain(const char* p, uint32_t n) {
+    if (n == 0) {
+        return 0;
+    }
+    if (n == 4 && memcmp(p, "null", 4) == 0) {
+        return 4; /* null */
+    }
+    if (n == 4 && memcmp(p, "true", 4) == 0) {
+        return 3; /* bool */
+    }
+    if (n == 5 && memcmp(p, "false", 5) == 0) {
+        return 3;
+    }
+    uint32_t i = (p[0] == '-') ? 1 : 0;
+    if (i >= n) {
+        return 0; /* lone "-" (or empty after the prefix check) */
+    }
+    /* int part: 0 | [1-9][0-9]* — no +sign, no leading zeros */
+    if (p[i] == '0') {
+        i++;
+    } else if (p[i] >= '1' && p[i] <= '9') {
+        i++;
+        while (i < n && p[i] >= '0' && p[i] <= '9') {
+            i++;
+        }
+    } else {
+        return 0;
+    }
+    if (i == n) {
+        return 1; /* bare int */
+    }
+    /* float tail: (\.[0-9]*)? ([eE][-+]?[0-9]+)? — at least one of the
+     * two must be present (a bare int already returned) */
+    int floaty = 0;
+    if (p[i] == '.') {
+        floaty = 1;
+        i++;
+        while (i < n && p[i] >= '0' && p[i] <= '9') {
+            i++; /* digits optional after the dot (1.2.2 erratum) */
+        }
+    }
+    if (i < n && (p[i] == 'e' || p[i] == 'E')) {
+        i++;
+        if (i < n && (p[i] == '+' || p[i] == '-')) {
+            i++;
+        }
+        int ed = 0;
+        while (i < n && p[i] >= '0' && p[i] <= '9') {
+            i++;
+            ed = 1;
+        }
+        if (!ed) {
+            return 0; /* exponent sign(s) with no digits */
+        }
+        floaty = 1;
+    }
+    return (floaty && i == n) ? 2 : 0;
+}
+
+static yep_tag_id json12(void* ctx, const char* p, uint32_t n) {
+    (void)ctx;
+    return (yep_tag_id)yep_json12_plain(p, n);
+}
+
+static yep_tag_id json12_number(void* ctx, int is_float) {
+    (void)ctx;
+    return is_float ? 2 : 1;
+}
+
+static const yep_resolver k_json12 = {json12, json12_number, NULL};
+
+const yep_resolver* yep_resolver_json12(void) {
+    return &k_json12;
+}

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

@@ -40,6 +40,15 @@ static inline yep_tag_id yep_resolve_number(const yep_resolver* r, int is_float)
 const yep_resolver* yep_resolver_core12(void);
 const yep_resolver* yep_resolver_compat11(void);
 
+/* The spec 10.2 JSON schema resolver (#882): null/true/false exact,
+ * the JSON int and float productions, everything else str. Parse stays
+ * lenient — the VALIDATOR flags plain scalars that matched no
+ * production (the spec's `*` -> Error row) through the classifier. */
+const yep_resolver* yep_resolver_json12(void);
+/* 1 when the plain span matches a JSON-schema production. The one
+ * truth table for the 12_JSON family (validate/ re-asks it). */
+int yep_json12_plain(const char* p, uint32_t n);
+
 /* core tag id <-> canonical URI (tags.c is the identity SSOT). */
 const char* yep_tag_uri(yep_tag_id id);
 

data/vendor/libyeptris/src/yeptris/validate/internal.h

@@ -0,0 +1,102 @@
+/* validate/internal.h — the validation face's shared internals (#882).
+ *
+ * Private to src/yeptris/validate/: the report shape, the diagnostic
+ * emitter (path capture + line/col resolution), and the JSON-pointer
+ * scratch path. The two walks (validate.c's schema family and
+ * jsonschema.c's keyword subset) share only this — MECE keeps the
+ * checks themselves in their own TUs.
+ */
+#ifndef YEP_VALIDATE_INTERNAL_H
+#define YEP_VALIDATE_INTERNAL_H
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/validate.h>
+
+#include "../dom/dom.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The report cap: a hostile document can carry O(nodes) violations, so
+ * the walk stops here and the LIMIT sentinel replaces the last slot. */
+#define YEP_VALIDATE_MAX_DIAGS 256
+
+struct yeptris_validate_report {
+    yeptris_diagnostic* diags;
+    uint32_t count;
+    int truncated;
+};
+
+typedef struct yep_vctx {
+    const yep_dom* dom;
+    yeptris_validate_report* rep;
+    /* line/col resolution over the node bytes (lazy: built on the
+     * first positioned diagnostic; valid documents never pay) */
+    const char* input;
+    size_t input_len;
+    uint32_t* line_off; /* byte offset of every line start */
+    uint32_t line_cnt, line_cap;
+    /* JSON-pointer path under construction (DFS scratch) */
+    char* path;
+    size_t path_len, path_cap;
+    int depth; /* the walk's nesting guard (never exceeds the DOM's) */
+    int oom;   /* an allocation failed: stop diagnosing */
+    /* JSON Schema trial suppression (anyOf/oneOf/not probes) */
+    int suppress;
+    int trial_hit;
+    int ref_depth; /* consecutive $ref expansions */
+} yep_vctx;
+
+/* Offset of a node's first positioned byte (the value span of the node
+ * itself, or of its first scalar leaf for collections; UINT32_MAX when
+ * everything reachable lives in the arena — line/col unknown). */
+uint32_t yep_validate_node_off(const yep_dom* d, uint32_t id);
+
+/* Emits one diagnostic at the current path. line/col resolve from
+ * `off` through the lazy line index; 0/0 when unknown. Detail is
+ * printf-composed into the bounded slot. Never fails the caller: the
+ * report cap turns the last slot into the LIMIT sentinel. */
+void yep_validate_emit(yep_vctx* c, int code, uint32_t off, const char* detail_fmt, ...);
+
+/* JSON-pointer path scratch: push an escaped segment / a decimal
+ * index, pop to a mark. 0 ok, -1 OOM (ctx.oom set; the walk unwinds). */
+int yep_validate_path_push(yep_vctx* c, const char* seg, size_t seg_len);
+int yep_validate_path_push_index(yep_vctx* c, uint32_t idx);
+void yep_validate_path_pop(yep_vctx* c, size_t mark);
+
+/* The bounded ECMA-regex subset behind `pattern` (jsonschema.c):
+ * literals, '.', classes, groups, alternation, the greedy/lazy
+ * quantifiers, anchors, \d\w\s\D\W\S\b\B and \xHH. Byte-oriented
+ * (ASCII classes; UTF-8 literals match byte-wise). A Thompson NFA —
+ * O(len * m), no backtracking blowup; patterns over the program
+ * budget are invalid. 1 match, 0 no match, -1 invalid pattern. */
+int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_len);
+
+/* Canonical scalar tag of a DOM node (explicit tag, then the parse
+ * resolver's plain verdict, then str): the value model both walks
+ * compare under. */
+uint8_t yep_validate_scalar_tag(const yep_dnode* n);
+
+/* Canonical-form hash and equality over DOM subtrees (spec 3.2.1.3:
+ * same tag + canonical form; numbers numerically within a tag). The
+ * equality may cross documents — the schema's enum/const live in a
+ * different DOM than the instance. Depth-bounded. */
+uint64_t yep_validate_node_hash(const yep_dom* d, uint32_t id, int depth);
+int yep_validate_node_equal(const yep_dom* da, uint32_t a, const yep_dom* db, uint32_t b,
+                            int depth);
+
+/* jsonschema.c's driver: applies the schema tree (its own DOM) to
+ * every instance document root, emitting into `rep`. Returns 0, -1
+ * on OOM. */
+int yep_jsonschema_run(const yep_dom* schema_dom, uint32_t schema_root, const yep_dom* instance_dom,
+                       const uint32_t* doc_roots, uint32_t doc_count, yeptris_validate_report* rep);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_VALIDATE_INTERNAL_H */