yeptris 0.6.18.2-arm-linux-eabihf

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

@@ -0,0 +1,65 @@
+/* engine.h — the one parser engine (TODO.impl/07).
+ *
+ * Non-recursive block machine + iterative flow kernel, producing events
+ * into any sink (DOM builder today; pull/recorder in 12). v1 runs the
+ * whole buffer in one call; resumable stepping lands with 12's streaming
+ * (recorded as the item's open phase). Depth guard rejects pathological
+ * nesting with an error, never a crash.
+ */
+#ifndef YEP_ENGINE_H
+#define YEP_ENGINE_H
+
+#include "common/error.h"
+#include "common/simd_text.h"
+#include "memory/allocator.h"
+#include "memory/pool.h"
+#include "parse/events.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct yep_engine yep_engine;
+
+yep_engine* yep_engine_create(const yep_allocator* sys);
+void yep_engine_destroy(yep_engine* e);
+
+/* Parses [buf, buf+len) — must be validated UTF-8 (05). Returns 0 on
+ * success, -1 on parse error (see yep_engine_error), -2 sink abort. */
+int yep_engine_run(yep_engine* e, const char* buf, size_t len, const yep_sink* sink);
+
+/* Content-derived pre-sizing before run(): reserves the anchor interner
+ * from the stream's '&' occurrences (every anchor definition carries
+ * exactly one, so the count never undershoots). */
+void yep_engine_prepare(yep_engine* e, const yep_text_stats* st);
+
+/* Resumable stepping (TODO.impl/07): chunks accumulate; every feed
+ * parses the complete DOCUMENTS received so far (cut at `---` / `...`
+ * boundaries at column 0, outside quotes and flow) and keeps the
+ * trailing partial document buffered. final != 0 flushes it and ends
+ * the stream. STREAM markers bracket the whole stepped stream, not
+ * each step; each document's events arrive exactly once, in order.
+ * Returns 0, -1 parse error, -2 sink abort. */
+int yep_engine_step(yep_engine* e, const char* chunk, size_t len, int final, const yep_sink* sink);
+
+/* Detaches the finish pool (ownership moves to the caller; the engine
+ * allocates a fresh one if reused). Returns NULL when absent. */
+yep_pool* yep_engine_detach_pool(yep_engine* e);
+
+/* Implicit-typing schema for the next run (NULL: 1.2 core), and the
+ * runtime nesting limit. */
+struct yep_resolver;
+void yep_engine_set_resolver(yep_engine* e, const struct yep_resolver* r);
+void yep_engine_set_max_depth(yep_engine* e, int depth);
+
+/* Byte offset the last run reached (into that run's buffer); used by
+ * consumers that stop the engine at a boundary and resume. */
+size_t yep_engine_pos(const yep_engine* e);
+
+const yep_error* yep_engine_error(const yep_engine* e);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_ENGINE_H */

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

