yeptris 0.6.18.2-arm-linux-eabihf

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

@@ -0,0 +1,150 @@
+/* scan.h — structure facts from bytes (TODO.impl/06).
+ *
+ * MECE law: scan answers "where does this line's content start and where
+ * do spans end" — never grammar decisions, never allocation. The engine
+ * (07) owns grammar. Line facts are produced lazily, one line at a time;
+ * no whole-document table (streaming-friendly).
+ */
+#ifndef YEP_SCAN_H
+#define YEP_SCAN_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "common/simd_text.h" /* yep_stopset (the stop-class form) */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct yep_line_info {
+    uint32_t offset; /* byte offset of the line start */
+    uint32_t end;    /* byte offset of the line break (exclusive content end) */
+    uint16_t indent; /* column of the first non-space (== end - offset when blank) */
+    uint16_t flags;
+    unsigned char first; /* first content byte ('\0' for blank lines) */
+} yep_line_info;
+
+enum {
+    YEP_LF_BLANK = 1u << 0,     /* only spaces */
+    YEP_LF_COMMENT = 1u << 1,   /* first content char is '#' */
+    YEP_LF_DOC_START = 1u << 2, /* "---" (then EOL / space / comment) */
+    YEP_LF_DOC_END = 1u << 3,   /* "..." (then EOL / space / comment) */
+    YEP_LF_DIRECTIVE = 1u << 4, /* '%' at column 0 */
+    YEP_LF_TAB = 1u << 5,       /* tab within the indentation (error) */
+};
+
+/* Facts for the line starting at pos. Handles \n, \r\n, lone \r breaks. */
+yep_line_info yep_scan_line(const char* p, size_t len, size_t pos);
+
+/* What terminated a plain-scalar span. */
+typedef enum {
+    YEP_TERM_EOF = 0,
+    YEP_TERM_EOL,
+    YEP_TERM_COMMENT,  /* " #" — span excludes the preceding space */
+    YEP_TERM_COLON,    /* ':' followed by blank/EOL — span ends before ':' */
+    YEP_TERM_FLOW,     /* flow indicator (flow context only) */
+    YEP_TERM_BAD_COLON /* ':' in a position YAML forbids (error context) */
+} yep_span_term;
+
+typedef struct yep_span {
+    uint32_t start;
+    uint32_t end; /* trimmed span end (exclusive) */
+    yep_span_term term;
+} yep_span;
+
+/* Line-shape classification (TODO.restructure/49): byte-class FACTS for
+ * the engine's one-per-line dispatch decision — scan walks, the engine
+ * decides. A shape is only produced for the dominant block line forms;
+ * every other line classifies NONE and keeps the general paths. */
+typedef enum {
+    YEP_LSHAPE_NONE = 0, /* not classified: use the general chain */
+    YEP_LSHAPE_DASH,     /* "- " entry at the content start */
+    YEP_LSHAPE_KEY,      /* plain key + terminating ':' */
+} yep_line_kind;
+
+typedef enum {
+    YEP_LVAL_NONE = 0,     /* value not classified (bail) */
+    YEP_LVAL_EMPTY,        /* EOL or comment after the ':' / '-' */
+    YEP_LVAL_PLAIN,        /* plain scalar (val_span + term) */
+    YEP_LVAL_ALIAS,        /* '*name' at val_start */
+    YEP_LVAL_ANCHOR_PLAIN, /* '&name' then a plain scalar */
+    YEP_LVAL_FLOW,         /* '[' / '{' at val_start: the flow kernel owns it */
+} yep_line_val;
+
+typedef struct yep_line_shape {
+    yep_line_kind kind;
+    yep_line_val val;
+    uint32_t dash;      /* '-' offset (DASH) */
+    uint32_t key_start; /* trimmed plain key span (KEY) */
+    uint32_t key_end;
+    uint32_t colon;      /* the terminating ':' offset (KEY) */
+    uint32_t val_start;  /* first value byte (all non-EMPTY vals) */
+    uint32_t anchor_end; /* ANCHOR_PLAIN: end of the anchor name */
+    yep_span val_span;   /* PLAIN / ANCHOR_PLAIN: the scalar span + term */
+} yep_line_shape;
+
+/* Classifies the content line described by li (its own line; flags must
+ * be clear). Zero-initializes *out, then fills the facts. */
+void yep_scan_shape(const char* p, size_t len, const yep_line_info* li, yep_line_shape* out);
+void yep_scan_shape_f(const char* p, size_t len, const yep_line_info* li, const yep_line_facts* f,
+                      yep_line_shape* out);
+void yep_scan_line_f(const char* p, size_t len, size_t pos, const yep_line_facts* f,
+                     yep_line_info* out);
+
+/* ns-anchor-name byte: not blank/break/flow-indicator, not ',' or '#'. */
+int yep_scan_prop_char(unsigned char c);
+
+/* First offset at/after pos that cannot continue an anchor/alias name. */
+size_t yep_scan_prop_end(const char* p, size_t len, size_t pos);
+
+/* Scans a plain scalar starting at pos (must be content, not a comment).
+ * flow != 0 adds flow stop characters; in flow, ':' terminates when
+ * followed by blank/EOL/flow indicator. Leading whitespace is NOT
+ * consumed. Trailing spaces are trimmed from the span. */
+yep_span yep_scan_plain(const char* p, size_t len, size_t pos, int flow);
+
+/* ns-plain-first truth: whether c may START a plain scalar. ','
+ * ']' '}' are c-flow-indicators, excluded in every context ('[' '{'
+ * never reach a plain start: the engine dispatches flow first). */
+int yep_plain_first_ok(unsigned char c);
+
+/* The stop classes (scan.c's SSOT; prebuilt nibble-class tables —
+ * '\n','\r',':','#' and, in flow, ',','[',']','{','}').
+ * Externally linked so the unit suite can pin them against
+ * yep_stopset_init — a hand-written literal drift here would silently
+ * end every plain scalar early. */
+extern const yep_stopset yep_break_stopset;
+extern const yep_stopset yep_plain_stop_block;
+extern const yep_stopset yep_plain_stop_flow;
+
+/* The fused line-facts sweep (kernel-dispatched): end/indent/stop in
+ * one pass — scan_line and scan_shape both consume these. */
+void yep_scan_facts(const char* p, size_t len, size_t pos, yep_line_facts* out);
+
+/* Scans a quoted scalar whose opening quote is at pos. Returns span of
+ * the CONTENT (between quotes) and sets *term (EOL on unterminated → the
+ * caller errors). q is '\'' or '"'. */
+yep_span yep_scan_quoted(const char* p, size_t len, size_t pos, int* has_escape);
+
+/* True if a simple key may start at p[pos] (ns-plain-first approximation
+ * plus quote/flow openers). Exposed for the engine's dispatch. */
+int yep_scan_is_key_start(unsigned char c);
+
+/* Consumed length of the line break at pos (0 if none): \n -> 1,
+ * \r\n -> 2, lone \r -> 1. */
+size_t yep_scan_break_len(const char* p, size_t len, size_t pos);
+
+/* Line/col bookkeeping across a scanned gap: advances *line and
+ * *line_start over the bytes in [*from, to) (only the unscanned region
+ * is walked — scanning from the line start is quadratic on long
+ * lines). *from becomes `to`. Shared by the flow kernel's event pass
+ * and the DOM direct builder so their line/col facts cannot drift. */
+void yep_scan_advance_line(const char* p, size_t* from, size_t to, uint32_t* line,
+                           size_t* line_start);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_SCAN_H */

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

