yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/cbor/sink.h

@@ -0,0 +1,58 @@
+/* sink.h — the CBOR decode seam (#157).
+ *
+ * The grammar loop (decode.c's cbor_item machinery) is the single
+ * source of CBOR semantics; a sink implements the item constructors
+ * on top of it. Two sinks exist: the DOM builder (the default, the
+ * yeptris_cbor_decode public path) and the native ext's VALUE builder
+ * (one pass, no intermediate). Sinks receive the resolver's tag_id
+ * and the pending semantic-tag chain in its text form ("N N N",
+ * outermost first — NULL when the item carries no chain).
+ */
+#ifndef YEP_CBOR_SINK_H
+#define YEP_CBOR_SINK_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <yeptris/api.h> /* YEPTRIS_API (the ext links these) */
+
+typedef struct yep_cbor_sink {
+    void* ctx;
+    /* All callbacks return 0 on sink failure (the decoder reports
+     * MEMORY). They may raise through host languages (longjmp): the
+     * decoder owns no host-managed state across them except the
+     * indefinite buffer, which its own exit paths free. */
+    /* is_key: 1 = the item lands in the enclosing map's key slot
+     * (sinks key-intern strings; the DOM ignores it). Rendered text:
+     * numbers-as-text, false/true/null/undefined, simple(N) — the
+     * exact bytes the DOM path stores. */
+    int (*text)(void* ctx, const char* s, uint32_t n, uint8_t tag_id, int is_key, const char* tag,
+                uint32_t tag_len);
+    /* Known integers: value = negative ? -(mag) : mag, mag <= 2^63. */
+    int (*int_val)(void* ctx, int negative, uint64_t mag, int is_key, const char* tag,
+                   uint32_t tag_len);
+    int (*float_val)(void* ctx, double dv, int is_key, const char* tag, uint32_t tag_len);
+    /* Strings. borrowed: 1 = p is the input (a sink may record the
+     * offset), 0 = the decoder's scratch buffer (copy or take it). */
+    int (*str_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                   const char* tag, uint32_t tag_len);
+    int (*bytes_val)(void* ctx, const unsigned char* p, uint32_t n, int borrowed, int is_key,
+                     const char* tag, uint32_t tag_len);
+    /* Containers. cap: expected item count (maps: pairs*2), UINT64_MAX
+     * for indefinite. close fires for BOTH the definite-complete and
+     * the break paths, after the last child. */
+    int (*open)(void* ctx, int is_map, uint64_t cap, const char* tag, uint32_t tag_len);
+    int (*close)(void* ctx, int is_map);
+} yep_cbor_sink;
+
+/* The generic engine: the grammar, driving `sink`. Same reject/
+ * encoding/depth semantics as the DOM entry. */
+YEPTRIS_API int yep_cbor_decode_gen(const unsigned char* p, size_t len, int strict,
+                                    size_t* consumed, const yep_cbor_sink* sink);
+
+/* The DOM sink: pairs yep_cbor_decode_gen with a yep_dom* (the
+ * yep_cbor_decode_dom public path's driver; d is a yep_dom*). */
+YEPTRIS_API int yep_cbor_decode_dom_sink(void* d, const unsigned char* p, size_t len, int strict,
+                                         size_t* consumed);
+
+#endif /* YEP_CBOR_SINK_H */

data/vendor/libyeptris/src/yeptris/common/chartype.c

