yeptris 0.6.58.1-arm-linux-eabihf → 0.6.59.1-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/validate/regexp.c

@@ -1,14 +1,16 @@
 /* regexp.c — the bounded ECMA-regex subset behind JSON Schema's
- * `pattern` keyword (#882 slice 2).
+ * `pattern` keyword (#882 slice 2; #885 item 2).
  *
  * Supported: literals, '.', [...] classes (ranges, negation, \d\w\s
  * and their negations, \n\t\r\f\v\0, \xHH), groups (capturing ignored,
  * (?:...) fine), alternation, the quantifiers * + ? {n} {n,} {n,m}
  * (lazy markers parse and are ignored — match/no-match has no
  * preference), the ^ $ \b \B assertions. Unsupported constructs
- * (backreferences, lookaround, unknown letter escapes) are
- * SyntaxErrors: the caller treats an invalid pattern as an absent
- * keyword (2020-12's ignore posture), never a guess.
+ * (backreferences, lookaround) are SyntaxErrors, and unknown LETTER
+ * escapes are identity escapes (non-unicode ECMA-262 Annex B: \p
+ * without the u flag is the literal 'p'): the caller treats an invalid
+ * pattern as an absent keyword (2020-12's ignore posture), never a
+ * guess.
  *
  * Shape: byte-oriented — classes are ASCII, UTF-8 literals match
  * byte-wise (ASCII patterns, the JSON Schema norm, are exact).
@@ -17,6 +19,14 @@
  * Every array is a fixed stack budget; overflow is a SyntaxError (-1),
  * never a crash. Truth lives here once (MECE: a second consumer moves
  * this to its own module).
+ *
+ * Two consumption shapes over one compiler (#885 item 3):
+ * `yep_re_search` compiles into a stack ctx and drops it (the one-shot
+ * walk, zero allocation); the retained-program cache
+ * (`yep_re_cache_*`) compiles a schema's patterns ONCE into exact-size
+ * heap programs and runs them per validated string — the XSD
+ * content-model economy. A cache miss recompiles (identical verdicts);
+ * the cache itself is immutable once populated.
  */
 
 #include <string.h>
@@ -223,9 +233,13 @@ static int p_escape(re_ctx* c, int* out) {
         return 0;
     }
     default:
-        /* letters/digits outside the set (incl. backrefs): SyntaxError;
-         * punctuation: identity escape */
-        if ((e >= 'a' && e <= 'z') || (e >= 'A' && e <= 'Z') || (e >= '0' && e <= '9')) {
+        /* non-unicode ECMA-262 (Annex B): unknown LETTER escapes are
+         * identity escapes — \p outside unicode mode is the literal
+         * 'p' (property escapes need the u flag this kernel does not
+         * carry). Digits stay SyntaxError: 1-9 are backreferences,
+         * out of the subset — an ignored pattern beats a misread one.
+         * Punctuation is identity too. */
+        if (e >= '0' && e <= '9') {
             c->err = 1;
             return -1;
         }
@@ -808,33 +822,43 @@ static int c_node(re_ctx* c, int id, re_frag* out, int depth) {
     }
 }
 