@@ -0,0 +1,124 @@
+/* events.h — the one grammar vocabulary (TODO.impl/07).
+ *
+ * Every consumption model (DOM builder, pull, push, recorder — 11/12) is
+ * a sink over these events; the engine knows none of them (OCP). Values
+ * are borrowed either from the input buffer or from the engine's finish
+ * pool (folded/escaped content) — `borrowed` says which, so the DOM
+ * builder copies exactly what must outlive the engine.
+ */
+#ifndef YEP_EVENTS_H
+#define YEP_EVENTS_H
+
+#include "common/string_view.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEP_EV_NONE = 0,
+    YEP_EV_STREAM_START,
+    YEP_EV_STREAM_END,
+    YEP_EV_DOCUMENT_START,
+    YEP_EV_DOCUMENT_END,
+    YEP_EV_SEQ_START,
+    YEP_EV_SEQ_END,
+    YEP_EV_MAP_START,
+    YEP_EV_MAP_END,
+    YEP_EV_SCALAR,
+    YEP_EV_ALIAS,
+} yep_event_type;
+
+/* Mirrors libyaml's style set — the wire vocabulary of 12's compat layer. */
+typedef enum {
+    YEP_STYLE_ANY = 0,
+    YEP_STYLE_PLAIN,
+    YEP_STYLE_SINGLE_QUOTED,
+    YEP_STYLE_DOUBLE_QUOTED,
+    YEP_STYLE_LITERAL,
+    YEP_STYLE_FOLDED,
+} yep_scalar_style;
+
+typedef struct yep_event {
+    yep_event_type type;
+    yep_view value;  /* scalar content / alias name */
+    yep_view anchor; /* node properties, empty when absent */
+    yep_view tag;
+    uint8_t style;      /* yep_scalar_style */
+    uint8_t implicit;   /* scalar written without quotes/tag (plain implicit) */
+    uint8_t flow;       /* collection opened in flow context */
+    uint8_t multiline;  /* scalar spanned lines: may not be a simple key */
+    uint8_t tag_id;     /* resolved implicit/explicit tag (resolve/resolver.h) */
+    uint8_t borrowed;   /* 1: value borrows the INPUT; 0: engine finish pool */
+    uint32_t anchor_id; /* 1-based anchor ordinal (the engine's serial);
+                         * on ALIAS: the TARGET's ordinal. 0 = none. Sinks
+                         * that key on it skip the name hash entirely. */
+    uint32_t line;      /* 1-based position of the node start */
+    uint32_t col;
+} yep_event;
+
+struct yep_block_value; /* value facts for on_block_pair (below) */
+
+typedef struct yep_sink {
+    /* Returns 0 to continue, nonzero to abort the parse (sink error). */
+    int (*on_event)(void* ctx, const yep_event* ev);
+    void* ctx;
+    /* Fused flow fast path (TODO.restructure/53): validate AND build
+     * the span at p[open..len) in ONE walk (the grammar walker is
+     * scan/json.c's SSOT). Returns 1 = built and staged, *close set —
+     * the engine runs its close-based grammar checks next, then
+     * COMMITS or ROLLS BACK; 2 = grammar-valid but a map key exceeds
+     * the simple-key limit (nothing staged; the engine's pass 2 owns
+     * that error); 0 = not JSON-class (nothing staged; the general
+     * kernel); <0 = abort. Sinks that consume events (pull/push/
+     * recorder) leave the trio NULL. */
+    int (*on_flow_build)(void* ctx, const char* p, size_t open, size_t len, uint32_t line,
+                         size_t line_start, yep_view anchor, yep_view tag, uint32_t anchor_id,
+                         int max_depth, size_t* close);
+    int (*on_flow_commit)(void* ctx);
+    void (*on_flow_rollback)(void* ctx);
+    /* Optional block fast path (TODO.restructure/54): the engine's
+     * classified KEY arm offers the whole line pair — key scalar plus
+     * a classified value — before emitting any event. line/cols are
+     * the engine's position facts. Return 1 = both nodes built and
+     * placed, 0 = not handled (the engine emits the two events
+     * exactly as before), <0 = abort. */
+    int (*on_block_pair)(void* ctx, const yep_view* key, const struct yep_block_value* v,
+                         uint32_t line, uint16_t key_col, uint16_t val_col);
+    /* Optional block-open fast path (TODO.restructure/57): a `key:`
+     * line whose value lives on FOLLOWING lines, when the engine is
+     * about to open a FRESH mapping. 1 = the sink built the map node
+     * (placed, stack pushed) and the key node — the engine opens its
+     * frame silently and skips both events; 0 = events as before. */
+    int (*on_block_open)(void* ctx, const yep_view* key, uint32_t line, uint16_t key_col);
+    /* Optional dash-item fast path (TODO.restructure/78): a classified
+     * `- value` plain item after the engine opened (or continued) the
+     * block sequence. 1 = the sink built and placed the item node,
+     * 0 = the engine emits the scalar event as before, <0 = abort. */
+    int (*on_block_item)(void* ctx, const struct yep_block_value* v);
+
+    /* Direct scalar path (TODO.restructure/79): the same node the
+     * YEP_EV_SCALAR event builds, minus the event seam — emit_now
+     * resolves the tag first (the typing SSOT stays in the engine)
+     * and calls here when present. NULL = the event path, unchanged. */
+    int (*on_scalar)(void* ctx, const struct yep_view* value, const struct yep_view* tag,
+                     const struct yep_view* anchor, uint32_t anchor_id, uint8_t tag_id,
+                     uint8_t style, uint8_t implicit, uint8_t flow, int borrowed);
+} yep_sink;
+
+/* Value facts for on_block_pair (the classified value classes the
+ * block arms own; spans are input-borrowed). */
+typedef struct yep_block_value {
+    uint8_t cls;        /* YEP_LVAL_PLAIN / _ALIAS / _ANCHOR_PLAIN */
+    uint8_t borrowed;   /* 1: value borrows the input; 0: engine pool */
+    yep_view value;     /* scalar content / alias name */
+    yep_view anchor;    /* _ANCHOR_PLAIN: the &name span */
+    uint32_t anchor_id; /* engine ordinal: the definition (_ANCHOR_)
+                         * or the resolved TARGET (_ALIAS_) */
+} yep_block_value;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_EVENTS_H */

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

