yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/include/yeptris/schema.h

@@ -0,0 +1,121 @@
+/* schema.h — the fused schema-descriptor materialization API
+ * (issue #238, TODO.restructure/83).
+ *
+ * The descriptor is the ABI, NOT a schema language: XSD/JSON-Schema
+ * cannot express consumer semantics (two-names-one-slot merges, value
+ * maps, key renames, raw capture) — the CONSUMER compiles those into
+ * this flat positional plan, the same way lutaml-model compiles its
+ * rule plans. The engine materializes against it in ONE native pass;
+ * the intermediate generic document (the Hash/Array the bindings used
+ * to build) never exists.
+ *
+ * Design contract (from the committed consumer, co-designed):
+ *  - kind CALLBACK is the escape hatch: the raw value span plus the
+ *    node's byte position come back as records; the host finishes
+ *    just those fields (custom procs, polymorphism, delegates).
+ *  - Results are WHOLE DOCUMENTS: this call never crosses the FFI
+ *    boundary per value — the caller passes output buffers sized by
+ *    expectation and receives per-node counts.
+ *  - The descriptor ABI is versioned in lockstep with the bindings
+ *    ({c-semver}.{binding-patch}); desc_abi changes only with a C
+ *    minor bump.
+ *  - Sequences of a plan run the SAME node plan for every element
+ *    (flags ELEMENT); nested mappings run their child plan slice.
+ */
+#ifndef YEPTRIS_SCHEMA_H
+#define YEPTRIS_SCHEMA_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/parse.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The descriptor ABI version of this header. */
+#define YEPTRIS_DESC_ABI 1u
+
+/* node kinds */
+enum {
+    YEP_SK_SCALAR = 0, /* typed leaf: type_tag decides the column */
+    YEP_SK_SEQUENCE,   /* sequence: children[0] is the ELEMENT plan */
+    YEP_SK_MAPPING,    /* mapping: children are the key plans */
+    YEP_SK_CALLBACK,   /* escape hatch: raw span + position records */
+};
+
+/* scalar type tags (the columns' element types) */
+enum {
+    YEP_ST_STR = 0, /* off/len into the input */
+    YEP_ST_INT,     /* int64_t */
+    YEP_ST_FLOAT,   /* double */
+    YEP_ST_BOOL,    /* uint8_t */
+    YEP_ST_NULL,    /* no payload (count only) */
+    YEP_ST_ANY,     /* SCALAR: keep the resolver's verdict — the
+                       column is a YeptrisValue-like record */
+};
+
+/* node flags */
+enum {
+    YEP_SF_REQUIRED = 1u << 0,   /* missing at its mapping -> error */
+    YEP_SF_FIRST_WINS = 1u << 1, /* duplicates: first match kept
+                                    (default: last, as at parse) */
+};
+
+/* One plan node. ABI-pinned: a pointer plus 16 fixed-width bytes —
+ * 24 on LP64, 20 on 32-bit (the hosts' FFI mirrors size :pointer
+ * per-process, so the layout contract is the POINTER plus the tail). */
+typedef struct yeptris_desc_node {
+    const char* wire_name; /* mapping key to match (NULL: the root) */
+    uint8_t kind;          /* YEP_SK_* */
+    uint8_t type_tag;      /* YEP_ST_* (SCALAR) */
+    uint16_t flags;        /* YEP_SF_* */
+    uint32_t child_index;  /* SEQUENCE: the element plan; MAPPING: the
+                              first child. Unused otherwise (0). */
+    uint32_t child_count;  /* MAPPING: children from child_index. */
+    uint32_t reserved;     /* must be 0 (ABI headroom) */
+} yeptris_desc_node;
+
+YEPTRIS_CT_ASSERT(sizeof(yeptris_desc_node) == sizeof(const char*) + 16);
+
+/* One column's output. Caller allocates the payload array (sized by
+ * expectation); the call fills it and sets count. No per-value FFI:
+ * hosts drain whole columns after the call. */
+typedef struct yeptris_schema_column {
+    void* data;        /* element type from the plan's type_tag */
+    uint32_t capacity; /* elements the buffer holds */
+    uint32_t count;    /* elements materialized (out) */
+} yeptris_schema_column;
+
+/* STR/CALLBACK payload: off/len into the INPUT buffer (zero-copy to
+ * the host). CALLBACK also carries the node's byte position. */
+typedef struct yeptris_span2 {
+    uint32_t off;
+    uint32_t len;
+    uint32_t node_off; /* the node's first byte (callbacks) */
+    uint32_t pad;
+} yeptris_span2;
+
+YEPTRIS_CT_ASSERT(sizeof(yeptris_span2) == 16);
+
+/* Parses `source` (YAML or strict JSON — the same front door as
+ * yeptris_parse_ex) and materializes against the descriptor in one
+ * pass: node i's matches land in cols[i]. The input buffer must
+ * outlive the string/callback spans (they borrow it).
+ *
+ * Status: YEPTRIS_OK; YEPTRIS_ERROR_PARSE (yeptris_last_error);
+ * YEPTRIS_ERROR_SCHEMA (a REQUIRED node missing — the error carries
+ * the node index; detail via yeptris_last_error); YEPTRIS_ERROR_MEMORY
+ * / ARG (NULL descriptor, desc_len 0, desc_abi mismatch). */
+YEPTRIS_API YeptrisStatus yeptris_schema_load(const char* source, size_t len, YeptrisSchema schema,
+                                              const yeptris_desc_node* desc, uint32_t desc_len,
+                                              uint32_t desc_abi, yeptris_schema_column* cols);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_SCHEMA_H */