@@ -0,0 +1,41 @@
+/* chartype.c — the 256-entry byte classification table.
+ *
+ * Row macros (class combos actually used); the golden test
+ * (test/unit/test_chartype.cpp) re-derives every entry from the spec
+ * productions, so a typo here fails the suite.
+ */
+
+#include "chartype.h"
+
+#define Z 0
+#define BT (YEP_CT_TAB | YEP_CT_BLANK | YEP_CT_PRINTABLE)
+#define BL (YEP_CT_LF | YEP_CT_LBREAK | YEP_CT_PRINTABLE)
+#define BC (YEP_CT_CR | YEP_CT_LBREAK | YEP_CT_PRINTABLE)
+#define BS (YEP_CT_SPACE | YEP_CT_BLANK | YEP_CT_PRINTABLE)
+#define BI (YEP_CT_INDICATOR | YEP_CT_PRINTABLE)
+#define BF (YEP_CT_FLOW_IND | YEP_CT_INDICATOR | YEP_CT_PRINTABLE)
+#define BP (YEP_CT_PRINTABLE)
+#define BD (YEP_CT_DIGIT | YEP_CT_HEXDIGIT | YEP_CT_PRINTABLE)
+#define BA (YEP_CT_ALPHA | YEP_CT_PRINTABLE)
+#define BX (YEP_CT_ALPHA | YEP_CT_HEXDIGIT | YEP_CT_PRINTABLE)
+#define BH (YEP_CT_HIGH)
+
+const uint16_t yep_chartype_table[256] = {
+    /*        0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F */
+    /* 0x00 */ Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  BT, BL, Z,  Z,  BC, Z,  Z,
+    /* 0x10 */ Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,  Z,
+    /* 0x20 */ BS, BI, BI, BI, BP, BI, BI, BI, BP, BP, BI, BP, BF, BI, BP, BP,
+    /* 0x30 */ BD, BD, BD, BD, BD, BD, BD, BD, BD, BD, BI, BP, BP, BP, BI, BI,
+    /* 0x40 */ BI, BX, BX, BX, BX, BX, BX, BA, BA, BA, BA, BA, BA, BA, BA, BA,
+    /* 0x50 */ BA, BA, BA, BA, BA, BA, BA, BA, BA, BA, BA, BF, BP, BF, BP, BP,
+    /* 0x60 */ BI, BX, BX, BX, BX, BX, BX, BA, BA, BA, BA, BA, BA, BA, BA, BA,
+    /* 0x70 */ BA, BA, BA, BA, BA, BA, BA, BA, BA, BA, BA, BF, BI, BF, BP, Z,
+    /* 0x80 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0x90 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0xA0 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0xB0 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0xC0 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0xD0 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0xE0 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+    /* 0xF0 */ BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH, BH,
+};

data/vendor/libyeptris/src/yeptris/common/chartype.h