-/* ---- the public search: Pike VM over the subject ----------------------- */
-
-int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_len) {
-    if (pat == NULL || pat_len == 0 || pat_len > RE_MAX_PAT) {
-        return -1;
-    }
-    re_ctx c;
-    memset(&c, 0, sizeof(c));
-    c.pat = pat;
-    c.pn = pat_len;
+/* ---- compile: pattern -> program --------------------------------------- */
 
-    int root = p_alt(&c, 0);
-    if (root < 0 || c.pi != c.pn) {
+/* parse + compile into the caller's ctx: MATCH emits last, every
+ * pending arrow resolves. 0 ok (the fragment entry pc in *entry_out),
+ * -1 SyntaxError (or a budget trip — the caller treats both as
+ * "pattern outside the subset", never a guess). */
+static int re_build(re_ctx* c, const char* pat, uint32_t pat_len, int* entry_out) {
+    memset(c, 0, sizeof(*c));
+    c->pat = pat;
+    c->pn = pat_len;
+    int root = p_alt(c, 0);
+    if (root < 0 || c->pi != c->pn) {
         return -1; /* trailing garbage is a SyntaxError */
     }
     re_frag f;
-    if (c_node(&c, root, &f, 0) < 0) {
+    if (c_node(c, root, &f, 0) < 0) {
         return -1;
     }
-    if (emit_inst(&c, RE_OP_MATCH, 0, 0, 0) < 0) {
+    if (emit_inst(c, RE_OP_MATCH, 0, 0, 0) < 0) {
         return -1;
     }
-    frag_connect(&f, c.inst, c.inst_n - 1); /* MATCH emits last */
-    if (c.err) {
+    frag_connect(&f, c->inst, c->inst_n - 1); /* MATCH emits last */
+    if (c->err) {
         return -1;
     }
+    *entry_out = f.in;
+    return 0;
+}
+
+/* ---- the Pike VM (shared by the one-shot and the retained programs) ----- */
 
+/* Runs one compiled program over the subject: 1 match, 0 no match.
+ * `entry` is the fragment entry pc (MATCH is emitted last, so the graph
+ * is self-contained). Never fails: a program exists only when its
+ * pattern compiled. */
+static int re_vm(const re_inst* inst, const uint8_t (*cls)[32], int entry, const char* s,
+                 uint32_t s_len) {
     uint8_t mark[RE_MAX_INST];
     uint16_t cur[RE_MAX_INST], nxt[RE_MAX_INST];
     /* closure depth: the seeds (m+1: live threads + the unanchored
@@ -845,7 +869,7 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
     uint32_t gen = 1;
     memset(mark, 0, sizeof(mark));
 
-    if (f.in < 0) {
+    if (entry < 0) {
         return 1; /* an empty pattern matches everywhere */
     }
     /* initial closure at subject offset 0 (from the fragment entry;
@@ -853,19 +877,19 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
     int cur_n = 0;
     {
         int st_n = 0;
-        stack[st_n++] = (uint16_t)f.in;
+        stack[st_n++] = (uint16_t)entry;
         while (st_n > 0) {
             uint16_t pc = stack[--st_n];
             if (mark[pc] == (uint8_t)gen) {
                 continue;
             }
             mark[pc] = (uint8_t)gen;
-            uint8_t op = c.inst[pc].op;
+            uint8_t op = inst[pc].op;
             if (op == RE_OP_JMP) {
-                stack[st_n++] = c.inst[pc].x;
+                stack[st_n++] = inst[pc].x;
             } else if (op == RE_OP_SPLIT) {
-                stack[st_n++] = c.inst[pc].x;
-                stack[st_n++] = c.inst[pc].y;
+                stack[st_n++] = inst[pc].x;
+                stack[st_n++] = inst[pc].y;
             } else if (op == RE_OP_MATCH) {
                 return 1; /* the empty match at offset 0 */
             } else if (op == RE_OP_ASSERT) {
@@ -873,7 +897,7 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
                  * subject; a word boundary holds exactly when the
                  * subject starts inside a word (no previous char) */
                 int ok = 0;
-                switch (c.inst[pc].cls) {
+                switch (inst[pc].cls) {
                 case RE_AS_BOL:
                     ok = 1;
                     break;
@@ -882,12 +906,12 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
                     break;
                 default: {
                     int wn = s_len > 0 && re_word((unsigned char)s[0]);
-                    ok = c.inst[pc].cls == RE_AS_WBOUND ? (int)wn : !(int)wn;
+                    ok = inst[pc].cls == RE_AS_WBOUND ? (int)wn : !(int)wn;
                     break;
                 }
                 }
                 if (ok) {
-                    stack[st_n++] = c.inst[pc].x; /* the connected exit */
+                    stack[st_n++] = inst[pc].x; /* the connected exit */
                 }
             } else {
                 cur[cur_n++] = pc; /* CHAR/BYTE: a live thread */
@@ -904,17 +928,17 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
         int nxt_n = 0;
         for (int i = 0; i < cur_n; i++) {
             uint16_t pc = cur[i];
-            int hit = c.inst[pc].op == RE_OP_BYTE
-                          ? (c.inst[pc].cls == byte)
-                          : (c.cls[c.inst[pc].cls][(byte >> 3) & 31] & (1u << (byte & 7))) != 0;
+            int hit = inst[pc].op == RE_OP_BYTE
+                          ? (inst[pc].cls == byte)
+                          : (cls[inst[pc].cls][(byte >> 3) & 31] & (1u << (byte & 7))) != 0;
             if (hit) {
                 /* the exit is the CONNECTED target (frag_connect), not
                  * a fall-through: fragments link arbitrary pcs */
-                nxt[nxt_n++] = c.inst[pc].x;
+                nxt[nxt_n++] = inst[pc].x;
             }
         }
-        nxt[nxt_n++] = (uint16_t)f.in; /* unanchored: the search restarts
-                                        * at every offset */
+        nxt[nxt_n++] = (uint16_t)entry; /* unanchored: the search restarts
+                                         * at every offset */
         gen++;
         if ((gen & 0xFF) == 0) {
             memset(mark, 0, sizeof(mark));
@@ -931,17 +955,17 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
                 continue;
             }
             mark[pc] = (uint8_t)gen;
-            uint8_t op = c.inst[pc].op;
+            uint8_t op = inst[pc].op;
             if (op == RE_OP_JMP) {
-                stack[st_n++] = c.inst[pc].x;
+                stack[st_n++] = inst[pc].x;
             } else if (op == RE_OP_SPLIT) {
-                stack[st_n++] = c.inst[pc].x;
-                stack[st_n++] = c.inst[pc].y;
+                stack[st_n++] = inst[pc].x;
+                stack[st_n++] = inst[pc].y;
             } else if (op == RE_OP_MATCH) {
                 matched = 1;
             } else if (op == RE_OP_ASSERT) {
                 int ok = 0;
-                switch (c.inst[pc].cls) {
+                switch (inst[pc].cls) {
                 case RE_AS_BOL:
                     ok = (sp + 1) == 0;
                     break;
@@ -951,12 +975,12 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
                 default: {
                     int wp = re_word((unsigned char)s[sp]);
                     int wn = (sp + 1) < (uint32_t)s_len && re_word((unsigned char)s[sp + 1]);
-                    ok = c.inst[pc].cls == RE_AS_WBOUND ? (wp != wn) : (wp == wn);
+                    ok = inst[pc].cls == RE_AS_WBOUND ? (wp != wn) : (wp == wn);
                     break;
                 }
                 }
                 if (ok) {
-                    stack[st_n++] = c.inst[pc].x; /* the connected exit */
+                    stack[st_n++] = inst[pc].x; /* the connected exit */
                 }
             } else {
                 nxt[live_n++] = pc; /* a live thread for the next byte */
@@ -970,3 +994,141 @@ int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_l
     }
     return 0;
 }
+
+/* ---- the one-shot search (compile fresh, run, drop) --------------------- */
+
+int yep_re_search(const char* pat, uint32_t pat_len, const char* s, uint32_t s_len) {
+    if (pat == NULL || pat_len == 0 || pat_len > RE_MAX_PAT) {
+        return -1;
+    }
+    re_ctx c;
+    int entry = -1;
+    if (re_build(&c, pat, pat_len, &entry) != 0) {
+        return -1;
+    }
+    return re_vm(c.inst, c.cls, entry, s, s_len);
+}
+
+/* ---- the retained programs (the compiled schema's pattern cache) -------- */
+
+/* A compiled program: exact-size copies of the instruction stream and
+ * the class table (the ctx's bounded budgets, retained past the
+ * compile call). */
+typedef struct {
+    re_inst* inst;
+    uint8_t (*cls)[32];
+    int inst_n, cls_n;
+    int entry;
+} re_prog;
+
+static void re_prog_free(re_prog* p) {
+    const yep_allocator* sys = yep_system_allocator();
+    yep_free(sys, p->inst);
+    yep_free(sys, p->cls);
+    p->inst = NULL;
+    p->cls = NULL;
+}
+
+/* Compiles into a heap program. 0 ok; -1 SyntaxError or allocation
+ * failure (nothing retained; both read as "the pattern is unusable",
+ * the kernel's ignore posture). */
+static int re_compile(const char* pat, uint32_t pat_len, re_prog* out) {
+    if (pat == NULL || pat_len == 0 || pat_len > RE_MAX_PAT) {
+        return -1;
+    }
+    re_ctx c;
+    int entry = -1;
+    if (re_build(&c, pat, pat_len, &entry) != 0) {
+        return -1;
+    }
+    const yep_allocator* sys = yep_system_allocator();
+    re_prog p;
+    memset(&p, 0, sizeof(p));
+    p.inst_n = c.inst_n;
+    p.cls_n = c.cls_n;
+    p.entry = entry;
+    p.inst = yep_alloc(sys, (size_t)c.inst_n * sizeof(re_inst));
+    p.cls = yep_alloc(sys, (size_t)(c.cls_n > 0 ? c.cls_n : 1) * 32);
+    if (p.inst == NULL || p.cls == NULL) {
+        re_prog_free(&p);
+        return -1;
+    }
+    memcpy(p.inst, c.inst, (size_t)c.inst_n * sizeof(re_inst));
+    memcpy(p.cls, c.cls, (size_t)c.cls_n * 32);
+    *out = p;
+    return 0;
+}
+
+/* The table: pattern source -> compiled program. Keys are the schema's
+ * own byte views (stable for the handle's lifetime); lookups compare
+ * content so equal patterns share one program. Bounded: over
+ * RE_CACHE_MAX entries a miss recompiles — the one-shot behavior. */
+#define RE_CACHE_MAX 256
+typedef struct {
+    const char* pat;
+    uint32_t plen;
+    re_prog prog;
+} re_cache_slot;
+
+struct yep_re_cache {
+    re_cache_slot slot[RE_CACHE_MAX];
+    int n;
+};
+
+yep_re_cache* yep_re_cache_new(void) {
+    yep_re_cache* t = yep_alloc(yep_system_allocator(), sizeof(yep_re_cache));
+    if (t != NULL) {
+        memset(t, 0, sizeof(*t)); /* the allocator does not zero: n starts empty */
+    }
+    return t;
+}
+
+void yep_re_cache_free(yep_re_cache* t) {
+    if (t == NULL) {
+        return;
+    }
+    for (int i = 0; i < t->n; i++) {
+        re_prog_free(&t->slot[i].prog);
+    }
+    yep_free(yep_system_allocator(), t);
+}
+
+int yep_re_cache_add(yep_re_cache* t, const char* pat, uint32_t plen) {
+    if (t == NULL || pat == NULL || plen == 0) {
+        return 0; /* nothing to retain */
+    }
+    for (int i = 0; i < t->n; i++) {
+        if (t->slot[i].plen == plen && memcmp(t->slot[i].pat, pat, plen) == 0) {
+            return 1; /* already retained (equal patterns share one program) */
+        }
+    }
+    if (t->n >= RE_CACHE_MAX) {
+        return 0; /* the table is full: misses recompile per use, as the
+                   * one-shot face always has */
+    }
+    re_prog p;
+    if (re_compile(pat, plen, &p) != 0) {
+        return 0; /* invalid pattern: not retained; every use reads -1,
+                   * exactly the uncached verdict */
+    }
+    t->slot[t->n].pat = pat;
+    t->slot[t->n].plen = plen;
+    t->slot[t->n].prog = p;
+    t->n++;
+    return 1;
+}
+
+int yep_re_cache_search(const yep_re_cache* t, const char* pat, uint32_t plen, const char* s,
+                        uint32_t s_len) {
+    if (t != NULL && pat != NULL) {
+        for (int i = 0; i < t->n; i++) {
+            if (t->slot[i].plen == plen && memcmp(t->slot[i].pat, pat, plen) == 0) {
+                return re_vm(t->slot[i].prog.inst, t->slot[i].prog.cls, t->slot[i].prog.entry, s,
+                             s_len);
+            }
+        }
+    }
+    /* a miss (or no cache: the one-shot face) compiles fresh — identical
+     * verdicts either way, and the handle stays untouched */
+    return yep_re_search(pat, plen, s, s_len);
+}

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

@@ -269,12 +269,16 @@ uint64_t yep_validate_node_hash(const yep_dom* d, uint32_t id, int depth) {
         return h;
     }
     if (n->kind == YEP_DOM_MAPPING) {
+        /* mappings are UNORDERED (spec 3.2.1.3 canonical form): the
+         * fold is commutative (XOR of per-pair mixes) so key order
+         * cannot change the fingerprint */
         uint64_t h = 0x5EED4A9ULL;
         uint32_t k = n->first_child;
         while (k != UINT32_MAX) {
             uint32_t v = yep_dom_node(d, k) ? yep_dom_node(d, k)->next_sibling : UINT32_MAX;
-            h = hash_mix(h, yep_validate_node_hash(d, k, depth + 1));
-            h = hash_mix(h, yep_validate_node_hash(d, v, depth + 1));
+            uint64_t pair = hash_mix(0x51D1, yep_validate_node_hash(d, k, depth + 1));
+            pair = hash_mix(pair, yep_validate_node_hash(d, v, depth + 1));
+            h ^= pair;
             k = v != UINT32_MAX && yep_dom_node(d, v) ? yep_dom_node(d, v)->next_sibling
                                                       : UINT32_MAX;
         }
@@ -285,21 +289,21 @@ uint64_t yep_validate_node_hash(const yep_dom* d, uint32_t id, int depth) {
     yep_view v = yep_dom_view(d, n->value);
     uint64_t h = 0x5CA1A + tag;
     if (tag == YEPTRIS_TAG_INT || tag == YEPTRIS_TAG_FLOAT) {
-        /* canonical: the numeric value (0o13 == 0xB == 11; 1 == 1.0
-         * rides the same number bucket only when the tags match) */
-        int64_t iv = 0;
+        /* canonical: the numeric VALUE, one bucket for both tags (1 and
+         * 1.0 are the same canonical number) — the double bits; exact
+         * for i64-representable magnitudes up to 2^53, and beyond that
+         * two distinct ints may collide (equality is the authority, a
+         * collision only costs a probe) */
         double dv = 0;
+        int64_t iv = 0;
         if (yep_num_i64(v.p, v.len, &iv) == 0) {
-            int is_neg = iv < 0;
-            uint64_t mag = is_neg ? (uint64_t)(-(iv + 1)) + 1 : (uint64_t)iv;
-            h = hash_mix(h, mag ^ (is_neg ? 0x8000000000000000ULL : 0));
-        } else if (yep_num_f64(v.p, v.len, &dv) == 0) {
-            uint64_t bits;
-            memcpy(&bits, &dv, sizeof(bits));
-            h = hash_mix(h, bits);
+            dv = (double)iv;
         } else {
-            h = hash_mix(h, v.len);
+            yep_num_f64(v.p, v.len, &dv);
         }
+        uint64_t bits;
+        memcpy(&bits, &dv, sizeof(bits));
+        h = hash_mix(h, bits);
         return h;
     }
     for (uint32_t i = 0; i < v.len; i++) {
@@ -380,24 +384,31 @@ int yep_validate_node_equal(const yep_dom* da, uint32_t a, const yep_dom* db, ui
         }
         return 1;
     }
-    /* scalars */
+    /* scalars: numbers (int or float, either tag) compare by numeric
+     * value (2020-12: 0 and 0.0 are one constant); everything else
+     * requires the same tag */
     uint8_t ta = yep_validate_scalar_tag(na), tb = yep_validate_scalar_tag(nb);
-    if (ta != tb) {
+    int numa = ta == YEPTRIS_TAG_INT || ta == YEPTRIS_TAG_FLOAT;
+    int numb = tb == YEPTRIS_TAG_INT || tb == YEPTRIS_TAG_FLOAT;
+    if (numa != numb) {
         return 0;
     }
     yep_view va = yep_dom_view(da, na->value);
     yep_view vb = yep_dom_view(db, nb->value);
-    if (ta == YEPTRIS_TAG_INT || ta == YEPTRIS_TAG_FLOAT) {
-        double fa, fb;
+    if (numa) {
         int64_t ia, ib;
         if (yep_num_i64(va.p, va.len, &ia) == 0 && yep_num_i64(vb.p, vb.len, &ib) == 0) {
             return ia == ib;
         }
+        double fa, fb;
         if (yep_num_f64(va.p, va.len, &fa) == 0 && yep_num_f64(vb.p, vb.len, &fb) == 0) {
             return fa == fb;
         }
         return 0;
     }
+    if (ta != tb) {
+        return 0;
+    }
     return va.len == vb.len && (va.len == 0 || memcmp(va.p, vb.p, va.len) == 0);
 }
 
@@ -739,21 +750,31 @@ YEPTRIS_API void yeptris_validate_report_free(yeptris_validate_report* report) {
     yep_free(sys, report);
 }
 
-/* The shared tail: walk every document of the DOM into a fresh report. */
-static YeptrisStatus validate_dom(yep_dom* dom, const yep_resolver* fam, int json_family,
-                                  yeptris_validate_report** out) {
+/* The report constructor (internal.h's seam — one home for the shape). */
+yeptris_validate_report* yep_validate_report_new(void) {
     const yep_allocator* sys = yep_system_allocator();
     yeptris_validate_report* r = yep_alloc(sys, sizeof(*r));
     if (r == NULL) {
-        return YEPTRIS_ERROR_MEMORY;
+        return NULL;
     }
     r->diags = yep_alloc(sys, YEP_VALIDATE_MAX_DIAGS * sizeof(yeptris_diagnostic));
     if (r->diags == NULL) {
         yep_free(sys, r);
-        return YEPTRIS_ERROR_MEMORY;
+        return NULL;
     }
     r->count = 0;
     r->truncated = 0;
+    return r;
+}
+
+/* The shared tail: walk every document of the DOM into a fresh report. */
+static YeptrisStatus validate_dom(yep_dom* dom, const yep_resolver* fam, int json_family,
+                                  yeptris_validate_report** out) {
+    const yep_allocator* sys = yep_system_allocator();
+    yeptris_validate_report* r = yep_validate_report_new();
+    if (r == NULL) {
+        return YEPTRIS_ERROR_MEMORY;
+    }
 
     yep_vctx c;
     memset(&c, 0, sizeof(c));
@@ -816,18 +837,10 @@ YEPTRIS_API YeptrisStatus yeptris_validate_document(YeptrisDocument doc, Yeptris
     }
     if (dom == NULL) {
         /* an empty stream (or NULL doc): valid, empty report */
-        const yep_allocator* sys = yep_system_allocator();
-        yeptris_validate_report* r = yep_alloc(sys, sizeof(*r));
+        yeptris_validate_report* r = yep_validate_report_new();
         if (r == NULL) {
             return YEPTRIS_ERROR_MEMORY;
         }
-        r->diags = yep_alloc(sys, YEP_VALIDATE_MAX_DIAGS * sizeof(yeptris_diagnostic));
-        if (r->diags == NULL) {
-            yep_free(sys, r);
-            return YEPTRIS_ERROR_MEMORY;
-        }
-        r->count = 0;
-        r->truncated = 0;
         *out = r;
         return YEPTRIS_OK;
     }
@@ -871,69 +884,17 @@ YEPTRIS_API YeptrisStatus yeptris_json_schema_validate(const char* schema, size_
         return YEPTRIS_ERROR_ARG;
     }
     *out = NULL;
-    const yep_allocator* sys = yep_system_allocator();
-    YeptrisParseOptions opts;
-    memset(&opts, 0, sizeof(opts)); /* core12 both sides: the YAML->JSON data model */
-
-    /* the schema document (document 0 of its stream) */
+    /* the compiled-schema economy, one call deep (#885 item 3): the
+     * schema parses ONCE here exactly as it always did, rides the SAME
+     * walk and report paths as the retained handle, and dies at return
+     * — the observable statuses and byte-for-byte verdicts are the
+     * suite port's 1298 cases, unchanged */
     YeptrisStatus st = YEPTRIS_OK;
-    YeptrisDocument sdoc = yeptris_parse_eager_ex(schema, schema_len, &opts, &st);
-    if (sdoc == NULL) {
-        if (st == YEPTRIS_OK) {
-            yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
-                          "the schema bytes hold no document");
-            return YEPTRIS_ERROR_ARG;
-        }
-        return st; /* the schema did not parse */
-    }
-    yep_dom* sdom = yep_doc_dom((yeptris_document*)sdoc);
-    if (sdom == NULL || sdom->dcount == 0) {
-        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, 0,
-                      "the schema bytes hold no document");
-        yeptris_document_free(sdoc);
-        return YEPTRIS_ERROR_ARG;
+    yeptris_schema* s = yep_schema_compile_st(schema, schema_len, &st);
+    if (s == NULL) {
+        return st; /* the schema's parse/arg failure, verbatim */
     }
-
-    /* the instance stream */
-    YeptrisDocument idoc = yeptris_parse_eager_ex(buf, len, &opts, &st);
-    if (idoc == NULL) {
-        yeptris_document_free(sdoc);
-        if (st == YEPTRIS_OK) {
-            /* an empty instance stream: nothing to invalidate */
-            return yeptris_validate_document(NULL, YEPTRIS_SCHEMA_12_CORE, out);
-        }
-        return st;
-    }
-    yep_dom* idom = yep_doc_dom((yeptris_document*)idoc);
-    if (idom == NULL) {
-        yeptris_document_free(idoc);
-        yeptris_document_free(sdoc);
-        return YEPTRIS_ERROR_MEMORY;
-    }
-
-    yeptris_validate_report* r = yep_alloc(sys, sizeof(*r));
-    if (r == NULL) {
-        yeptris_document_free(idoc);
-        yeptris_document_free(sdoc);
-        return YEPTRIS_ERROR_MEMORY;
-    }
-    r->diags = yep_alloc(sys, YEP_VALIDATE_MAX_DIAGS * sizeof(yeptris_diagnostic));
-    if (r->diags == NULL) {
-        yep_free(sys, r);
-        yeptris_document_free(idoc);
-        yeptris_document_free(sdoc);
-        return YEPTRIS_ERROR_MEMORY;
-    }
-    r->count = 0;
-    r->truncated = 0;
-
-    int rc = yep_jsonschema_run(sdom, sdom->docs[0], idom, idom->docs, idom->dcount, r);
-    yeptris_document_free(idoc);
-    yeptris_document_free(sdoc);
-    if (rc != 0) {
-        yeptris_validate_report_free(r);
-        return YEPTRIS_ERROR_MEMORY;
-    }
-    *out = r;
-    return r->count > 0 ? YEPTRIS_ERROR_SCHEMA : YEPTRIS_OK;
+    st = yeptris_schema_validate(s, buf, len, out);
+    yeptris_schema_free(s);
+    return st;
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.6.58.1
+  version: 0.6.59.1
 platform: arm-linux-eabihf
 authors:
 - Ribose Inc.
@@ -60,6 +60,7 @@ files:
 - lib/yeptris/psych/tree_builder.rb
 - lib/yeptris/psych/visitors.rb
 - lib/yeptris/schema.rb
+- lib/yeptris/validation.rb
 - lib/yeptris/valueml.rb
 - lib/yeptris/yaml.rb
 - lib/yeptris/yaml/descriptor.rb
@@ -177,6 +178,7 @@ files:
 - vendor/libyeptris/src/yeptris/schema.c
 - vendor/libyeptris/src/yeptris/tape.c
 - vendor/libyeptris/src/yeptris/tape_in.h
+- vendor/libyeptris/src/yeptris/validate/compile.c
 - vendor/libyeptris/src/yeptris/validate/internal.h
 - vendor/libyeptris/src/yeptris/validate/jsonschema.c
 - vendor/libyeptris/src/yeptris/validate/regexp.c