data/vendor/libyeptris/src/include/yeptris/tape.h

@@ -0,0 +1,123 @@
+/* tape.h — the compact JSON tape (issue #238's consumer shape,
+ * TODO.restructure/85: the simdjson-class materialization).
+ *
+ * One fused strict walk appends ONE record per token — no DOM nodes,
+ * no links, no views. Records are THREE parallel columns (kind byte,
+ * off, len) carved from one block: bools encode in the kind, container
+ * links ride the off column, and NUMBERS RECORD SPANS ONLY — parse
+ * validates the grammar (the lean shape scan) and materialize converts
+ * (yeptris_tape_convert; the C-API materializer converts inline).
+ * Strings stay zero-copy spans into the caller's buffer.
+ *
+ * The tape is a document-level result (never per value across FFI);
+ * the buffer the spans borrow must outlive it.
+ */
+#ifndef YEPTRIS_TAPE_H
+#define YEPTRIS_TAPE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Record kinds (the kinds column). */
+enum {
+    YEP_T_DOC = 0, /* document boundary (records start after it) */
+    YEP_T_NULL,
+    YEP_T_TRUE,     /* the kind IS the value */
+    YEP_T_FALSE,    /* the kind IS the value */
+    YEP_T_INT,      /* off/len: signed digit span; convert at materialize */
+    YEP_T_FLOAT,    /* off/len: float text span; convert at materialize */
+    YEP_T_STR,      /* off/len: raw span (escapes untouched; the
+                        qbc kernel found them) */
+    YEP_T_SEQ_OPEN, /* off: index of the matching CLOSE */
+    YEP_T_MAP_OPEN, /* off: index of the matching CLOSE; keys are
+                        the STR records at even positions inside */
+    YEP_T_CLOSE,    /* off: index of the matching OPEN */
+    YEP_T_NUM,      /* lenient route only: off/len number span with
+                        the grammar UNVALIDATED at parse —
+                        yeptris_tape_convert is the authority (it
+                        classifies int/float and rejects malformed
+                        spans; simdjson's deferred contract) */
+};
+
+/* The interleaved record (TODO.max-perf/07): one 8-byte store per
+ * token instead of three column stores. Layout: off:u32 | len:u23 |
+ * kind:u8 — a span longer than 0xFEFFFF bytes carries len == 0xFFFFFF
+ * with the true length stored as a CONT-terminated extension record
+ * (kind YEP_T_CONT; unreachable for <16 MiB tokens). The columns
+ * stay the compatibility ABI: yeptris_tape_columns materializes them
+ * lazily from the records on first touch. */
+#define YEP_T_CONT 8 /* record-length extension (not a token kind) */
+typedef uint64_t yeptris_tape_rec;
+
+typedef struct yeptris_json_tape {
+    size_t count;
+    uint8_t* kinds;         /* compat columns — materialized lazily (see
+                               yeptris_tape_columns) when the interleaved
+                               records are the primary storage */
+    uint32_t* offs;         /* span starts (STR/INT/FLOAT); container links */
+    uint32_t* lens;         /* span lengths (STR/INT/FLOAT) */
+    yeptris_tape_rec* recs; /* primary storage (may be NULL on legacy
+                               column-built tapes: the strict route) */
+    int _cols_ready;        /* columns materialized from recs already */
+    int _rec_primary;       /* the lenient route: recs carry the data and
+                               the columns are lazy */
+    int64_t int_min;        /* set by yeptris_tape_convert when an INT span
+                               exceeds int64 (materialize-time discovery) */
+    const void* _src;       /* the parsed buffer (spans borrow it; it must
+                               outlive the tape — same contract as the spans) */
+    size_t _srclen;
+    void* _block; /* the carved allocation base */
+} yeptris_json_tape;
+
+/* Parses strict JSON into the tape. Accepts scalar roots (a single
+ * record). Returns YEPTRIS_OK, YEPTRIS_ERROR_PARSE (details via
+ * yeptris_last_error), YEPTRIS_ERROR_MEMORY, YEPTRIS_ERROR_ARG. */
+YEPTRIS_API YeptrisStatus yeptris_parse_json_tape(const char* source, size_t len,
+                                                  yeptris_json_tape* tape);
+
+/* The lenient route (simdjson's deferred contract, opt-in): every
+ * STRUCTURAL check stays at parse (bracket matching, alternation,
+ * comma/colon placement, literals, string closes/escapes) while
+ * NUMBER grammar defers to yeptris_tape_convert — a number records
+ * as a YEP_T_NUM charset run (so "1.2.3" is accepted here and
+ * rejected at convert, exactly where simdjson's number parse would
+ * fail; a run with non-number bytes like "12ab" still rejects
+ * structurally at parse). Accepts a superset of the strict route's
+ * inputs (tab whitespace becomes legal, RFC 8259); on everything
+ * the strict route accepts, the tapes are structurally identical
+ * (spans and containers equal; NUM records carry the same bytes the
+ * strict INT/FLOAT records carry). Non-ASCII inputs take the strict
+ * route unchanged. */
+YEPTRIS_API YeptrisStatus yeptris_parse_json_tape_lenient(const char* source, size_t len,
+                                                          yeptris_json_tape* tape);
+
+YEPTRIS_API void yeptris_tape_free(yeptris_json_tape* tape);
+
+/* Converts the INT/FLOAT records in [from, to): ivals/dvals are
+ * parallel to the RECORD indices (slots for other kinds are left
+ * untouched; either pointer may be NULL). Returns the number of
+ * number records converted, or SIZE_MAX if a span does not re-scan
+ * as a number (impossible for a tape this library produced).
+ * Sets t->int_min when an INT span exceeds int64. */
+/* Materializes the kinds/offs/lens columns from the interleaved
+ * records (no-op when the tape was built column-primary or the
+ * columns are already materialized). Consumers reading the column
+ * pointers directly (the FFI binding) must call this once first.
+ * Returns 0 on success, nonzero on allocation failure. */
+YEPTRIS_API int yeptris_tape_columns(yeptris_json_tape* t);
+
+YEPTRIS_API size_t yeptris_tape_convert(yeptris_json_tape* t, size_t from, size_t to,
+                                        int64_t* ivals, double* dvals);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_TAPE_H */

