yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/events/iterparse.c

@@ -0,0 +1,208 @@
+/* iterparse.c — document-at-a-time iteration (TODO.impl/12).
+ *
+ * Multi-document streams: each next() runs the engine from the current
+ * cursor and captures ONE document's events (records and arena reset
+ * per document — memory bounded by the largest document, not the
+ * stream). The sink aborts at DOCUMENT_END; the engine's position
+ * accessor gives the resume offset. */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/yeptris/events.h"
+#include "../common/simd_text.h"
+#include "../parse/engine.h"
+#include "capture.h"
+
+typedef struct {
+    yep_rec_store* store;
+    int doc_ends; /* DOCUMENT_END events seen this run */
+} yep_iter_sink;
+
+static int iter_on_event(void* ctx, const yep_event* ev) {
+    yep_iter_sink* s = (yep_iter_sink*)ctx;
+    /* stream framing is synthesized by the iterator (the aborted run
+     * never reaches STREAM_END); documents are the slice unit */
+    if (ev->type == YEP_EV_STREAM_START || ev->type == YEP_EV_STREAM_END) {
+        return 0;
+    }
+    if (ev->type == YEP_EV_DOCUMENT_END) {
+        s->doc_ends++;
+    }
+    int rc = yep_rec_on_event(s->store, ev);
+    if (rc != 0) {
+        return rc;
+    }
+    if (s->doc_ends >= 1) {
+        return 1; /* abort: the document is complete */
+    }
+    return 0;
+}
+
+struct yeptris_iterparse {
+    const char* buf;
+    size_t len;
+    size_t cursor;
+    int done;
+    int emitted_stream_start;
+    int pending_stream_end; /* deliver a final lone STREAM_END slice */
+    YeptrisStatus status;
+    uint32_t err_line;
+    uint32_t err_col;
+    yep_rec_store store;
+    size_t next;
+    YeptrisEvent* mat;
+    size_t mat_cap;
+    YeptrisEvent final_end;
+    YeptrisEvent final_pair[2];
+};
+
+YEPTRIS_API YeptrisIterparse yeptris_iterparse_new(const char* buf, size_t len) {
+    if (buf == NULL && len != 0) {
+        return NULL;
+    }
+    struct yeptris_iterparse* it = calloc(1, sizeof(*it));
+    if (it == NULL) {
+        return NULL;
+    }
+    it->buf = buf;
+    it->len = len;
+    yep_rec_init(&it->store);
+    return it;
+}
+
+YEPTRIS_API const YeptrisEvent* yeptris_iterparse_next(YeptrisIterparse it, size_t* count) {
+    if (it == NULL) {
+        return NULL;
+    }
+    for (;;) {
+        if (it->done && it->pending_stream_end && it->next >= it->store.n) {
+            it->pending_stream_end = 0;
+            if (!it->emitted_stream_start) {
+                /* a stream with zero documents still frames +STR */
+                it->emitted_stream_start = 1;
+                it->final_pair[0].type = YEPTRIS_EV_STREAM_START;
+                it->final_pair[1].type = YEPTRIS_EV_STREAM_END;
+                if (count != NULL) {
+                    *count = 2;
+                }
+                return it->final_pair;
+            }
+            it->final_end.type = YEPTRIS_EV_STREAM_END;
+            if (count != NULL) {
+                *count = 1;
+            }
+            return &it->final_end;
+        }
+        if (it->next < it->store.n) {
+            /* materialize the whole captured slice (one document) */
+            size_t n = it->store.n;
+            if (n + 1 > it->mat_cap) {
+                YeptrisEvent* nm = realloc(it->mat, (n + 1) * sizeof(*nm));
+                if (nm == NULL) {
+                    it->done = 1;
+                    it->status = YEPTRIS_ERROR_MEMORY;
+                    return NULL;
+                }
+                it->mat = nm;
+                it->mat_cap = n + 1;
+            }
+            for (size_t i = 0; i < n; i++) {
+                yep_rec_materialize(&it->store, i, &it->mat[i]);
+            }
+            size_t base = 0;
+            if (!it->emitted_stream_start) {
+                it->emitted_stream_start = 1;
+                /* prepend the synthesized STREAM_START */
+                memmove(&it->mat[1], it->mat, n * sizeof(*it->mat));
+                memset(&it->mat[0], 0, sizeof(it->mat[0]));
+                it->mat[0].type = YEPTRIS_EV_STREAM_START;
+                base = 1;
+            }
+            it->next = it->store.n; /* consumed */
+            if (count != NULL) {
+                *count = n + base;
+            }
+            return it->mat;
+        }
+        if (it->done) {
+            return NULL;
+        }
+        /* capture the next document: abort the run at its DOCUMENT_END;
+         * the marker line stays unconsumed and doubles as the next
+         * document's start on the resumed run */
+        yep_rec_reset(&it->store);
+        it->next = 0;
+        yep_iter_sink s = {&it->store, 0};
+        yep_engine* eng = yep_engine_create(yep_system_allocator());
+        if (eng == NULL) {
+            it->done = 1;
+            it->status = YEPTRIS_ERROR_MEMORY;
+            return NULL;
+        }
+        yep_sink sink = {.on_event = iter_on_event,
+                         .ctx = &s,
+                         .on_flow_build = NULL,
+                         .on_flow_commit = NULL,
+                         .on_flow_rollback = NULL,
+                         .on_block_pair = NULL,
+                         .on_block_open = NULL,
+                         .on_block_item = NULL};
+        yep_text_stats pst;
+        yep_text_active()->scan_stats(it->buf + it->cursor, it->len - it->cursor, &pst);
+        yep_engine_prepare(eng, &pst);
+        int rc = yep_engine_run(eng, it->buf + it->cursor, it->len - it->cursor, &sink);
+        size_t pos = yep_engine_pos(eng);
+        const yep_error* err = yep_engine_error(eng);
+        if (rc == -1 && err != NULL) {
+            it->err_line = err->line;
+            it->err_col = err->col;
+        }
+        yep_engine_destroy(eng);
+        if (rc == -1) {
+            it->done = 1;
+            it->status = YEPTRIS_ERROR_PARSE;
+            if (it->store.n == 0) {
+                if (!it->emitted_stream_start) {
+                    /* the engine emitted +STR before failing: match it */
+                    it->emitted_stream_start = 1;
+                    it->final_end.type = YEPTRIS_EV_STREAM_START;
+                    if (count != NULL) {
+                        *count = 1;
+                    }
+                    return &it->final_end;
+                }
+                return NULL;
+            }
+            continue; /* surface the partial slice, then stop */
+        }
+        it->cursor += pos;
+        if (rc == 0 || s.doc_ends == 0) {
+            it->done = 1; /* natural end or blank tail: stream is over */
+            it->pending_stream_end = 1;
+        }
+    }
+}
+
+YEPTRIS_API YeptrisStatus yeptris_iterparse_status(const YeptrisIterparse it, uint32_t* line,
+                                                   uint32_t* col) {
+    if (it == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    if (line != NULL) {
+        *line = it->err_line;
+    }
+    if (col != NULL) {
+        *col = it->err_col;
+    }
+    return it->status;
+}
+
+YEPTRIS_API void yeptris_iterparse_free(YeptrisIterparse it) {
+    if (it == NULL) {
+        return;
+    }
+    yep_rec_free(&it->store);
+    free(it->mat);
+    free(it);
+}

data/vendor/libyeptris/src/yeptris/events/pull.c

@@ -0,0 +1,97 @@
+/* pull.c — StAX-style cursor (TODO.impl/12).
+ *
+ * Zero C->host dispatch: the run completes into the shared capture,
+ * then events are handed out one (or a batch) at a time. Event strings
+ * reference the puller's arena and are valid until the next call. */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/yeptris/events.h"
+#include "../common/simd_text.h"
+#include "../parse/engine.h"
+#include "capture.h"
+
+struct yeptris_pull {
+    yep_rec_store store;
+    size_t next;
+    YeptrisStatus status;
+    uint32_t err_line;
+    uint32_t err_col;
+    YeptrisEvent current;
+};
+
+YEPTRIS_API YeptrisPullParser yeptris_pull_new(const char* buf, size_t len) {
+    if (buf == NULL && len != 0) {
+        return NULL;
+    }
+    struct yeptris_pull* p = calloc(1, sizeof(*p));
+    if (p == NULL) {
+        return NULL;
+    }
+    yep_rec_init(&p->store);
+    yep_engine* eng = yep_engine_create(yep_system_allocator());
+    if (eng == NULL) {
+        yeptris_pull_free(p);
+        return NULL;
+    }
+    yep_sink sink = {.on_event = yep_rec_on_event,
+                     .ctx = &p->store,
+                     .on_flow_build = NULL,
+                     .on_flow_commit = NULL,
+                     .on_block_item = NULL};
+    yep_text_stats pst;
+    yep_text_active()->scan_stats(buf, len, &pst);
+    yep_engine_prepare(eng, &pst);
+    int rc = yep_engine_run(eng, buf, len, &sink);
+    const yep_error* err = yep_engine_error(eng);
+    if (err != NULL && rc != 0) {
+        p->err_line = err->line;
+        p->err_col = err->col;
+    }
+    yep_engine_destroy(eng);
+    p->status = rc == 0 ? YEPTRIS_OK : YEPTRIS_ERROR_PARSE;
+    return p;
+}
+
+YEPTRIS_API const YeptrisEvent* yeptris_pull_next(YeptrisPullParser pull) {
+    if (pull == NULL || pull->next >= pull->store.n) {
+        return NULL;
+    }
+    yep_rec_materialize(&pull->store, pull->next++, &pull->current);
+    return &pull->current;
+}
+
+YEPTRIS_API size_t yeptris_pull_next_batch(YeptrisPullParser pull, YeptrisEvent* out, size_t max) {
+    if (pull == NULL || out == NULL) {
+        return 0;
+    }
+    size_t n = 0;
+    while (n < max && pull->next < pull->store.n) {
+        yep_rec_materialize(&pull->store, pull->next++, &out[n]);
+        n++;
+    }
+    return n;
+}
+
+YEPTRIS_API YeptrisStatus yeptris_pull_status(const YeptrisPullParser pull, uint32_t* line,
+                                              uint32_t* col) {
+    if (pull == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    if (line != NULL) {
+        *line = pull->err_line;
+    }
+    if (col != NULL) {
+        *col = pull->err_col;
+    }
+    return pull->status;
+}
+
+YEPTRIS_API void yeptris_pull_free(YeptrisPullParser pull) {
+    if (pull == NULL) {
+        return;
+    }
+    yep_rec_free(&pull->store);
+    free(pull);
+}

data/vendor/libyeptris/src/yeptris/events/push.c

@@ -0,0 +1,104 @@
+/* push.c — callback push over the engine sink (TODO.impl/12).
+ *
+ * The C-user convenience shape: one call per event, strings valid only
+ * during the callback. Bindings prefer the recorder's bulk drain. */
+
+#include <string.h>
+
+#include "../../include/yeptris/events.h"
+#include "../common/simd_text.h"
+#include "../parse/engine.h"
+#include "yeptris/error.h"
+#include "yeptris/parse.h"
+
+typedef struct {
+    yeptris_event_fn fn;
+    void* ctx;
+} yep_push_ctx;
+
+static int push_on_event(void* ctx, const yep_event* ev) {
+    yep_push_ctx* p = (yep_push_ctx*)ctx;
+    YeptrisEvent e;
+    memset(&e, 0, sizeof(e));
+    switch (ev->type) {
+    case YEP_EV_STREAM_START:
+        e.type = YEPTRIS_EV_STREAM_START;
+        break;
+    case YEP_EV_STREAM_END:
+        e.type = YEPTRIS_EV_STREAM_END;
+        break;
+    case YEP_EV_DOCUMENT_START:
+        e.type = YEPTRIS_EV_DOCUMENT_START;
+        e.explicit_marker = (ev->style == 1);
+        break;
+    case YEP_EV_DOCUMENT_END:
+        e.type = YEPTRIS_EV_DOCUMENT_END;
+        e.explicit_marker = (ev->style == 1);
+        break;
+    case YEP_EV_SEQ_START:
+        e.type = YEPTRIS_EV_SEQUENCE_START;
+        break;
+    case YEP_EV_SEQ_END:
+        e.type = YEPTRIS_EV_SEQUENCE_END;
+        break;
+    case YEP_EV_MAP_START:
+        e.type = YEPTRIS_EV_MAPPING_START;
+        break;
+    case YEP_EV_MAP_END:
+        e.type = YEPTRIS_EV_MAPPING_END;
+        break;
+    case YEP_EV_SCALAR:
+        e.type = YEPTRIS_EV_SCALAR;
+        e.style = ev->style;
+        e.implicit = ev->implicit;
+        break;
+    case YEP_EV_ALIAS:
+        e.type = YEPTRIS_EV_ALIAS;
+        break;
+    default:
+        return 0;
+    }
+    e.flow = ev->flow;
+    e.line = ev->line;
+    e.col = ev->col;
+    e.value = ev->value.len > 0 ? (const char*)ev->value.p : NULL;
+    e.value_len = ev->value.len;
+    e.anchor = ev->anchor.len > 0 ? (const char*)ev->anchor.p : NULL;
+    e.anchor_len = ev->anchor.len;
+    e.tag = ev->tag.len > 0 ? (const char*)ev->tag.p : NULL;
+    e.tag_len = ev->tag.len;
+    return p->fn(p->ctx, &e);
+}
+
+YEPTRIS_API YeptrisStatus yeptris_push_parse(const char* buf, size_t len, yeptris_event_fn on_event,
+                                             void* ctx) {
+    if (buf == NULL && len != 0) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    if (on_event == NULL) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    yep_engine* eng = yep_engine_create(yep_system_allocator());
+    if (eng == NULL) {
+        return YEPTRIS_ERROR_MEMORY;
+    }
+    yep_push_ctx p = {on_event, ctx};
+    yep_sink sink = {.on_event = push_on_event,
+                     .ctx = &p,
+                     .on_flow_build = NULL,
+                     .on_flow_commit = NULL,
+                     .on_flow_rollback = NULL,
+                     .on_block_pair = NULL,
+                     .on_block_open = NULL,
+                     .on_block_item = NULL};
+    yep_text_stats pst;
+    yep_text_active()->scan_stats(buf, len, &pst);
+    yep_engine_prepare(eng, &pst);
+    int rc = yep_engine_run(eng, buf, len, &sink);
+    yep_engine_destroy(eng);
+    if (rc == 0) {
+        return YEPTRIS_OK;
+    }
+    /* -2: the callback aborted — reported as a parse stop, not a bug */
+    return YEPTRIS_ERROR_PARSE;
+}

data/vendor/libyeptris/src/yeptris/events/recorder.c

@@ -0,0 +1,107 @@
+/* recorder.c — chunked event recorder (TODO.impl/12).
+ *
+ * Feed chunks, drain bulk: fixed-size records plus one string arena,
+ * reset at every feed entry. The engine's resumable stepping (07)
+ * advances the parse as complete documents arrive — each feed's
+ * records are the events for documents closed by that chunk, so a
+ * stream watcher holds one document of memory, not the whole stream. */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/yeptris/events.h"
+#include "../parse/engine.h"
+#include "../resolve/resolver.h"
+#include "capture.h"
+
+struct yeptris_recorder {
+    yep_rec_store store;
+    yep_engine* eng; /* created on first feed; steps per feed */
+    int final_fed;
+    int compat11;
+    YeptrisStatus status;
+    uint32_t err_line;
+    uint32_t err_col;
+};
+
+YEPTRIS_API YeptrisRecorder yeptris_recorder_new(void) {
+    return yeptris_recorder_new_ex(YEPTRIS_SCHEMA_12_CORE);
+}
+
+YEPTRIS_API YeptrisRecorder yeptris_recorder_new_ex(YeptrisSchema schema) {
+    struct yeptris_recorder* r = calloc(1, sizeof(*r));
+    if (r != NULL) {
+        yep_rec_init(&r->store);
+        r->compat11 = schema == YEPTRIS_SCHEMA_11_COMPAT;
+    }
+    return r;
+}
+
+YEPTRIS_API YeptrisStatus yeptris_recorder_feed(YeptrisRecorder rec, const char* chunk, size_t len,
+                                                int final) {
+    if (rec == NULL || (chunk == NULL && len != 0)) {
+        return YEPTRIS_ERROR_ARG;
+    }
+    if (rec->final_fed) {
+        return YEPTRIS_ERROR_ARG; /* one stream per recorder */
+    }
+    if (rec->eng == NULL) {
+        rec->eng = yep_engine_create(yep_system_allocator());
+        if (rec->eng == NULL) {
+            return YEPTRIS_ERROR_MEMORY;
+        }
+        yep_engine_set_resolver(rec->eng,
+                                rec->compat11 ? yep_resolver_compat11() : yep_resolver_core12());
+    }
+    if (final) {
+        rec->final_fed = 1;
+    }
+    yep_rec_reset(&rec->store);
+    yep_sink sink = {.on_event = yep_rec_on_event,
+                     .ctx = &rec->store,
+                     .on_flow_build = NULL,
+                     .on_flow_commit = NULL,
+                     .on_block_item = NULL};
+    int rc = yep_engine_step(rec->eng, chunk, len, final, &sink);
+    if (rc != 0) {
+        const yep_error* err = yep_engine_error(rec->eng);
+        if (err != NULL) {
+            rec->err_line = err->line;
+            rec->err_col = err->col;
+        }
+        rec->final_fed = 1; /* a parse error kills the stream */
+        rec->status = YEPTRIS_ERROR_PARSE;
+        return rec->status;
+    }
+    rec->status = YEPTRIS_OK;
+    return rec->status;
+}
+
+YEPTRIS_API const YeptrisEventRecord* yeptris_recorder_records(YeptrisRecorder rec, size_t* count) {
+    if (rec == NULL) {
+        return NULL;
+    }
+    if (count != NULL) {
+        *count = rec->store.n;
+    }
+    return rec->store.recs;
+}
+
+YEPTRIS_API const char* yeptris_recorder_arena(YeptrisRecorder rec, size_t* len) {
+    if (rec == NULL) {
+        return NULL;
+    }
+    if (len != NULL) {
+        *len = rec->store.arena_len;
+    }
+    return rec->store.arena;
+}
+
+YEPTRIS_API void yeptris_recorder_free(YeptrisRecorder rec) {
+    if (rec == NULL) {
+        return;
+    }
+    yep_engine_destroy(rec->eng);
+    yep_rec_free(&rec->store);
+    free(rec);
+}