@@ -0,0 +1,77 @@
+/* chartype.h — THE byte classification truth table (MECE law: chartype
+ * answers "what class of byte is this" and nothing else; scan (06) answers
+ * "where structures start"; the SIMD kernels (04) implement these same
+ * classes with vector compares, proven equivalent by differential tests).
+ *
+ * Byte-level approximation of the YAML character productions:
+ *  - Printability is decided per byte for ASCII (tab/LF/CR/0x20-0x7E are
+ *    printable, C0 controls and DEL are not). Bytes >= 0x80 carry HIGH;
+ *    their printability is decided by the encoding front-end (05), which
+ *    validates the whole sequence.
+ *  - YAML's Unicode line breaks (NEL U+0085, LS U+2028, PS U+2029) are
+ *    multi-byte; they are recognized by the scan layer, not by this table.
+ *  - c-indicator set (YAML 1.2 spec, 5.5): - ? : , [ ] { } # & * ! | >
+ *    ' " % @ `  — of these, `, [ ] { }` are flow indicators.
+ *
+ * Derived classes are inline helpers, not table bits: ns-char is
+ * printable-and-not-whitespace (plus HIGH, pending encoding validation).
+ */
+#ifndef YEP_CHARTYPE_H
+#define YEP_CHARTYPE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    YEP_CT_SPACE = 1u << 0,
+    YEP_CT_TAB = 1u << 1,
+    YEP_CT_LF = 1u << 2,
+    YEP_CT_CR = 1u << 3,
+    YEP_CT_DIGIT = 1u << 4,
+    YEP_CT_ALPHA = 1u << 5,
+    YEP_CT_HEXDIGIT = 1u << 6,
+    YEP_CT_INDICATOR = 1u << 7, /* the 19-byte c-indicator set */
+    YEP_CT_FLOW_IND = 1u << 8,  /* , [ ] { } */
+    YEP_CT_HIGH = 1u << 9,      /* >= 0x80: UTF-8 sequence byte */
+
+    /* Composite (stored pre-computed in the table). */
+    YEP_CT_BLANK = YEP_CT_SPACE | YEP_CT_TAB,
+    YEP_CT_LBREAK = YEP_CT_LF | YEP_CT_CR,
+    YEP_CT_PRINTABLE = 1u << 10, /* byte-level: tab|LF|CR|0x20..0x7E */
+};
+
+/* The 256-entry truth table (const, rodata). */
+extern const uint16_t yep_chartype_table[256];
+
+static inline uint16_t yep_ct(unsigned char c) {
+    return yep_chartype_table[c];
+}
+
+/* True when ALL of flags are set on c. */
+static inline bool yep_ct_is(unsigned char c, uint16_t flags) {
+    return (yep_chartype_table[c] & flags) == flags;
+}
+
+static inline bool yep_ct_any(unsigned char c, uint16_t flags) {
+    return (yep_chartype_table[c] & flags) != 0;
+}
+
+/* ns-char approximation: printable and not whitespace; high bytes defer to
+ * the encoding layer. */
+static inline bool yep_ct_is_ns(unsigned char c) {
+    uint16_t t = yep_chartype_table[c];
+    if (t & YEP_CT_HIGH) {
+        return true;
+    }
+    return (t & YEP_CT_PRINTABLE) != 0 && (t & (YEP_CT_BLANK | YEP_CT_LBREAK)) == 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_CHARTYPE_H */

data/vendor/libyeptris/src/yeptris/common/cpu.c

@@ -0,0 +1,81 @@
+/* cpu.c — feature detection via compiler builtins (no inline asm, no
+ * platform headers). SSE2 is architectural on x86-64; NEON on AArch64.
+ * Advanced flags come from __builtin_cpu_supports where available.
+ */
+
+#include <stdatomic.h>
+
+#include "cpu.h"
+
+#if defined(__x86_64__) || defined(__i386__)
+#define YEP_X86 1
+#endif
+
+#if defined(__aarch64__) || defined(__ARM_NEON)
+#define YEP_ARM_NEON_OK 1
+#endif
+
+/* Raw CPUID (TODO.restructure/82): __builtin_cpu_supports returned 0
+ * for AVX/AVX2 on real CI Xeons (the bench artifact's kernels line
+ * said scalar(sse2) — the whole kernel campaign had never run there).
+ * The builtins depend on the runtime's __cpu_model initialization;
+ * cpuid has no such dependency. <cpuid.h> intrinsics need no -m
+ * flags; xgetbv is raw asm behind the OSXSAVE gate. */
+#if defined(YEP_X86) && (defined(__GNUC__) || defined(__clang__))
+#include <cpuid.h>
+
+static uint64_t yep_xgetbv0(void) {
+    uint32_t lo, hi;
+    __asm__ volatile("xgetbv" : "=a"(lo), "=d"(hi) : "c"(0));
+    return ((uint64_t)hi << 32) | lo;
+}
+#endif
+
+static yep_cpu_features yep_cpu_compute(void) {
+    yep_cpu_features f = {0};
+
+#if defined(YEP_X86)
+    f.sse2 = 1; /* architectural on x86-64 */
+#if defined(__GNUC__) || defined(__clang__)
+    {
+        uint32_t a, b, c, d;
+        if (__get_cpuid(1, &a, &b, &c, &d)) {
+            f.sse3 = (c & (1u << 0)) != 0;
+            f.ssse3 = (c & (1u << 9)) != 0;
+            f.sse41 = (c & (1u << 19)) != 0;
+            f.popcnt = (c & (1u << 23)) != 0;
+            int osxsave = (c & (1u << 27)) != 0;
+            int cpu_avx = (c & (1u << 28)) != 0;
+            if (osxsave && cpu_avx && (yep_xgetbv0() & 0x6u) == 0x6u) {
+                f.avx = 1;
+            }
+        }
+        uint32_t a7, b7, c7, d7;
+        if (__get_cpuid_count(7, 0, &a7, &b7, &c7, &d7)) {
+            f.bmi1 = (b7 & (1u << 3)) != 0;
+            f.bmi2 = (b7 & (1u << 8)) != 0;
+            f.avx2 = f.avx && (b7 & (1u << 5)) != 0;
+        }
+    }
+#endif
+#elif defined(YEP_ARM_NEON_OK)
+    f.neon = 1;
+#if defined(__ARM_FEATURE_CRC32)
+    f.crc32 = 1;
+#endif
+#endif
+
+    return f;
+}
+
+static _Atomic yep_cpu_features yep_cpu_cached;
+
+yep_cpu_features yep_cpu_detect(void) {
+    yep_cpu_features f = atomic_load_explicit(&yep_cpu_cached, memory_order_acquire);
+    if (!f.detected) {
+        f = yep_cpu_compute();
+        f.detected = 1;
+        atomic_store_explicit(&yep_cpu_cached, f, memory_order_release);
+    }
+    return f;
+}

data/vendor/libyeptris/src/yeptris/common/cpu.h

@@ -0,0 +1,40 @@
+/* cpu.h — CPU feature facts for the SIMD dispatch table (TODO.impl/04).
+ *
+ * Detection is atomic-lazy: the first caller computes, later callers read.
+ * Concurrent first calls are benign — every writer stores identical bytes
+ * through atomic stores, so there is no data race under the C11 memory
+ * model (and none reported by TSAN).
+ */
+#ifndef YEP_CPU_H
+#define YEP_CPU_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct yep_cpu_features {
+    uint16_t sse2 : 1;
+    uint16_t sse3 : 1;
+    uint16_t ssse3 : 1;
+    uint16_t sse41 : 1;
+    uint16_t popcnt : 1;
+    uint16_t avx : 1;
+    uint16_t avx2 : 1;
+    uint16_t bmi1 : 1;
+    uint16_t bmi2 : 1;
+    uint16_t neon : 1;
+    uint16_t crc32 : 1;
+    uint16_t detected : 1; /* internal: set once computed */
+} yep_cpu_features;
+
+/* Returns the feature snapshot (computing it on first use). */
+yep_cpu_features yep_cpu_detect(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_CPU_H */

data/vendor/libyeptris/src/yeptris/common/error.c

@@ -0,0 +1,65 @@
+/* error.c — error channel implementation. printf-composition happens here,
+ * once, at error-creation time; nothing on any hot path formats strings.
+ */
+
+#include <stdio.h>
+
+#include "error.h"
+
+const char* yep_error_string(yep_err_code code) {
+    switch (code) {
+#define YEP_ERROR_CASE(code, str)                                                                  \
+    case code:                                                                                     \
+        return str;
+        YEP_ERROR_X(YEP_ERROR_CASE)
+#undef YEP_ERROR_CASE
+    default:
+        return "unknown error code";
+    }
+}
+
+void yep_error_clear(yep_error* slot) {
+    if (slot == NULL) {
+        return;
+    }
+    slot->code = YEP_ERR_NONE;
+    slot->line = 0;
+    slot->col = 0;
+    slot->offset = 0;
+    slot->msg[0] = '\0';
+}
+
+int yep_error_is_none(const yep_error* slot) {
+    return slot == NULL || slot->code == YEP_ERR_NONE;
+}
+
+static void yep_error_vset(yep_error* slot, yep_err_code code, uint32_t line, uint32_t col,
+                           size_t offset, const char* fmt, va_list ap) {
+    slot->code = code;
+    slot->line = line;
+    slot->col = col;
+    slot->offset = offset;
+    if (fmt == NULL) {
+        snprintf(slot->msg, sizeof(slot->msg), "%s", yep_error_string(code));
+        return;
+    }
+    vsnprintf(slot->msg, sizeof(slot->msg), fmt, ap);
+}
+
+int yep_error_set(yep_error* slot, yep_err_code code, uint32_t line, uint32_t col, size_t offset,
+                  const char* fmt, ...) {
+    if (slot == NULL) {
+        return 0;
+    }
+    va_list ap;
+    va_start(ap, fmt);
+    yep_error_vset(slot, code, line, col, offset, fmt, ap);
+    va_end(ap);
+    return 0;
+}
+
+static _Thread_local yep_error yep_tls_error = {YEP_ERR_NONE, 0, 0, 0, ""};
+
+yep_error* yep_error_tls(void) {
+    return &yep_tls_error;
+}

data/vendor/libyeptris/src/yeptris/common/error.h

@@ -0,0 +1,79 @@
+/* error.h — the internal error channel.
+ *
+ * Codes and their strings are declared together in one X-macro — adding a
+ * code is one line (OCP). Public API entry points map these to the pinned
+ * YeptrisStatus codes (public error.h); this channel carries the detail:
+ * code + line/column/offset + composed message.
+ *
+ * Two channels (the libleptris contract):
+ *  - thread-local slot: yep_error_tls() — most recent failure on the
+ *    calling thread;
+ *  - per-document slot: any yep_error* the owner (document, 11) embeds.
+ */
+#ifndef YEP_ERROR_H
+#define YEP_ERROR_H
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#include "port.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define YEP_ERROR_X(X)                                                                             \
+    X(YEP_ERR_NONE, "no error")                                                                    \
+    X(YEP_ERR_UNEXPECTED, "unexpected parser state")                                               \
+    X(YEP_ERR_MEMORY, "out of memory")                                                             \
+    X(YEP_ERR_DEPTH, "nesting depth exceeds the limit")                                            \
+    X(YEP_ERR_ENCODING, "ill-formed or unsupported character encoding")                            \
+    X(YEP_ERR_TAB_IN_INDENT, "tab character used as indentation")                                  \
+    X(YEP_ERR_UNTERMINATED_QUOTE, "unterminated quoted scalar")                                    \
+    X(YEP_ERR_BAD_INDENT, "inconsistent indentation")                                              \
+    X(YEP_ERR_KEY_TOO_LONG, "simple key exceeds 1024 characters")                                  \
+    X(YEP_ERR_UNDEFINED_ALIAS, "alias references an undefined anchor")                             \
+    X(YEP_ERR_INVALID_ESCAPE, "invalid escape sequence in double-quoted scalar")                   \
+    X(YEP_ERR_BAD_DIRECTIVE, "invalid or unsupported directive")                                   \
+    X(YEP_ERR_INTERNAL, "internal invariant violation")                                            \
+    X(YEP_ERR_SCHEMA, "required descriptor node missing")
+
+typedef enum {
+#define YEP_ERROR_ENUM(code, str) code,
+    YEP_ERROR_X(YEP_ERROR_ENUM)
+#undef YEP_ERROR_ENUM
+        YEP_ERR_CODE_COUNT
+} yep_err_code;
+
+#define YEP_ERROR_MSG_MAX 192
+
+typedef struct yep_error {
+    yep_err_code code;
+    uint32_t line; /* 1-based; 0 = unknown */
+    uint32_t col;  /* 1-based; 0 = unknown */
+    size_t offset; /* byte offset in the input */
+    char msg[YEP_ERROR_MSG_MAX];
+} yep_error;
+
+/* The string for a code (X-macro table; never NULL). */
+const char* yep_error_string(yep_err_code code);
+
+/* Clears a slot to the no-error state. */
+void yep_error_clear(yep_error* slot);
+
+/* True when the slot holds no error. */
+int yep_error_is_none(const yep_error* slot);
+
+/* Sets slot (printf-style message, truncated to fit). Returns 0 so callers
+ * can `return yep_error_set(...)` where convenient. */
+int yep_error_set(yep_error* slot, yep_err_code code, uint32_t line, uint32_t col, size_t offset,
+                  const char* fmt, ...);
+
+/* The thread-local slot (one per thread; no cross-talk by construction). */
+yep_error* yep_error_tls(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_ERROR_H */

data/vendor/libyeptris/src/yeptris/common/mutex.h

@@ -0,0 +1,45 @@
+/* mutex.h — the one lock shape for internal short-critical-section
+ * mutexes (dom pool, mapindex). pthread on POSIX; SRWLOCK on Windows
+ * (no trylock consumer exists — SRWLOCK's shape is a superset of what
+ * we use: init/destroy/lock/unlock).
+ *
+ * Naming law: internal symbols are yep_*. */
+#ifndef YEP_MUTEX_H
+#define YEP_MUTEX_H
+
+#include "port.h"
+
+static inline int yep_mutex_init(yep_mutex_raw* m) {
+#if defined(_WIN32)
+    InitializeSRWLock(m);
+    return 0;
+#else
+    return pthread_mutex_init(m, NULL);
+#endif
+}
+
+static inline void yep_mutex_destroy(yep_mutex_raw* m) {
+#if !defined(_WIN32)
+    pthread_mutex_destroy(m);
+#else
+    (void)m; /* SRWLOCK needs no destroy */
+#endif
+}
+
+static inline void yep_mutex_lock(yep_mutex_raw* m) {
+#if defined(_WIN32)
+    AcquireSRWLockExclusive(m);
+#else
+    pthread_mutex_lock(m);
+#endif
+}
+
+static inline void yep_mutex_unlock(yep_mutex_raw* m) {
+#if defined(_WIN32)
+    ReleaseSRWLockExclusive(m);
+#else
+    pthread_mutex_unlock(m);
+#endif
+}
+
+#endif /* YEP_MUTEX_H */