data/vendor/libyeptris/src/include/yeptris/types.h

@@ -0,0 +1,38 @@
+/* types.h — opaque public handles.
+ *
+ * The single canonical source of public types (TODO.impl/02 extends this
+ * file; internal types never appear here). Callers never see struct
+ * definitions: every handle is opaque and pointer-sized, asserted by the
+ * ABI pinning test (test/unit/test_abi.cpp).
+ */
+#ifndef YEPTRIS_TYPES_H
+#define YEPTRIS_TYPES_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* A parsed document; the sole owner of all memory reachable from it.
+ * Memory: freed exactly once with yeptris_document_free (TODO.impl/11). */
+typedef struct yeptris_document* YeptrisDocument;
+
+/* A node (document, mapping, sequence, scalar, alias) inside a document.
+ * Memory: borrowed from its document — valid until the document is freed. */
+typedef struct yeptris_node* YeptrisNode;
+
+/* Streaming/streaming-adjacent handles, introduced with their items:
+ * parser engine (TODO.impl/07), pull/recorder/iterparse (TODO.impl/12),
+ * emitter (TODO.impl/13). Declared now so the handle vocabulary is stable. */
+typedef struct yeptris_parser* YeptrisParser;
+typedef struct yeptris_pull* YeptrisPullParser;
+typedef struct yeptris_recorder* YeptrisRecorder;
+typedef struct yeptris_iterparse* YeptrisIterparse;
+typedef struct yeptris_emitter* YeptrisEmitter;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_TYPES_H */