@@ -0,0 +1,349 @@
+/* numbers.c — the typed-value conversion kernels (TODO.impl/08B).
+ *
+ * Extracted verbatim from parse.c's node accessors: behavior is
+ * pinned by the typed-accessor spec battery and the 20k randomized
+ * strtod cross-checks. */
+
+#include <errno.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "numbers.h"
+
+#define NUM_BUF 80
+
+/* strips '_' and ',' into a NUL-terminated stack buffer; returns the
+ * cleaned length (the raw length when nothing needed stripping —
+ * callers then use the original bytes) */
+static size_t num_clean(const char* p, uint32_t len, char* buf) {
+    if (memchr(p, '_', len) == NULL && memchr(p, ',', len) == NULL) {
+        return len; /* caller reads p directly */
+    }
+    size_t o = 0;
+    for (uint32_t i = 0; i < len && o + 1 < NUM_BUF; i++) {
+        char c = p[i];
+        if (c == '_' || c == ',') {
+            continue;
+        }
+        buf[o++] = c;
+    }
+    buf[o] = '\0';
+    return o;
+}
+
+/* Clinger-bounded exact decimal: mantissa < 2^53, adjusted
+ * exponent within +-22 — 23-entry pow10 table (08B) */
+static const double k_pow10[23] = {
+    1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,
+};
+
+static int fast_double(const char* s, size_t len, double* out) {
+    size_t i = 0;
+    int neg = 0;
+    if (i < len && (s[i] == '-' || s[i] == '+')) {
+        neg = s[i] == '-';
+        i++;
+    }
+    uint64_t m = 0;
+    int digits = 0;
+    int dot = -1;
+    for (; i < len; i++) {
+        char c = s[i];
+        if (c == '.') {
+            if (dot >= 0) {
+                return 0;
+            }
+            dot = (int)digits;
+            continue;
+        }
+        if (c < '0' || c > '9') {
+            break;
+        }
+        if (digits >= 15) {
+            return 0; /* outside the exact range */
+        }
+        m = m * 10u + (uint64_t)(c - '0');
+        digits++;
+    }
+    if (digits == 0 || (i < len && s[i] != 'e' && s[i] != 'E')) {
+        return 0; /* empty mantissa or trailing junk */
+    }
+    int e10 = 0;
+    if (i < len) {
+        i++; /* e/E */
+        int eneg = 0;
+        if (i < len && (s[i] == '-' || s[i] == '+')) {
+            eneg = s[i] == '-';
+            i++;
+        }
+        if (i >= len) {
+            return 0;
+        }
+        for (; i < len; i++) {
+            if (s[i] < '0' || s[i] > '9') {
+                return 0;
+            }
+            e10 = e10 * 10 + (s[i] - '0');
+            if (e10 > 308) {
+                return 0;
+            }
+        }
+        if (eneg) {
+            e10 = -e10;
+        }
+    }
+    if (dot >= 0) {
+        e10 -= digits - dot;
+    }
+    if (e10 > 22 || e10 < -22 || m >= (1ull << 53)) {
+        return 0; /* outside Clinger's exact range */
+    }
+    if (e10 >= 0) {
+        double v = (double)m * k_pow10[e10];
+        *out = neg ? -v : v;
+    } else {
+        double v = (double)m / k_pow10[-e10];
+        *out = neg ? -v : v;
+    }
+    return 1;
+}
+
+int yep_num_i64(const char* p, uint32_t len, int64_t* out) {
+    if (p == NULL || len == 0) {
+        return 1;
+    }
+    char buf[NUM_BUF];
+    size_t l = num_clean(p, len, buf);
+    const char* num =
+        (l == len && memchr(p, '_', len) == NULL && memchr(p, ',', len) == NULL) ? p : buf;
+    if (num != p) {
+        /* cleaned copy already NUL-terminated by num_clean */
+    } else {
+        if (l >= NUM_BUF) {
+            return 1;
+        }
+        memcpy(buf, num, l);
+        buf[l] = '\0';
+        num = buf;
+    }
+    int base = 10;
+    const char* s = buf;
+    if (buf[0] == '-' || buf[0] == '+') {
+        s++;
+    }
+    if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
+        base = 16;
+    } else if (s[0] == '0' && (s[1] == 'b' || s[1] == 'B')) {
+        base = 2;
+    } else if (s[0] == '0' && s[1] == 'o') {
+        memmove(buf + (size_t)(s - buf) + 1, s + 2, l - (size_t)(s - buf) - 1);
+        l -= 1;
+        buf[l] = '\0';
+        base = 8; /* 0o17 -> 017 octal */
+    } else if (s[0] == '0' && s[1] != '\0' && s[1] != '.') {
+        base = 8; /* compat leading-0 octal */
+    }
+    if (memchr(buf, ':', l) != NULL) {
+        /* Psych's sexagesimal fold, verbatim (scalar_scanner.rb):
+         * component e weighs 60 ** |e - 2| and the SIGN rides the
+         * first component only (-1:30 -> -3600 + 1800 = -1800, not
+         * -5400). A 2-component value is H:M, seconds implicitly
+         * zero (1:30 -> 5400). TODO.restructure/43 / issue #30. */
+        const char* q = buf;
+        long long sign = 1;
+        if (q[0] == '-' || q[0] == '+') {
+            if (q[0] == '-')
+                sign = -1;
+            q++;
+        }
+        long long v = 0;
+        while (*q >= '0' && *q <= '9') {
+            v = v * 10 + (*q - '0');
+            q++;
+        }
+        v *= 3600; /* e0 weight */
+        if (sign < 0)
+            v = -v;
+        int groups = 0;
+        while (*q == ':' && groups < 2) {
+            q++;
+            long long g = 0;
+            int d = 0;
+            while (*q >= '0' && *q <= '9') {
+                g = g * 10 + (*q - '0');
+                q++;
+                d++;
+            }
+            if (d == 0) {
+                return 1;
+            }
+            v += g * (groups == 0 ? 60 : 1); /* e1 then e2 */
+            groups++;
+        }
+        if (groups == 0 || *q != '\0') {
+            return 1;
+        }
+        *out = v;
+        return 0;
+    }
+    char* end = NULL;
+    errno = 0;
+    long long v = strtoll(buf, &end, base);
+    if (end == buf || *end != '\0' || errno == ERANGE) {
+        return 1;
+    }
+    *out = (int64_t)v;
+    return 0;
+}
+
+int yep_num_f64(const char* p, uint32_t len, double* out) {
+    if (p == NULL || len == 0) {
+        return 1;
+    }
+    char buf[NUM_BUF];
+    size_t l = num_clean(p, len, buf);
+    const char* num =
+        (l == len && memchr(p, '_', len) == NULL && memchr(p, ',', len) == NULL) ? p : buf;
+    /* 08B fast path: the common decimal shape converts exactly with
+     * integer arithmetic; everything else falls to strtod */
+    {
+        double fast;
+        if (fast_double(num, l, &fast)) {
+            *out = fast;
+            return 0;
+        }
+    }
+    if (num != p) {
+        /* cleaned copy is NUL-terminated */
+    } else {
+        if (l >= NUM_BUF) {
+            return 1;
+        }
+        memcpy(buf, num, l);
+        buf[l] = '\0';
+        num = buf;
+    }
+    /* .inf / .nan family (sign allowed on inf) */
+    {
+        const char* s = buf;
+        size_t sl = l;
+        if (s[0] == '-' || s[0] == '+') {
+            s++;
+            sl--;
+        }
+        if (sl == 4 && s[0] == '.') {
+            if ((s[1] == 'i' || s[1] == 'I') && (s[2] == 'n' || s[2] == 'N') &&
+                (s[3] == 'f' || s[3] == 'F')) {
+                *out = (buf[0] == '-') ? -INFINITY : INFINITY;
+                return 0;
+            }
+            if ((s[1] == 'n' || s[1] == 'N') && (s[2] == 'a' || s[2] == 'A') &&
+                (s[3] == 'n' || s[3] == 'N')) {
+                *out = NAN;
+                return 0;
+            }
+        }
+    }
+    /* sexagesimal float — Psych's fold: weights 60**|e-2|, sign on
+     * the first component, the fraction on the LAST component
+     * (1:30.5 -> 1*3600 + 30.5*60 = 5430.0). */
+    if (memchr(buf, ':', l) != NULL) {
+        const char* s = buf;
+        double sign = 1.0;
+        if (s[0] == '-' || s[0] == '+') {
+            if (s[0] == '-')
+                sign = -1.0;
+            s++;
+        }
+        double v = 0.0;
+        const char* q = s;
+        while (*q >= '0' && *q <= '9') {
+            v = v * 10.0 + (*q - '0');
+            q++;
+        }
+        v *= 3600.0;
+        v *= sign;
+        int groups = 0;
+        double last = 0.0;
+        double weight = 60.0;
+        for (;;) {
+            if (*q != ':' || groups >= 2)
+                break;
+            q++;
+            double g = 0.0;
+            int d = 0;
+            while (*q >= '0' && *q <= '9') {
+                g = g * 10.0 + (*q - '0');
+                q++;
+                d++;
+            }
+            if (d == 0) {
+                return 1;
+            }
+            if (*q == '.') {
+                double frac = 0.0, scale = 0.1;
+                q++;
+                while (*q >= '0' && *q <= '9') {
+                    frac += (*q - '0') * scale;
+                    scale /= 10.0;
+                    q++;
+                }
+                g += frac;
+            }
+            v += g * weight;
+            weight = 1.0; /* e2 */
+            last = g;
+            groups++;
+        }
+        (void)last;
+        if (groups == 0 || *q != '\0') {
+            return 1;
+        }
+        *out = v;
+        return 0;
+    }
+    char* end = NULL;
+    errno = 0;
+    double v = strtod(buf, &end);
+    if (end == buf || *end != '\0') {
+        return 1;
+    }
+    (void)errno;
+    *out = v;
+    return 0;
+}
+
+int yep_num_bool(const char* p, uint32_t len) {
+    static const char* k_true[] = {"true", "True", "TRUE", "y",  "Y", "yes",
+                                   "Yes",  "YES",  "on",   "On", "ON"};
+    for (size_t i = 0; i < sizeof(k_true) / sizeof(k_true[0]); i++) {
+        size_t m = strlen(k_true[i]);
+        if (len == m && memcmp(p, k_true[i], m) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int yep_num_bool_ci(const char* p, uint32_t len) {
+    /* the compat resolver matches bool words case-insensitively;
+     * truth follows the same rule (Psych's scanner downcases) */
+    static const char* k_true[] = {"y", "yes", "true", "on"};
+    char buf[8];
+    if (len == 0 || len > 5) {
+        return 0;
+    }
+    for (uint32_t i = 0; i < len; i++) {
+        char c = p[i];
+        buf[i] = (c >= 'A' && c <= 'Z') ? (char)(c + 32) : c;
+    }
+    for (size_t i = 0; i < sizeof(k_true) / sizeof(k_true[0]); i++) {
+        size_t m = strlen(k_true[i]);
+        if (len == m && memcmp(buf, k_true[i], m) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,33 @@
+/* numbers.h — the typed-value conversion kernels (TODO.impl/08B).
+ *
+ * ONE home for text->int64/double/bool: the node typed accessors,
+ * the value stream (values.c), and any future consumer ride these.
+ * Pure functions over (pointer, length) — no handles, no state. */
+#ifndef YEP_NUMBERS_H
+#define YEP_NUMBERS_H
+
+#include <stdint.h>
+#include <yeptris/api.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Separator-carrying YAML number text (digits, '_', ','; radix
+ * forms 0x/0o/0b/leading-0; sexagesimal for the compat schema).
+ * Returns 0 and sets *out on success, nonzero otherwise. */
+YEPTRIS_API int yep_num_i64(const char* p, uint32_t len, int64_t* out);
+YEPTRIS_API int yep_num_f64(const char* p, uint32_t len, double* out);
+
+/* The resolver's true-word set (true/True/TRUE/y/Y/yes/Yes/YES/on/
+ * On/ON); anything else the BOOL tag accepted is false. */
+YEPTRIS_API int yep_num_bool(const char* p, uint32_t len);
+
+/* Case-insensitive truth (the compat resolver's matching rule). */
+YEPTRIS_API int yep_num_bool_ci(const char* p, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_NUMBERS_H */