yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/tape_in.h

@@ -0,0 +1,19 @@
+/* tape_in.h — the tape module's internal seams (not public ABI).
+ *
+ * parse.c's #342 slice-2 lazy route drives the fused lenient walk
+ * directly: the gate and opener checks it already ran must not be
+ * repeated (the lenient public entry re-gates). The walk's contract
+ * is the public entry's: gate-clean buffer, p[open] is '[' or '{',
+ * tail must be whitespace-only. */
+#ifndef YEP_TAPE_IN_H
+#define YEP_TAPE_IN_H
+
+#include <stddef.h>
+
+#include <yeptris/tape.h>
+
+/* tape.c (was tape_walk_lnt_fused) */
+YeptrisStatus yep_tape_walk_lenient_fused(const char* p, size_t len, size_t open,
+                                          yeptris_json_tape* t);
+
+#endif

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

@@ -0,0 +1,7 @@
+/* version.c — library version string (generated header is the SSOT). */
+
+#include <yeptris/version.h>
+
+YEPTRIS_API const char* yeptris_version(void) {
+    return YEPTRIS_VERSION_STRING;
+}

data/vendor/libyeptris/src/yeptris/visit/dom_visit.c

@@ -0,0 +1,115 @@
+/* dom_visit.c — DOM subtree → visitor (TODO.restructure/24). */
+
+#include <string.h>
+
+#include "../dom/dom.h"
+#include "../parse/numbers.h"
+#include "doc.h"
+
+#include <yeptris/resolve.h>
+#include <yeptris/visit.h>
+
+static int visit_id(const yep_dom* d, uint32_t id, const YeptrisVisitVTable* vt, void* ctx);
+
+static int visit_id(const yep_dom* d, uint32_t id, const YeptrisVisitVTable* vt, void* ctx) {
+    const yep_dnode* n = yep_dom_node(d, id);
+    if (n == NULL) {
+        return -1;
+    }
+    if (n->anchor.len != 0 && n->kind != YEP_DOM_ALIAS && vt->on_anchor) {
+        yep_view a = yep_dom_view(d, n->anchor);
+        if (vt->on_anchor(ctx, a.p, a.len) != 0) {
+            return -1;
+        }
+    }
+    switch (n->kind) {
+    case YEP_DOM_ALIAS: {
+        yep_view a = yep_dom_view(d, n->value);
+        if (vt->on_alias && vt->on_alias(ctx, a.p, a.len) != 0) {
+            return -1;
+        }
+        return 0;
+    }
+    case YEP_DOM_SEQUENCE:
+        if (vt->on_seq_start && vt->on_seq_start(ctx) != 0) {
+            return -1;
+        }
+        for (uint32_t c = n->first_child; c != UINT32_MAX; c = d->nodes[c].next_sibling) {
+            if (visit_id(d, c, vt, ctx) != 0) {
+                return -1;
+            }
+        }
+        if (vt->on_seq_end && vt->on_seq_end(ctx) != 0) {
+            return -1;
+        }
+        return 0;
+    case YEP_DOM_MAPPING:
+        if (vt->on_map_start && vt->on_map_start(ctx) != 0) {
+            return -1;
+        }
+        for (uint32_t c = n->first_child; c != UINT32_MAX;) {
+            uint32_t k = c;
+            uint32_t v = d->nodes[c].next_sibling;
+            if (v == UINT32_MAX) {
+                return -1;
+            }
+            /* key */
+            const yep_dnode* kn = yep_dom_node(d, k);
+            if (kn != NULL && kn->kind == YEP_DOM_SCALAR && vt->on_key) {
+                yep_view kv = yep_dom_view(d, kn->value);
+                if (vt->on_key(ctx, kv.p, kv.len) != 0) {
+                    return -1;
+                }
+            } else if (visit_id(d, k, vt, ctx) != 0) {
+                return -1;
+            }
+            if (visit_id(d, v, vt, ctx) != 0) {
+                return -1;
+            }
+            c = d->nodes[v].next_sibling;
+        }
+        if (vt->on_map_end && vt->on_map_end(ctx) != 0) {
+            return -1;
+        }
+        return 0;
+    default: { /* scalar */
+        yep_view s = yep_dom_view(d, n->value);
+        switch (n->tag_id) {
+        case YEPTRIS_TAG_NULL:
+            return vt->on_null ? vt->on_null(ctx) : 0;
+        case YEPTRIS_TAG_BOOL: {
+            int b = yep_num_bool_ci(s.p, (uint32_t)s.len);
+            return vt->on_bool ? vt->on_bool(ctx, b) : 0;
+        }
+        case YEPTRIS_TAG_INT: {
+            int64_t v = 0;
+            if (yep_num_i64(s.p, (uint32_t)s.len, &v) != 0) {
+                return vt->on_string ? vt->on_string(ctx, s.p, s.len) : 0;
+            }
+            return vt->on_int ? vt->on_int(ctx, v) : 0;
+        }
+        case YEPTRIS_TAG_FLOAT: {
+            double v = 0.0;
+            if (yep_num_f64(s.p, (uint32_t)s.len, &v) != 0) {
+                return vt->on_string ? vt->on_string(ctx, s.p, s.len) : 0;
+            }
+            return vt->on_float ? vt->on_float(ctx, v) : 0;
+        }
+        default:
+            return vt->on_string ? vt->on_string(ctx, s.p, s.len) : 0;
+        }
+    }
+    }
+}
+
+YEPTRIS_API YeptrisStatus yeptris_visit_node(YeptrisNode node, const YeptrisVisitVTable* vt,
+                                             void* ctx) {
+    if (node == NULL || vt == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    yeptris_node* h = (yeptris_node*)node;
+    if (h->doc == NULL || h->doc->dom == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    return visit_id(h->doc->dom, h->id, vt, ctx) == 0 ? YEPTRIS_OK : YEPTRIS_ERROR_INTERNAL;
+}

data/vendor/libyeptris/src/yeptris/visit/json_visit.c

@@ -0,0 +1,293 @@
+/* json_visit.c — fused RFC 8259 scan → visitor (TODO.restructure/24).
+ *
+ * One pass, no DOM, no records: the JSON kernels tokenize and the
+ * vtable receives values directly. Escaped strings decode into a
+ * small scratch that lives only for the on_string callback. */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "../parse/numbers.h"
+#include "../parse/scalars.h"
+#include "../scan/json.h"
+
+#include <yeptris/visit.h>
+
+typedef struct {
+    const char* p;
+    size_t len;
+    size_t i;
+    const YeptrisVisitVTable* vt;
+    void* ctx;
+    char* scratch;
+    size_t scratch_cap;
+    int depth;
+    int err; /* 0 ok, -1 oom/abort, -2 parse */
+} jv;
+
+#define YEP_JV_MAX_DEPTH 1000
+
+static int jv_emit_str(jv* j, const char* s, size_t n) {
+    if (j->vt->on_string == NULL) {
+        return 0;
+    }
+    return j->vt->on_string(j->ctx, s, n);
+}
+
+static int jv_value(jv* j);
+
+static void jv_ws(jv* j) {
+    while (j->i < j->len) {
+        char c = j->p[j->i];
+        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+            j->i++;
+        } else {
+            break;
+        }
+    }
+}
+
+static int jv_string(jv* j, int as_key) {
+    size_t start = j->i;
+    size_t close = 0;
+    int has_esc = 0;
+    if (!yep_json_string(j->p, j->len, &j->i, &close, &has_esc)) {
+        j->err = -2;
+        return -1;
+    }
+    const char* sp;
+    size_t sl;
+    if (has_esc) {
+        uint32_t span = (uint32_t)(close - start - 1);
+        if (span + 1 > j->scratch_cap) {
+            size_t cap = j->scratch_cap ? j->scratch_cap : 64;
+            while (cap < span + 1) {
+                cap *= 2;
+            }
+            char* ns = realloc(j->scratch, cap);
+            if (ns == NULL) {
+                j->err = -1;
+                return -1;
+            }
+            j->scratch = ns;
+            j->scratch_cap = cap;
+        }
+        sl = yep_finish_double_into(j->p, (uint32_t)(start + 1), (uint32_t)close, j->scratch, span);
+        sp = j->scratch;
+    } else {
+        sp = j->p + start + 1;
+        sl = close - start - 1;
+    }
+    int rc;
+    if (as_key && j->vt->on_key != NULL) {
+        rc = j->vt->on_key(j->ctx, sp, sl);
+    } else {
+        rc = jv_emit_str(j, sp, sl);
+    }
+    if (rc != 0) {
+        j->err = -1;
+        return -1;
+    }
+    return 0;
+}
+
+static int jv_number(jv* j) {
+    size_t start = j->i;
+    if (!yep_json_number(j->p, j->len, &j->i)) {
+        j->err = -2;
+        return -1;
+    }
+    const char* s = j->p + start;
+    uint32_t n = (uint32_t)(j->i - start);
+    /* integer if no '.' and no exponent — matches JSON.parse */
+    int is_float = 0;
+    for (uint32_t k = 0; k < n; k++) {
+        char c = s[k];
+        if (c == '.' || c == 'e' || c == 'E') {
+            is_float = 1;
+            break;
+        }
+    }
+    if (is_float) {
+        double d = 0.0;
+        if (yep_num_f64(s, n, &d) != 0) {
+            j->err = -2;
+            return -1;
+        }
+        if (j->vt->on_float != NULL && j->vt->on_float(j->ctx, d) != 0) {
+            j->err = -1;
+            return -1;
+        }
+    } else {
+        int64_t v = 0;
+        if (yep_num_i64(s, n, &v) != 0) {
+            /* overflow: hand up as double (JSON.parse does this past
+             * 2^53 roughly; we keep int64 max then float) */
+            double d = 0.0;
+            if (yep_num_f64(s, n, &d) != 0) {
+                j->err = -2;
+                return -1;
+            }
+            if (j->vt->on_float != NULL && j->vt->on_float(j->ctx, d) != 0) {
+                j->err = -1;
+                return -1;
+            }
+        } else if (j->vt->on_int != NULL && j->vt->on_int(j->ctx, v) != 0) {
+            j->err = -1;
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static int jv_literal(jv* j, const char* word, int kind) {
+    if (!yep_json_literal(j->p, j->len, &j->i, word)) {
+        j->err = -2;
+        return -1;
+    }
+    int rc = 0;
+    if (kind == 0) { /* null */
+        if (j->vt->on_null) {
+            rc = j->vt->on_null(j->ctx);
+        }
+    } else if (j->vt->on_bool) {
+        rc = j->vt->on_bool(j->ctx, kind > 0);
+    }
+    if (rc != 0) {
+        j->err = -1;
+        return -1;
+    }
+    return 0;
+}
+
+static int jv_container(jv* j, int is_map) {
+    if (j->depth >= YEP_JV_MAX_DEPTH) {
+        j->err = -2;
+        return -1;
+    }
+    j->i++; /* skip [ or { */
+    j->depth++;
+    if (is_map) {
+        if (j->vt->on_map_start && j->vt->on_map_start(j->ctx) != 0) {
+            j->err = -1;
+            return -1;
+        }
+    } else if (j->vt->on_seq_start && j->vt->on_seq_start(j->ctx) != 0) {
+        j->err = -1;
+        return -1;
+    }
+    jv_ws(j);
+    char close = is_map ? '}' : ']';
+    if (j->i < j->len && j->p[j->i] == close) {
+        j->i++;
+        j->depth--;
+        if (is_map) {
+            if (j->vt->on_map_end && j->vt->on_map_end(j->ctx) != 0) {
+                j->err = -1;
+                return -1;
+            }
+        } else if (j->vt->on_seq_end && j->vt->on_seq_end(j->ctx) != 0) {
+            j->err = -1;
+            return -1;
+        }
+        return 0;
+    }
+    for (;;) {
+        if (is_map) {
+            jv_ws(j);
+            if (j->i >= j->len || j->p[j->i] != '"') {
+                j->err = -2;
+                return -1;
+            }
+            if (jv_string(j, 1) != 0) {
+                return -1;
+            }
+            jv_ws(j);
+            if (j->i >= j->len || j->p[j->i] != ':') {
+                j->err = -2;
+                return -1;
+            }
+            j->i++;
+            if (jv_value(j) != 0) {
+                return -1;
+            }
+        } else if (jv_value(j) != 0) {
+            return -1;
+        }
+        jv_ws(j);
+        if (j->i >= j->len) {
+            j->err = -2;
+            return -1;
+        }
+        if (j->p[j->i] == ',') {
+            j->i++;
+            continue;
+        }
+        if (j->p[j->i] == close) {
+            j->i++;
+            j->depth--;
+            if (is_map) {
+                if (j->vt->on_map_end && j->vt->on_map_end(j->ctx) != 0) {
+                    j->err = -1;
+                    return -1;
+                }
+            } else if (j->vt->on_seq_end && j->vt->on_seq_end(j->ctx) != 0) {
+                j->err = -1;
+                return -1;
+            }
+            return 0;
+        }
+        j->err = -2;
+        return -1;
+    }
+}
+
+static int jv_value(jv* j) {
+    jv_ws(j);
+    if (j->i >= j->len) {
+        j->err = -2;
+        return -1;
+    }
+    char c = j->p[j->i];
+    if (c == '{') {
+        return jv_container(j, 1);
+    }
+    if (c == '[') {
+        return jv_container(j, 0);
+    }
+    if (c == '"') {
+        return jv_string(j, 0);
+    }
+    if (c == 't') {
+        return jv_literal(j, "true", 1);
+    }
+    if (c == 'f') {
+        return jv_literal(j, "false", -1);
+    }
+    if (c == 'n') {
+        return jv_literal(j, "null", 0);
+    }
+    if (c == '-' || (c >= '0' && c <= '9')) {
+        return jv_number(j);
+    }
+    j->err = -2;
+    return -1;
+}
+
+YEPTRIS_API YeptrisStatus yeptris_visit_json(const char* data, size_t len,
+                                             const YeptrisVisitVTable* vt, void* ctx) {
+    if (vt == NULL || (data == NULL && len != 0)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    jv j = {data, len, 0, vt, ctx, NULL, 0, 0, 0};
+    if (jv_value(&j) != 0) {
+        free(j.scratch);
+        return j.err == -1 ? YEPTRIS_ERROR_MEMORY : YEPTRIS_ERROR_PARSE;
+    }
+    jv_ws(&j);
+    free(j.scratch);
+    if (j.i != len) {
+        return YEPTRIS_ERROR_PARSE;
+    }
+    return YEPTRIS_OK;
+}

data/vendor/libyeptris/src/yeptris/visit/yaml_visit.c

@@ -0,0 +1,127 @@
+/* yaml_visit.c — engine → visitor (TODO.restructure/24).
+ *
+ * Reuses the value-record pipeline (the conversion SSOT) and replays
+ * records into the vtable. One allocation of records is still far
+ * cheaper than host-side walks; the JSON fused path is the one that
+ * must beat JSON.parse and skips records entirely. */
+
+#include <string.h>
+
+#include "../events/values_priv.h"
+
+#include <yeptris/visit.h>
+
+/* CLOSE needs open-kind: replay with a small kind stack. */
+static int play_stacked(const yep_value_ctx* c, const YeptrisVisitVTable* vt, void* ctx) {
+    const YeptrisValue* vals = c->vals;
+    const char* arena = c->arena ? c->arena : "";
+    unsigned char stack[1024];
+    int sp = 0;
+    for (size_t i = 0; i < c->n; i++) {
+        const YeptrisValue* v = &vals[i];
+        int rc = 0;
+        switch (v->kind) {
+        case YEP_V_DOC:
+            if (vt->on_doc) {
+                rc = vt->on_doc(ctx);
+            }
+            break;
+        case YEP_V_NULL:
+            if (vt->on_null) {
+                rc = vt->on_null(ctx);
+            }
+            break;
+        case YEP_V_BOOL:
+            if (vt->on_bool) {
+                rc = vt->on_bool(ctx, v->b);
+            }
+            break;
+        case YEP_V_INT:
+            if (vt->on_int) {
+                rc = vt->on_int(ctx, (int64_t)v->p);
+            }
+            break;
+        case YEP_V_FLOAT: {
+            double d;
+            memcpy(&d, &v->p, sizeof(d));
+            if (vt->on_float) {
+                rc = vt->on_float(ctx, d);
+            }
+            break;
+        }
+        case YEP_V_STR:
+        case YEP_V_TIMESTAMP: {
+            const char* s = arena + v->off;
+            /* is_key alternation only MEANS something inside a map:
+             * the slot rule marks a container's first record
+             * spuriously when the parent is a sequence */
+            int in_map = sp > 0 && stack[sp - 1] == 1;
+            if (in_map && v->is_key && vt->on_key) {
+                rc = vt->on_key(ctx, s, v->len);
+            } else if (vt->on_string) {
+                rc = vt->on_string(ctx, s, v->len);
+            }
+            break;
+        }
+        case YEP_V_SEQ_OPEN:
+            if (sp < (int)sizeof(stack)) {
+                stack[sp++] = 0;
+            }
+            if (vt->on_seq_start) {
+                rc = vt->on_seq_start(ctx);
+            }
+            break;
+        case YEP_V_MAP_OPEN:
+            if (sp < (int)sizeof(stack)) {
+                stack[sp++] = 1;
+            }
+            if (vt->on_map_start) {
+                rc = vt->on_map_start(ctx);
+            }
+            break;
+        case YEP_V_CLOSE:
+            if (sp > 0) {
+                unsigned char kind = stack[--sp];
+                if (kind) {
+                    if (vt->on_map_end) {
+                        rc = vt->on_map_end(ctx);
+                    }
+                } else if (vt->on_seq_end) {
+                    rc = vt->on_seq_end(ctx);
+                }
+            }
+            break;
+        case YEP_V_ANCHOR:
+            if (vt->on_anchor) {
+                rc = vt->on_anchor(ctx, arena + v->off, v->len);
+            }
+            break;
+        case YEP_V_ALIAS:
+            if (vt->on_alias) {
+                rc = vt->on_alias(ctx, arena + v->off, v->len);
+            }
+            break;
+        default:
+            break;
+        }
+        if (rc != 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+YEPTRIS_API YeptrisStatus yeptris_visit(const char* data, size_t len, YeptrisSchema schema,
+                                        const YeptrisVisitVTable* vt, void* ctx) {
+    if (vt == NULL || (data == NULL && len != 0)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    yep_value_ctx* c = NULL;
+    int rc = yep_values_from_input(data, len, schema == YEPTRIS_SCHEMA_11_COMPAT, &c);
+    if (rc != 0) {
+        return rc == -1 ? YEPTRIS_ERROR_MEMORY : YEPTRIS_ERROR_PARSE;
+    }
+    int prc = play_stacked(c, vt, ctx);
+    yep_value_ctx_free(c);
+    return prc == 0 ? YEPTRIS_OK : YEPTRIS_ERROR_INTERNAL;
+}