data/vendor/libyeptris/src/include/yeptris/values.h

@@ -0,0 +1,102 @@
+/* values.h — the typed value stream (TODO.impl/15 phase F).
+ *
+ * The materialization fast path for FFI bindings: one parse, one
+ * drain of PRE-CONVERTED typed values. The C side runs the same
+ * engine the recorder drives, then converts every scalar by its
+ * resolver tag — the host walks a flat array and builds containers,
+ * never re-parsing text.
+ *
+ * The `is_key` bit carries the key/value alternation, so hosts need
+ * no pending-key bookkeeping; `tag_id` rides along so hosts with
+ * schema quirks (Psych's single-char y/n, PyYAML's dot-required
+ * floats) can re-decide a scalar's type from its raw bytes without
+ * re-running a conversion grammar.
+ */
+#ifndef YEPTRIS_VALUES_H
+#define YEPTRIS_VALUES_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/resolve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    YEP_V_DOC = 0, /* document boundary */
+    YEP_V_NULL,
+    YEP_V_BOOL,      /* b carries 0/1 */
+    YEP_V_INT,       /* i */
+    YEP_V_FLOAT,     /* d */
+    YEP_V_STR,       /* off/len bytes */
+    YEP_V_TIMESTAMP, /* off/len bytes (host constructs the date) */
+    YEP_V_SEQ_OPEN,
+    YEP_V_MAP_OPEN,
+    YEP_V_CLOSE, /* closes the innermost open container */
+    YEP_V_ALIAS, /* off/len: the alias name */
+    /* decorates the entry that FOLLOWS it: the anchor name binds to
+     * that value (identity for aliases). Emitted only when anchored. */
+    YEP_V_ANCHOR, /* off/len: the name */
+} YeptrisValueKind;
+
+/* 24 bytes, ABI-pinned. Every scalar carries its raw bytes (off/len)
+ * next to a typed payload; `p` holds the INT bits or the FLOAT bits
+ * (reinterpreted by kind — hosts unpack it as ONE 64-bit field, so
+ * the record costs 7 values, not 8). */
+typedef struct {
+    uint8_t kind;   /* YeptrisValueKind */
+    uint8_t tag_id; /* the resolver's verdict for this scalar */
+    uint8_t is_key; /* the entry lands in the inner map's key slot */
+    uint8_t b;      /* BOOL payload; implicit-plain flag otherwise */
+    uint32_t off;   /* STR/TIMESTAMP/ALIAS/anchor bytes */
+    uint32_t len;
+    uint64_t p; /* INT or FLOAT payload, by kind */
+} YeptrisValue;
+YEPTRIS_CT_ASSERT(sizeof(YeptrisValue) == 24);
+
+/* Parses `yaml` and drains the typed value stream. On success sets
+ * *vals / *count / *arena / *arena_len (both malloc'd; free with
+ * yeptris_value_free exactly once). Returns YEPTRIS_OK,
+ * YEPTRIS_ERROR_PARSE (details via yeptris_last_error), or
+ * YEPTRIS_ERROR_MEMORY / YEPTRIS_ERROR_ARG. */
+YEPTRIS_API YeptrisStatus yeptris_value_drain(const char* yaml, size_t len, YeptrisSchema schema,
+                                              YeptrisValue** vals, size_t* count, char** arena,
+                                              size_t* arena_len);
+
+YEPTRIS_API void yeptris_value_free(YeptrisValue* vals, char* arena);
+
+/* Columnar projection of the same stream (task #42: the materializer
+ * wall is per-record struct decoding in FFI hosts — parallel typed
+ * buffers let bindings iterate C-speed arrays and unpack whole
+ * columns in one call). Same walk, same semantics, same arena; one
+ * carved allocation holds payloads/offs/lens/kinds/tags/is_keys/bools
+ * (payloads is the block base — yeptris_value_free_columns frees it
+ * and the arena; both are safe on a zero-entry drain). */
+typedef struct {
+    size_t count;
+    size_t arena_len;
+    int64_t* payloads; /* INT or FLOAT bits, by kind */
+    uint32_t* offs;    /* STR/TIMESTAMP/ALIAS/ANCHOR bytes */
+    uint32_t* lens;
+    uint8_t* kinds; /* YeptrisValueKind */
+    uint8_t* tags;  /* resolver verdict per scalar */
+    uint8_t* is_keys;
+    uint8_t* bools; /* BOOL payload; implicit-plain flag otherwise */
+    char* arena;
+} YeptrisValueColumns;
+
+YEPTRIS_API YeptrisStatus yeptris_value_drain_columns(const char* yaml, size_t len,
+                                                      YeptrisSchema schema,
+                                                      YeptrisValueColumns* cols);
+
+YEPTRIS_API void yeptris_value_free_columns(YeptrisValueColumns* cols);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VALUES_H */

