yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/resolve/compat11.c

@@ -0,0 +1,334 @@
+/* compat11.c — libyaml/Psych 1.1 implicit semantics (TODO.impl/10).
+ *
+ * The oracle is psych's scalar_scanner.rb; every divergence is a
+ * compat bug (15's ported tests enforce it):
+ *   bool: y/Y/yes/on/true/n/N/no/off/false, any case pattern psych
+ *     matches (/^(yes|true|on)$/i family)
+ *   int: decimal with _, 0b binary, leading-0 octal, 0x hex
+ *   float: psych FLOAT + sexagesimal ints/floats + .inf/.nan
+ *   timestamp: the yaml.org timestamp production (plus plain dates)
+ *   '=' is the value tag; '<<' is merge (grammar-level anyway)
+ * else str.
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "resolver.h"
+
+static int eq(const char* p, uint32_t n, const char* s) {
+    uint32_t m = 0;
+    while (s[m] != '\0') {
+        m++;
+    }
+    return n == m && (n == 0 || memcmp(p, s, n) == 0);
+}
+
+static int ci_eq3(const char* p, uint32_t n, const char* s) {
+    /* case-insensitive match (psych's /i booleans) */
+    uint32_t m = 0;
+    while (s[m] != '\0') {
+        m++;
+    }
+    if (n != m) {
+        return 0;
+    }
+    for (uint32_t k = 0; k < n; k++) {
+        char a = p[k], b = s[k];
+        if (a >= 'A' && a <= 'Z') {
+            a = (char)(a - 'A' + 'a');
+        }
+        if (b >= 'A' && b <= 'Z') {
+            b = (char)(b - 'A' + 'a');
+        }
+        if (a != b) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int is_digits_us(const char* p, uint32_t n) {
+    if (n == 0) {
+        return 0;
+    }
+    for (uint32_t k = 0; k < n; k++) {
+        if (!((p[k] >= '0' && p[k] <= '9') || p[k] == '_')) {
+            return 0;
+        }
+    }
+    return p[0] != '_';
+}
+
+static yep_tag_id compat11(void* ctx, const char* p, uint32_t n) {
+    (void)ctx;
+    if (n == 0 || eq(p, n, "~") || ci_eq3(p, n, "null")) {
+        return 4; /* null: psych nil for ""/"~"/null (any case) */
+    }
+    if (ci_eq3(p, n, "yes") || ci_eq3(p, n, "true") || ci_eq3(p, n, "on") || ci_eq3(p, n, "y")) {
+        return 3;
+    }
+    if (ci_eq3(p, n, "no") || ci_eq3(p, n, "false") || ci_eq3(p, n, "off") || ci_eq3(p, n, "n")) {
+        return 3;
+    }
+    if (eq(p, n, "=")) {
+        return 10; /* value */
+    }
+    if (eq(p, n, "<<")) {
+        return 9; /* merge */
+    }
+    uint32_t i = 0;
+    if (p[0] == '-' || p[0] == '+') {
+        i = 1;
+    }
+    if (i >= n) {
+        return 0;
+    }
+    /* timestamps: full production first (psych TIME), then plain dates */
+    {
+        /* -?dddd-dd-dd([Tt ]dd:dd:dd(.d*)?(Z|+dd(:dd)?|+d)?)? — the
+         * date-only form handled after; conservative core check */
+        uint32_t k = i;
+        int digs = 0;
+        while (k < n && p[k] >= '0' && p[k] <= '9' && digs < 4) {
+            k++;
+            digs++;
+        }
+        if (digs == 4 && k + 1 < n && p[k] == '-') {
+            k++;
+            int m1 = 0;
+            while (k < n && p[k] >= '0' && p[k] <= '9' && m1 < 2) {
+                k++;
+                m1++;
+            }
+            if (m1 >= 1 && k + 1 < n && p[k] == '-') {
+                k++;
+                int m2 = 0;
+                while (k < n && p[k] >= '0' && p[k] <= '9' && m2 < 2) {
+                    k++;
+                    m2++;
+                }
+                if (m2 >= 1) {
+                    if (k == n) {
+                        return 5; /* date */
+                    }
+                    if (p[k] == 'T' || p[k] == 't' || p[k] == ' ') {
+                        /* time part: dd:dd:dd required */
+                        k++; /* consume the separator */
+                        int ok = 1;
+                        int f[3] = {0, 0, 0};
+                        int fi = 0;
+                        int seen_colon = 0;
+                        while (k < n) {
+                            char c = p[k];
+                            if (c == ':') {
+                                if (f[fi] < 1 || f[fi] > 2 || fi >= 2) {
+                                    ok = 0;
+                                    break;
+                                }
+                                seen_colon = 1;
+                                fi++;
+                                k++;
+                                continue;
+                            }
+                            if (c >= '0' && c <= '9' && fi <= 2) {
+                                f[fi]++;
+                                if (f[fi] > 2) {
+                                    ok = 0;
+                                    break;
+                                }
+                                k++;
+                                continue;
+                            }
+                            break;
+                        }
+                        if (ok && seen_colon && fi == 2 && f[2] == 2) {
+                            /* optional .frac, Z or offset */
+                            if (k < n && p[k] == '.') {
+                                k++;
+                                int fd = 0;
+                                while (k < n && p[k] >= '0' && p[k] <= '9') {
+                                    k++;
+                                    fd++;
+                                }
+                                if (fd == 0) {
+                                    ok = 0;
+                                }
+                            }
+                            while (ok && k < n && p[k] == ' ') {
+                                k++; /* psych: \s* before the zone */
+                            }
+                            if (ok && k < n) {
+                                if (p[k] == 'Z') {
+                                    k++;
+                                } else if (p[k] == '+' || p[k] == '-') {
+                                    k++;
+                                    int od = 0;
+                                    while (k < n && ((p[k] >= '0' && p[k] <= '9') ||
+                                                     (od == 2 && p[k] == ':'))) {
+                                        if (p[k] == ':') {
+                                            if (od != 2) {
+                                                ok = 0;
+                                                break;
+                                            }
+                                        } else {
+                                            od++;
+                                        }
+                                        k++;
+                                    }
+                                    if (od < 1 || od > 4) {
+                                        ok = 0;
+                                    }
+                                } else {
+                                    ok = 0;
+                                }
+                            }
+                            if (ok && k == n) {
+                                return 5; /* timestamp */
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /* .inf/.nan (psych, with sign on inf) */
+    {
+        const char* r = p + i;
+        uint32_t rn = n - i;
+        if (rn > 1 && r[0] == '.') {
+            if (ci_eq3(r, rn, ".inf") || ci_eq3(r, rn, ".nan")) {
+                return 2;
+            }
+        }
+    }
+    /* sexagesimal: [-+]?d[d_]*(:[0-5]?d){1,2}(.d*)? */
+    {
+        uint32_t k = i;
+        if (k < n && p[k] >= '0' && p[k] <= '9') {
+            k++;
+            while (k < n && ((p[k] >= '0' && p[k] <= '9') || p[k] == '_')) {
+                k++;
+            }
+            if (k < n && p[k] == ':') {
+                int groups = 0;
+                int ok = 1;
+                int is_float = 0;
+                while (k < n && p[k] == ':') {
+                    k++;
+                    groups++;
+                    int d = 0;
+                    while (k < n && p[k] >= '0' && p[k] <= '9') {
+                        k++;
+                        d++;
+                    }
+                    if (d < 1 || d > 2 || groups > 2) {
+                        ok = 0;
+                        break;
+                    }
+                    if (d == 2 && p[k - 2] > '5') {
+                        ok = 0; /* [0-5]?d */
+                        break;
+                    }
+                }
+                if (ok && k < n && p[k] == '.') {
+                    is_float = 1;
+                    k++;
+                    while (k < n && ((p[k] >= '0' && p[k] <= '9') || p[k] == '_')) {
+                        k++;
+                    }
+                }
+                if (ok && k == n && groups >= 1) {
+                    return is_float ? 2 : 1;
+                }
+            }
+        }
+    }
+    /* 0b / 0x / leading-0 octal / decimal int with underscores */
+    if (n - i > 2 && p[i] == '0' && (p[i + 1] == 'b' || p[i + 1] == 'B')) {
+        return is_digits_us(p + i + 2, n - i - 2) ? 1 : 0;
+    }
+    if (n - i > 2 && p[i] == '0' && (p[i + 1] == 'x' || p[i + 1] == 'X')) {
+        uint32_t k = i + 2;
+        if (p[k] == '_') {
+            k++;
+        }
+        int d = 0;
+        for (; k < n; k++) {
+            char c = p[k];
+            if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ||
+                c == '_') {
+                if (c != '_') {
+                    d++;
+                }
+                continue;
+            }
+            return 0;
+        }
+        return d ? 1 : 0;
+    }
+    if (n - i >= 2 && p[i] == '0') {
+        /* leading-0 octal (psych: 0[_]*[0-7][0-7_]*) */
+        uint32_t k = i + 1;
+        while (k < n && p[k] == '_') {
+            k++;
+        }
+        int d = 0;
+        for (; k < n; k++) {
+            if (p[k] >= '0' && p[k] <= '7') {
+                d++;
+            } else if (p[k] == '_') {
+                continue;
+            } else {
+                break;
+            }
+        }
+        if (d && k == n) {
+            return 1;
+        }
+        if (d == 0 && k == n && p[n - 1] == '0') {
+            return 1; /* plain 0 */
+        }
+    }
+    /* decimal int / float with underscores and commas (psych legacy) */
+    {
+        int digits = 0, dot = 0, e = 0, ed = 0;
+        for (uint32_t k = i; k < n; k++) {
+            char c = p[k];
+            if (c >= '0' && c <= '9') {
+                if (e) {
+                    ed = 1;
+                } else {
+                    digits = 1;
+                }
+            } else if ((c == '_' || c == ',') && !e) {
+                /* separators */
+            } else if (c == '.' && !e) {
+                if (dot) {
+                    return 0;
+                }
+                dot = 1;
+            } else if ((c == 'e' || c == 'E') && digits && !e) {
+                e = 1;
+                if (k + 1 < n && (p[k + 1] == '-' || p[k + 1] == '+')) {
+                    k++;
+                }
+            } else {
+                return 0;
+            }
+        }
+        if (digits && (dot || e) && (!e || ed)) {
+            return 2;
+        }
+        if (digits && !dot && !e) {
+            return 1;
+        }
+    }
+    return 0; /* str */
+}
+
+static const yep_resolver k_compat11 = {compat11, NULL, NULL};
+
+const yep_resolver* yep_resolver_compat11(void) {
+    return &k_compat11;
+}

data/vendor/libyeptris/src/yeptris/resolve/core12.c

@@ -0,0 +1,143 @@
+/* core12.c — the YAML 1.2 core schema (TODO.impl/10).
+ *
+ * null: "", "~", "null", "Null", "NULL"
+ * bool: true/True/TRUE, false/False/FALSE
+ * int:  [-+]?[0-9]+ | [-+]?0o[0-7]+ | [-+]?0x[0-9a-fA-F]+
+ * float: core float production, [-+]?(\.inf|\.Inf|\.INF), \.nan/\.NaN/\.NAN
+ * else str
+ *
+ * Shape (TODO.restructure/71): the first-byte gate, then ONE branch —
+ * word lead letters do the null/true/false compares and return, digits
+ * and signs take the number walk. The old chain tried the word memcmps
+ * for every length-4/5 scalar before ruling (anchor-heavy: 42 cycles
+ * per call on gate-passing strings).
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#include "resolver.h"
+
+static yep_tag_id core12(void* ctx, const char* p, uint32_t n) {
+    (void)ctx;
+    if (n == 0) {
+        return 4; /* null */
+    }
+    unsigned char c0 = (unsigned char)p[0];
+    unsigned l0 = c0 | 0x20u;
+
+    /* The gate (profile: 6.5% of deep-nesting was the reject chain):
+     * a first byte that can begin no core production is a string. */
+    if (!((c0 >= '0' && c0 <= '9') || c0 == '-' || c0 == '+' || c0 == '.' || l0 == 'n' ||
+          l0 == 't' || l0 == 'f' || l0 == 'y' || c0 == '~')) {
+        return 0;
+    }
+
+    /* Word leads: the exact casings only; every other spelling (and
+     * every y-word — compat owns those) is a string, no walk. */
+    if (l0 == 'n' || l0 == 't' || l0 == 'f' || l0 == 'y') {
+        if (n == 4 && l0 == 'n') {
+            return (memcmp(p, "null", 4) == 0 || memcmp(p, "Null", 4) == 0 ||
+                    memcmp(p, "NULL", 4) == 0)
+                       ? 4
+                       : 0;
+        }
+        if (n == 4 && l0 == 't') {
+            return (memcmp(p, "true", 4) == 0 || memcmp(p, "True", 4) == 0 ||
+                    memcmp(p, "TRUE", 4) == 0)
+                       ? 3
+                       : 0;
+        }
+        if (n == 5 && l0 == 'f') {
+            return (memcmp(p, "false", 5) == 0 || memcmp(p, "False", 5) == 0 ||
+                    memcmp(p, "FALSE", 5) == 0)
+                       ? 3
+                       : 0;
+        }
+        return 0;
+    }
+    if (c0 == '~') {
+        return n == 1 ? 4 : 0;
+    }
+
+    /* Number path: optional sign, then the productions in frequency
+     * order (.inf/.nan, hex, octal, decimal int/float). */
+    uint32_t i = (c0 == '-' || c0 == '+') ? 1 : 0;
+    if (i >= n) {
+        return 0; /* lone sign */
+    }
+    {
+        const char* r = p + i;
+        uint32_t rn = n - i;
+        if (rn == 4 && r[0] == '.') {
+            if (memcmp(r, ".inf", 4) == 0 || memcmp(r, ".Inf", 4) == 0 ||
+                memcmp(r, ".INF", 4) == 0 ||
+                (i == 0 && (memcmp(r, ".nan", 4) == 0 || memcmp(r, ".NaN", 4) == 0 ||
+                            memcmp(r, ".NAN", 4) == 0))) {
+                return 2; /* float; NaN carries no sign */
+            }
+        }
+    }
+    if (n - i > 2 && p[i] == '0' && (p[i + 1] == 'x' || p[i + 1] == 'X')) {
+        for (uint32_t k = i + 2; k < n; k++) {
+            char c = p[k];
+            if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+                return 0;
+            }
+        }
+        return 1; /* int */
+    }
+    if (n - i > 2 && p[i] == '0' && p[i + 1] == 'o') {
+        for (uint32_t k = i + 2; k < n; k++) {
+            if (p[k] < '0' || p[k] > '7') {
+                return 0;
+            }
+        }
+        return 1; /* int */
+    }
+    int digits = 0, dot = 0, e = 0, edigits = 0;
+    for (uint32_t k = i; k < n; k++) {
+        char c = p[k];
+        if (c >= '0' && c <= '9') {
+            if (e) {
+                edigits = 1;
+            } else {
+                digits = 1;
+            }
+            continue;
+        }
+        if (c == '.' && !e) {
+            if (dot) {
+                return 0;
+            }
+            dot = 1;
+            continue;
+        }
+        if ((c == 'e' || c == 'E') && digits && !e) {
+            e = 1;
+            if (k + 1 < n && (p[k + 1] == '-' || p[k + 1] == '+')) {
+                k++;
+            }
+            continue;
+        }
+        return 0;
+    }
+    if (digits && (dot || e) && (!e || edigits)) {
+        return 2; /* float */
+    }
+    if (digits && !dot && !e) {
+        return 1; /* int */
+    }
+    return 0;
+}
+
+static yep_tag_id core12_number(void* ctx, int is_float) {
+    (void)ctx;
+    return is_float ? 2 : 1;
+}
+
+static const yep_resolver k_core12 = {core12, core12_number, NULL};
+
+const yep_resolver* yep_resolver_core12(void) {
+    return &k_core12;
+}

data/vendor/libyeptris/src/yeptris/resolve/resolver.h

@@ -0,0 +1,56 @@
+/* resolver.h — the internal resolver interface (TODO.impl/10).
+ *
+ * MECE: scan produces facts, the engine parses, the RESOLVER alone
+ * decides implicit typing. OCP: a new schema is a new resolver
+ * instance; no schema branches exist anywhere else.
+ */
+#ifndef YEP_RESOLVER_H
+#define YEP_RESOLVER_H
+
+#include <stdint.h>
+
+#include "common/string_view.h"
+
+/* yep_view: bytes + length, the one string representation (SSOT). */
+
+/* The tag-id space is the public YeptrisTagId (resolve.h); internal
+ * re-export for the table SSOT. */
+typedef uint8_t yep_tag_id;
+
+typedef struct yep_resolver {
+    /* Returns the implicit tag for a PLAIN, untagged scalar. */
+    yep_tag_id (*resolve)(void* ctx, const char* p, uint32_t len);
+    /* Optional fast path for spans a validator already classified as
+     * strict numbers (is_float: the text contains '.' or an exponent):
+     * skips the digit re-walk resolve() would pay. NULL = resolve(). */
+    yep_tag_id (*resolve_number)(void* ctx, int is_float);
+    void* ctx;
+} yep_resolver;
+
+/* Typing for a validated number span, through whichever hook the
+ * schema provides (the typing SSOT either way). */
+static inline yep_tag_id yep_resolve_number(const yep_resolver* r, int is_float) {
+    if (r->resolve_number != NULL) {
+        return r->resolve_number(NULL, is_float);
+    }
+    return is_float ? 2 /* float */ : 1 /* int */;
+}
+
+/* The two built-in resolvers (no ctx). */
+const yep_resolver* yep_resolver_core12(void);
+const yep_resolver* yep_resolver_compat11(void);
+
+/* core tag id <-> canonical URI (tags.c is the identity SSOT). */
+const char* yep_tag_uri(yep_tag_id id);
+
+/* Explicit-tag resolution: the tag URI a node carried maps to a core
+ * id when it matches one, else YEPTRIS_TAG_CUSTOM. */
+yep_tag_id yep_tag_from_uri(const char* p, uint32_t len);
+
+/* Canonical word for a resolved float view: ".inf" / "-.inf" / ".nan"
+ * or NULL when the view is not an infinity/nan word (the canonical
+ * emitter re-prints these words; libc strtod does not accept them
+ * portably). */
+const char* yep_tag_float_word(const char* p, uint32_t len);
+
+#endif /* YEP_RESOLVER_H */

data/vendor/libyeptris/src/yeptris/resolve/tags.c

@@ -0,0 +1,58 @@
+/* tags.c — the tag identity SSOT (TODO.impl/10).
+ *
+ * Dense ids for the core set; canonical URIs live here once. Custom
+ * tags keep their string (the DOM already stores the view) and use
+ * YEPTRIS_TAG_CUSTOM.
+ */
+
+#include "resolver.h"
+
+#include <string.h>
+
+typedef struct {
+    yep_tag_id id;
+    const char* uri;
+} yep_tag_entry;
+
+static const yep_tag_entry k_core[] = {
+    {0, "tag:yaml.org,2002:str"},    {1, "tag:yaml.org,2002:int"},
+    {2, "tag:yaml.org,2002:float"},  {3, "tag:yaml.org,2002:bool"},
+    {4, "tag:yaml.org,2002:null"},   {5, "tag:yaml.org,2002:timestamp"},
+    {6, "tag:yaml.org,2002:seq"},    {7, "tag:yaml.org,2002:map"},
+    {8, "tag:yaml.org,2002:binary"}, {9, "tag:yaml.org,2002:merge"},
+    {10, "tag:yaml.org,2002:value"},
+};
+
+const char* yep_tag_uri(yep_tag_id id) {
+    if (id < sizeof(k_core) / sizeof(k_core[0])) {
+        return k_core[id].uri;
+    }
+    return NULL;
+}
+
+yep_tag_id yep_tag_from_uri(const char* p, uint32_t len) {
+    for (size_t i = 0; i < sizeof(k_core) / sizeof(k_core[0]); i++) {
+        if (strlen(k_core[i].uri) == len && memcmp(k_core[i].uri, p, len) == 0) {
+            return k_core[i].id;
+        }
+    }
+    return 11; /* YEPTRIS_TAG_CUSTOM */
+}
+
+const char* yep_tag_float_word(const char* p, uint32_t len) {
+    static const struct {
+        const char* word;
+        const char* canon;
+    } words[] = {
+        {".inf", ".inf"},   {".Inf", ".inf"},   {".INF", ".inf"},  {"-.inf", "-.inf"},
+        {"-.Inf", "-.inf"}, {"-.INF", "-.inf"}, {"+.inf", ".inf"}, {"+.Inf", ".inf"},
+        {"+.INF", ".inf"},  {".nan", ".nan"},   {".NaN", ".nan"},  {".NAN", ".nan"},
+    };
+    for (size_t i = 0; i < sizeof(words) / sizeof(words[0]); i++) {
+        uint32_t wl = (uint32_t)strlen(words[i].word);
+        if (len == wl && memcmp(p, words[i].word, wl) == 0) {
+            return words[i].canon;
+        }
+    }
+    return NULL;
+}