@@ -0,0 +1,308 @@
+/* schema.c — the fused schema-descriptor materialization
+ * (issue #238, TODO.restructure/83).
+ *
+ * One parse (the same engine every surface uses) + one fused walk of
+ * the DOM against the caller's descriptor: typed columns come out,
+ * the intermediate generic document never exists. The DOM side runs
+ * first because it is the cheapest complete-materialization engine;
+ * when the recorder path learns descriptor projection it can drop in
+ * under the same ABI (the columns are the contract, not the walk).
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <yeptris/schema.h>
+#include <yeptris/values.h> /* YeptrisValue: ST_ANY records (#238) */
+
+#include "dom/dom.h"
+#include "memory/allocator.h"
+#include "parse/engine.h"
+#include "resolve/resolver.h"
+#include "scan/json.h"
+
+typedef struct {
+    const yeptris_desc_node* desc;
+    uint32_t desc_len;
+    yeptris_schema_column* cols;
+    const yep_dom* dom;
+    int oom;
+    int overflow;
+    int type_mismatch;  /* node index */
+    uint32_t* seen_map; /* per-node: the mapping instance that last
+                         * emitted — YEP_SF_FIRST_WINS skips a repeat */
+} yep_schema_ctx;
+
+static int col_put(yep_schema_ctx* c, uint32_t node, const void* rec, size_t size) {
+    yeptris_schema_column* col = &c->cols[node];
+    if (col->count >= col->capacity) {
+        c->overflow = 1;
+        return 0;
+    }
+    memcpy((char*)col->data + (size_t)col->count * size, rec, size);
+    col->count++;
+    return 1;
+}
+
+static void put_error_schema(uint32_t node) {
+    yep_error_set(yep_error_tls(), YEP_ERR_SCHEMA, 0, 0, node,
+                  "required descriptor node %u missing", node);
+}
+
+/* Materializes the DOM node under plan `node` into its column. */
+static int emit(yep_schema_ctx* c, uint32_t node, uint32_t at);
+
+static int emit_scalar(yep_schema_ctx* c, uint32_t node, uint32_t at) {
+    const yeptris_desc_node* d = &c->desc[node];
+    const yep_dnode* n = yep_dom_node(c->dom, at);
+    yep_view v = yep_dom_view(c->dom, n->value);
+    switch (d->type_tag) {
+    case YEP_ST_STR: {
+        yeptris_span2 s = {(uint32_t)((const char*)v.p - c->dom->input_base), v.len, 0, 0};
+        return col_put(c, node, &s, sizeof(s));
+    }
+    case YEP_ST_INT:
+    case YEP_ST_FLOAT: {
+        int64_t iv = 0;
+        double dv = 0;
+        int shape = 0;
+        size_t end = 0;
+        if (v.len == 0 || v.p == NULL ||
+            yep_json_number_scan(v.p, v.len, &end, &shape, &iv, &dv) == 0 || end != v.len) {
+            c->type_mismatch = (int)node;
+            return -1;
+        }
+        if (d->type_tag == YEP_ST_INT) {
+            int64_t out = shape == 0 ? iv : (int64_t)dv;
+            return col_put(c, node, &out, sizeof(out));
+        }
+        double fd = shape == 0 ? (double)iv : dv;
+        return col_put(c, node, &fd, sizeof(fd));
+    }
+    case YEP_ST_BOOL: {
+        uint8_t b = (uint8_t)(v.len > 0 && (v.p[0] == 't' || v.p[0] == 'T' || v.p[0] == 'y' ||
+                                            v.p[0] == 'Y' || v.p[0] == 'o' || v.p[0] == '1'));
+        return col_put(c, node, &b, sizeof(b));
+    }
+    case YEP_ST_NULL:
+        col_put(c, node, &(uint8_t){0}, 0);
+        return 1;
+    case YEP_ST_ANY: {
+        /* the resolver's verdict, verbatim: a YeptrisValue record
+         * (#238's headroom) — kind/tag_id from the node, the span
+         * borrowed, and the numeric payload converted when the
+         * verdict says so (the values-drain's conversion, DOM-side) */
+        YeptrisValue r = {0, 0, 0, 0, 0, 0, 0};
+        r.tag_id = n->tag_id;
+        r.off = (uint32_t)((const char*)v.p - c->dom->input_base);
+        r.len = v.len;
+        switch (n->tag_id) {
+        case YEPTRIS_TAG_NULL:
+            r.kind = YEP_V_NULL;
+            break;
+        case YEPTRIS_TAG_BOOL: {
+            r.kind = YEP_V_BOOL;
+            r.b = (uint8_t)(v.len > 0 && (v.p[0] == 't' || v.p[0] == 'T' || v.p[0] == 'y' ||
+                                          v.p[0] == 'Y' || v.p[0] == 'o' || v.p[0] == '1'));
+            break;
+        }
+        case YEPTRIS_TAG_INT:
+        case YEPTRIS_TAG_FLOAT: {
+            int64_t iv = 0;
+            double dv = 0;
+            int shape = 0;
+            size_t end = 0;
+            if (v.len != 0 && v.p != NULL &&
+                yep_json_number_scan(v.p, v.len, &end, &shape, &iv, &dv) != 0 && end == v.len) {
+                if (n->tag_id == YEPTRIS_TAG_INT) {
+                    r.kind = YEP_V_INT;
+                    r.p = (uint64_t)iv;
+                } else {
+                    r.kind = YEP_V_FLOAT;
+                    double fd = shape == 0 ? (double)iv : dv;
+                    memcpy(&r.p, &fd, sizeof(fd));
+                }
+            } else {
+                r.kind = YEP_V_STR; /* the resolver said number, the
+                                      bytes disagree: keep the span */
+            }
+            break;
+        }
+        case YEPTRIS_TAG_TIMESTAMP:
+            r.kind = YEP_V_TIMESTAMP;
+            break;
+        default:
+            r.kind = YEP_V_STR;
+            break;
+        }
+        return col_put(c, node, &r, sizeof(r));
+    }
+    default:
+        return -1;
+    }
+}
+
+static int emit(yep_schema_ctx* c, uint32_t node, uint32_t at) {
+    const yeptris_desc_node* d = &c->desc[node];
+    const yep_dnode* n = yep_dom_node(c->dom, at);
+    switch (d->kind) {
+    case YEP_SK_SCALAR:
+        return emit_scalar(c, node, at);
+    case YEP_SK_CALLBACK: {
+        /* the escape hatch: raw span + the node's first byte —
+         * scalar content by span, collections by their extent (the
+         * caller that needs the tree takes the generic surface) */
+        yep_view v = yep_dom_view(c->dom, n->value);
+        yeptris_span2 s = {(uint32_t)((const char*)v.p - c->dom->input_base), v.len,
+                           (uint32_t)((const char*)v.p - c->dom->input_base), 0};
+        if (n->kind == YEP_DOM_MAPPING || n->kind == YEP_DOM_SEQUENCE) {
+            s.off = 0; /* collections have no span: position only */
+            s.len = 0;
+        }
+        return col_put(c, node, &s, sizeof(s));
+    }
+    case YEP_SK_SEQUENCE: {
+        if (n->kind != YEP_DOM_SEQUENCE) {
+            return 0; /* not this shape: the column stays empty */
+        }
+        uint32_t ch = d->child_index;
+        if (ch >= c->desc_len) {
+            return -1;
+        }
+        uint32_t e = n->first_child;
+        while (e != UINT32_MAX) {
+            int rc = emit(c, ch, e);
+            if (rc != 1) {
+                return rc;
+            }
+            e = c->dom->nodes[e].next_sibling;
+        }
+        return 1;
+    }
+    case YEP_SK_MAPPING: {
+        if (n->kind != YEP_DOM_MAPPING) {
+            return 0;
+        }
+        uint32_t k = n->first_child;
+        while (k != UINT32_MAX) {
+            uint32_t val = c->dom->nodes[k].next_sibling;
+            yep_view key = yep_dom_view(c->dom, c->dom->nodes[k].value);
+            for (uint32_t ci = d->child_index;
+                 ci < d->child_index + d->child_count && ci < c->desc_len; ci++) {
+                const yeptris_desc_node* cd = &c->desc[ci];
+                size_t wl = strlen(cd->wire_name ? cd->wire_name : "");
+                if (cd->wire_name != NULL && key.len == wl &&
+                    memcmp(key.p, cd->wire_name, wl) == 0) {
+                    if ((cd->flags & YEP_SF_FIRST_WINS) && c->seen_map != NULL &&
+                        c->seen_map[ci] == at + 1) {
+                        break; /* a repeat within THIS mapping: first wins */
+                    }
+                    int rc = emit(c, ci, val);
+                    if (rc != 1) {
+                        return rc;
+                    }
+                    if ((cd->flags & YEP_SF_FIRST_WINS) && c->seen_map != NULL) {
+                        c->seen_map[ci] = at + 1;
+                    }
+                    break;
+                }
+            }
+            k = c->dom->nodes[val].next_sibling;
+        }
+        return 1;
+    }
+    default:
+        return -1;
+    }
+}
+
+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) {
+    if ((source == NULL && len != 0) || desc == NULL || desc_len == 0 || cols == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    if (desc_abi != YEPTRIS_DESC_ABI) {
+        yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, desc_abi,
+                      "descriptor ABI %u != %u (recompile the descriptor)", desc_abi,
+                      YEPTRIS_DESC_ABI);
+        return YEPTRIS_ERROR_ARG;
+    }
+    for (uint32_t i = 0; i < desc_len; i++) {
+        if (desc[i].reserved != 0) {
+            return YEPTRIS_ERROR_ARG;
+        }
+        cols[i].count = 0;
+    }
+
+    const yep_allocator* sys = yep_system_allocator();
+    yep_engine* eng = yep_engine_create(sys);
+    yep_dom* dom = yep_dom_create(sys);
+    uint32_t* seen_map_ptr = NULL;
+    YeptrisStatus st = YEPTRIS_OK;
+    yep_sink sink = {.on_event = yep_dom_on_event,
+                     .ctx = dom,
+                     .on_flow_build = dom_on_flow_build,
+                     .on_flow_commit = dom_on_flow_commit,
+                     .on_flow_rollback = dom_on_flow_rollback,
+                     .on_block_pair = dom_on_block_pair,
+                     .on_scalar = dom_on_scalar,
+                     .on_block_open = dom_on_block_open,
+                     .on_block_item = dom_on_block_item};
+    if (eng == NULL || dom == NULL) {
+        st = YEPTRIS_ERROR_MEMORY;
+        goto out;
+    }
+    if (schema == YEPTRIS_SCHEMA_11_COMPAT) {
+        yep_engine_set_resolver(eng, yep_resolver_compat11());
+        dom->resolver = yep_resolver_compat11(); /* the DOM's direct
+                                  builders resolve their own tag_ids —
+                                  ST_ANY reads the NODE's verdict */
+    }
+    dom->input_base = source;
+    dom->input_len = len;
+    yep_dom_prepare_len(dom, len);
+    if (yep_engine_run(eng, source, len, &sink) != 0 || dom->dcount == 0) {
+        st = YEPTRIS_ERROR_PARSE;
+        goto out;
+    }
+
+    {
+        uint32_t* seen = seen_map_ptr = calloc(desc_len, sizeof(uint32_t));
+        if (seen == NULL) {
+            st = YEPTRIS_ERROR_MEMORY;
+            goto out;
+        }
+        yep_schema_ctx c = {desc, desc_len, cols, dom, 0, 0, -1, seen};
+        int rc = emit(&c, 0, dom->docs[0]);
+        if (rc < 0 && c.type_mismatch >= 0) {
+            yep_error_set(yep_error_tls(), YEP_ERR_UNEXPECTED, 0, 0, (uint32_t)c.type_mismatch,
+                          "node %d: value is not a number", c.type_mismatch);
+            st = YEPTRIS_ERROR_PARSE;
+            goto out;
+        }
+        if (rc < 0) {
+            st = YEPTRIS_ERROR_ARG;
+            goto out;
+        }
+        for (uint32_t i = 0; i < desc_len; i++) {
+            if ((desc[i].flags & YEP_SF_REQUIRED) && cols[i].count == 0 &&
+                desc[i].wire_name != NULL) {
+                put_error_schema(i);
+                st = YEPTRIS_ERROR_SCHEMA;
+                goto out;
+            }
+        }
+        if (c.overflow) {
+            st = YEPTRIS_ERROR_MEMORY; /* caller buffers too small */
+            yep_error_set(yep_error_tls(), YEP_ERR_MEMORY, 0, 0, 0,
+                          "output column capacity exceeded");
+        }
+    }
+
+out:
+    free(seen_map_ptr);
+    yep_dom_destroy(dom);
+    yep_engine_destroy(eng);
+    return st;
+}