data/vendor/libyeptris/src/include/yeptris/version.h.in

@@ -0,0 +1,29 @@
+/* version.h — generated from the CMake project VERSION.
+ *
+ * CMakeLists.txt project(yeptris VERSION ...) is the single source of truth;
+ * scripts/bump-version.sh syncs vcpkg.json and CHANGELOG.md from it. Never
+ * hand-edit the generated file (it lives in the build tree).
+ */
+#ifndef YEPTRIS_VERSION_H
+#define YEPTRIS_VERSION_H
+
+#include <yeptris/api.h>
+
+#define YEPTRIS_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define YEPTRIS_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define YEPTRIS_VERSION_PATCH @PROJECT_VERSION_PATCH@
+#define YEPTRIS_VERSION_STRING "@PROJECT_VERSION@"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Returns the library version string ("major.minor.patch").
+ * Memory: static storage; valid for the lifetime of the process. */
+YEPTRIS_API const char* yeptris_version(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VERSION_H */

data/vendor/libyeptris/src/include/yeptris/visit.h

@@ -0,0 +1,77 @@
+/* visit.h — language-agnostic value visitor (TODO.restructure/22/24).
+ *
+ * A push-style sink over the parsed value stream. Hosts that build
+ * native objects (Ruby C-API, CPython, etc.) implement the vtable and
+ * receive one callback per scalar/container — no intermediate records,
+ * no DOM, no host-side walk. The JSON entry is a fused RFC 8259 scan
+ * that never allocates a tree; the YAML entry rides the engine; the
+ * node entry walks an existing DOM subtree.
+ *
+ * OCP: a new host is a new vtable, never a core edit. MECE: scanning
+ * stays in scan/; this header is only the sink contract. */
+#ifndef YEPTRIS_VISIT_H
+#define YEPTRIS_VISIT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h>
+#include <yeptris/dom.h>
+#include <yeptris/error.h>
+#include <yeptris/resolve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Return 0 to continue, nonzero to abort (propagated as the status
+ * detail when non-zero; YEPTRIS_ERROR_INTERNAL is the library-side
+ * stand-in when the visitor doesn't set a more specific code). */
+typedef struct YeptrisVisitVTable {
+    int (*on_null)(void* ctx);
+    int (*on_bool)(void* ctx, int truthy);
+    int (*on_int)(void* ctx, int64_t v);
+    int (*on_float)(void* ctx, double v);
+    /* bytes are borrowed from the input (or a short-lived decode
+     * scratch for escaped JSON strings — valid only for the duration
+     * of the callback). */
+    int (*on_string)(void* ctx, const char* p, size_t len);
+    int (*on_seq_start)(void* ctx);
+    int (*on_seq_end)(void* ctx);
+    int (*on_map_start)(void* ctx);
+    /* A map key is always a string callback immediately followed by
+     * the value; hosts that need the key/value pairing push the key
+     * on on_string when is_key is set. */
+    int (*on_map_end)(void* ctx);
+    /* Optional: 1 when the next scalar/container is a map key. NULL
+     * means the visitor does not distinguish (JSON keys are always
+     * strings fired via on_string before their value). */
+    int (*on_key)(void* ctx, const char* p, size_t len);
+    /* Optional document boundary (YAML multi-doc). NULL = ignore. */
+    int (*on_doc)(void* ctx);
+    /* Optional anchor/alias. NULL = materializer does not support
+     * identity (JSON never fires these). */
+    int (*on_anchor)(void* ctx, const char* name, size_t len);
+    int (*on_alias)(void* ctx, const char* name, size_t len);
+} YeptrisVisitVTable;
+
+/* Fused strict-JSON scan → visit. No DOM, no records. On success the
+ * visitor saw exactly one value (plus optional ws). */
+YEPTRIS_API YeptrisStatus yeptris_visit_json(const char* data, size_t len,
+                                             const YeptrisVisitVTable* vt, void* ctx);
+
+/* YAML parse → visit through the engine (schema selects the resolver).
+ * Multi-doc streams fire on_doc before each document's root value. */
+YEPTRIS_API YeptrisStatus yeptris_visit(const char* data, size_t len, YeptrisSchema schema,
+                                        const YeptrisVisitVTable* vt, void* ctx);
+
+/* Existing DOM subtree → visit (Node#to_ruby bulk path without
+ * records/Marshal). */
+YEPTRIS_API YeptrisStatus yeptris_visit_node(YeptrisNode node, const YeptrisVisitVTable* vt,
+                                             void* ctx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_VISIT_H */

data/vendor/libyeptris/src/include/yeptris/yajl_compat.h

@@ -0,0 +1,135 @@
+/* yajl_compat.h — the yajl generator migration layer (TODO.impl/21).
+ *
+ * REAL yajl_gen symbol names over the yeptris core: users link
+ * -lyeptris-yajl instead of -lyajl and change nothing else. The
+ * generator validates call order (yajl's own state machine) and
+ * builds a Yeptris document; get_buf serializes JSON (beautify
+ * selects the pretty writer, default compact).
+ *
+ * v2 scope: the generator (yajl_gen_*) and the SAX parser
+ * (yajl_alloc/yajl_parse/...). The parser accumulates yajl_parse
+ * feeds and delivers all callbacks at yajl_complete_parse (the core
+ * parses whole documents; timing is batched, order and content are
+ * yajl's). Strict RFC 8259 always; yajl_allow_comments masks
+ * JavaScript comments (block star-slash, line double-slash) outside
+ * strings before the strict parse — offsets preserved, yajl's exact
+ * semantics. Unsupported options (trailing garbage / multiple
+ * values / partial values) are rejected at yajl_config time: zero,
+ * per yajl's own error contract.
+ */
+#ifndef YEPTRIS_YAJL_COMPAT_H
+#define YEPTRIS_YAJL_COMPAT_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    yajl_gen_status_ok = 0,
+    yajl_gen_keys_must_be_strings, /* 1 */
+    yajl_max_depth_exceeded,       /* unused: depth-guarded builder */
+    yajl_gen_in_error_state = 3,
+    yajl_gen_generation_complete, /* 4: gen after get_buf without clear */
+    yajl_gen_invalid_string = 5   /* NULL bytes with len 0 handled; reserved */
+} yajl_gen_status;
+
+typedef enum {
+    yajl_gen_beautify = 1,      /* int: pretty output */
+    yajl_gen_indent_string = 2, /* const char*: reserved (fixed 2-space) */
+    yajl_gen_validate_utf8 = 3  /* int: always on (the front-end validates) */
+} yajl_gen_option;
+
+typedef struct yajl_gen_t* yajl_gen;
+typedef struct yajl_alloc_funcs_t yajl_alloc_funcs;
+
+/* NULL alloc (the yajl default) uses the system allocator. */
+yajl_gen yajl_gen_alloc(const yajl_alloc_funcs* afs);
+void yajl_gen_free(yajl_gen g);
+void yajl_gen_reset(yajl_gen g, const char* sep_ignored);
+
+/* var-args: (yajl_gen_beautify, int). Returns 1 on success. */
+int yajl_gen_config(yajl_gen g, yajl_gen_option opt, ...);
+
+yajl_gen_status yajl_gen_map_open(yajl_gen g);
+yajl_gen_status yajl_gen_map_close(yajl_gen g);
+yajl_gen_status yajl_gen_array_open(yajl_gen g);
+yajl_gen_status yajl_gen_array_close(yajl_gen g);
+
+/* In a map, the first call per entry is the KEY: it must be a
+ * string (yajl accepts raw bytes; keys serialize JSON-quoted). */
+yajl_gen_status yajl_gen_string(yajl_gen g, const unsigned char* str, size_t len);
+yajl_gen_status yajl_gen_integer(yajl_gen g, long long n);
+yajl_gen_status yajl_gen_double(yajl_gen g, double d);
+yajl_gen_status yajl_gen_number(yajl_gen g, const char* s, size_t len);
+yajl_gen_status yajl_gen_null(yajl_gen g);
+yajl_gen_status yajl_gen_bool(yajl_gen g, int b);
+
+/* The serialized document (owned by the generator; valid until the
+ * next generating call or reset). Empty until the ROOT closes. */
+const unsigned char* yajl_gen_get_buf(yajl_gen g, size_t* len);
+void yajl_gen_clear(yajl_gen g);
+
+/* ---- SAX parser ------------------------------------------------------- */
+
+typedef enum { yajl_status_ok = 0, yajl_status_client_canceled, yajl_status_error } yajl_status;
+
+const char* yajl_status_to_string(yajl_status code);
+
+/* Zero return from a callback cancels the parse
+ * (yajl_status_client_canceled). When yajl_number is set it carries
+ * EVERY number in string form; yajl_integer/yajl_double are then
+ * ignored (yajl's own precedence). */
+typedef struct {
+    int (*yajl_null)(void* ctx);
+    int (*yajl_boolean)(void* ctx, int boolVal);
+    int (*yajl_integer)(void* ctx, long long integerVal);
+    int (*yajl_double)(void* ctx, double doubleVal);
+    int (*yajl_number)(void* ctx, const char* numberVal, size_t numberLen);
+    int (*yajl_string)(void* ctx, const unsigned char* stringVal, size_t stringLen);
+    int (*yajl_start_map)(void* ctx);
+    int (*yajl_map_key)(void* ctx, const unsigned char* key, size_t stringLen);
+    int (*yajl_end_map)(void* ctx);
+    int (*yajl_start_array)(void* ctx);
+    int (*yajl_end_array)(void* ctx);
+} yajl_callbacks;
+
+typedef enum {
+    yajl_allow_comments = 0x01,        /* JS comments masked, offsets kept */
+    yajl_dont_validate_strings = 0x02, /* accepted no-op: always on */
+    yajl_allow_trailing_garbage = 0x04,
+    yajl_allow_multiple_values = 0x08,
+    yajl_allow_partial_values = 0x10
+} yajl_option;
+
+typedef struct yajl_handle_t* yajl_handle;
+
+/* callbacks may be NULL (pure validation). afs accepted, ignored. */
+yajl_handle yajl_alloc(const yajl_callbacks* callbacks, yajl_alloc_funcs* afs, void* ctx);
+void yajl_free(yajl_handle handle);
+
+/* var-args int option: 1 on, 0 off. Returns 0 on unknown/unsupported
+ * options (trailing garbage / multiple values / partial values). */
+int yajl_config(yajl_handle h, yajl_option opt, ...);
+
+/* Accumulates feeds; callbacks fire at complete_parse. After an
+ * error or cancel the handle stays in that state. */
+yajl_status yajl_parse(yajl_handle hand, const unsigned char* jsonText, size_t jsonTextLength);
+yajl_status yajl_complete_parse(yajl_handle hand);
+
+/* Malloc'd message (free with yajl_free_error); NULL when no error.
+ * verbose adds the offending line and a caret. */
+unsigned char* yajl_get_error(yajl_handle hand, int verbose, const unsigned char* jsonText,
+                              size_t jsonTextLength);
+void yajl_free_error(yajl_handle hand, unsigned char* str);
+
+/* Bytes consumed: the whole input once complete; on error, the
+ * offset of the violation. */
+size_t yajl_get_bytes_consumed(yajl_handle hand);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_YAJL_COMPAT_H */

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

@@ -0,0 +1,23 @@
+/* yeptris.h — umbrella header for libyeptris.
+ *
+ * Ultra-fast YAML 1.2 parser, emitter and streamer in C; the YAML
+ * counterpart of libleptris. Subsystem headers grow with their items
+ * (TODO.impl/01-20); this file only includes the public surface.
+ */
+#ifndef YEPTRIS_H
+#define YEPTRIS_H
+
+#include <yeptris/api.h>
+#include <yeptris/dom.h>
+#include <yeptris/emit.h>
+#include <yeptris/error.h>
+#ifdef YEPTRIS_WITH_CBOR
+#include <yeptris/cbor.h>
+#endif
+#include <yeptris/events.h>
+#include <yeptris/parse.h>
+#include <yeptris/resolve.h>
+#include <yeptris/types.h>
+#include <yeptris/version.h>
+
+#endif /* YEPTRIS_H */