yeptris 0.6.59.1-arm-linux-eabihf → 0.6.60.1-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/emit/writer.h

@@ -38,7 +38,12 @@ typedef struct yep_writer {
     const char* json_indent;                    /* json_pretty indent unit; NULL = 2 spaces */
     int json_indent_len;                        /* json_pretty unit byte length */
     int best_width;                             /* 13B: 0 = default 80; flow lines wrap after a
-                                                 * value past this width */
+                                                 * value past this width; with block_fold it is
+                                                 * also the block scalar fold column (#903) */
+    int indent;                                 /* #903: block indent per level (2..9, default
+                                                 * 2): nested map content and seq item columns */
+    int block_fold;                             /* #903: plain/quoted block scalars fold at
+                                                 * best_width (libyaml's plain-fold walk) */
     int col;                                    /* current output column (wr_* maintains) */
     const char* sv_input;                       /* compact-view decode bases (dom regions) */
     const char* sv_arena;
@@ -82,6 +87,15 @@ typedef struct yep_emitter {
 /* One pass over the document set. dry=1 counts exactly. */
 size_t yep_emit_run(yep_emitter* em, int dry);
 
+/* The write primitives, shared with the marshal reader
+ * (marshal/to_json.c — the move keeps ONE writer engine; #904 item 5).
+ * Internal: never in a public header. */
+void wr_col_update(yep_writer* w, const char* p, uint32_t n);
+void wr_reserve(yep_writer* w, size_t need);
+void wr_put(yep_writer* w, const char* p, uint32_t n);
+void wr_byte(yep_writer* w, char c);
+void emit_dq_json(yep_writer* w, const char* p, uint32_t n);
+
 /* Compact single-line JSON (internal entries for the json-c compat
  * layer's to_json_string forms). pretty selects json-c's
  * JSON_C_TO_STRING_PRETTY layout: newline + 2-space indent per

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

@@ -14,6 +14,10 @@
 typedef struct {
     yeptris_event_fn fn;
     void* ctx;
+    uint32_t abort_line; /* the mark of the event the callback aborted
+                          * on: the abort-text law sets the channel AT
+                          * the abort point, not at 0/0 */
+    uint32_t abort_col;
 } yep_push_ctx;
 
 static int push_on_event(void* ctx, const yep_event* ev) {
@@ -73,7 +77,14 @@ static int push_on_event(void* ctx, const yep_event* ev) {
     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);
+    int rc = p->fn(p->ctx, &e);
+    if (rc != 0) {
+        /* the abort point travels with the abort: the TLS slot's mark
+         * is where the walk stopped, not 0/0 (events.h's contract) */
+        p->abort_line = ev->line;
+        p->abort_col = ev->col;
+    }
+    return rc;
 }
 
 YEPTRIS_API YeptrisStatus yeptris_push_parse(const char* buf, size_t len, yeptris_event_fn on_event,
@@ -84,11 +95,17 @@ YEPTRIS_API YeptrisStatus yeptris_push_parse(const char* buf, size_t len, yeptri
     if (on_event == NULL) {
         return YEPTRIS_ERROR_ARG;
     }
+    /* the push run owns the channel for its duration: clearing at
+     * entry makes the abort-text law verifiable (the message a caller
+     * reads after a push is THIS run's verdict, never a stale one
+     * from an earlier operation on the thread — error.h promises ""
+     * after a success) */
+    yep_error_clear(yep_error_tls());
     yep_engine* eng = yep_engine_create(yep_system_allocator());
     if (eng == NULL) {
         return YEPTRIS_ERROR_MEMORY;
     }
-    yep_push_ctx p = {on_event, ctx};
+    yep_push_ctx p = {on_event, ctx, 0, 0};
     yep_sink sink = {.on_event = push_on_event,
                      .ctx = &p,
                      .on_flow_build = NULL,
@@ -118,9 +135,17 @@ YEPTRIS_API YeptrisStatus yeptris_push_parse(const char* buf, size_t len, yeptri
     }
     /* the engine's own memory failures report MEMORY (the parse route's
      * law); the callback abort keeps its documented contract — a parse
-     * stop, clean channel */
+     * stop with the last-error channel SET (#904 item 4, the
+     * abort-text law: the old code returned PARSE over a CLEAN slot,
+     * so yeptris_last_error served whatever stale message this thread's
+     * previous operation had left there). YEP_ERR_ABORTED carries the
+     * mark of the event the callback aborted on. */
     if (err_code == YEP_ERR_MEMORY) {
         return YEPTRIS_ERROR_MEMORY;
     }
+    if (err_code == YEP_ERR_NONE) {
+        yep_error_set(yep_error_tls(), YEP_ERR_ABORTED, p.abort_line, p.abort_col, 0,
+                      "parse aborted by the event callback at %u:%u", p.abort_line, p.abort_col);
+    }
     return YEPTRIS_ERROR_PARSE;
 }

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

@@ -175,6 +175,15 @@ static int transform(yep_value_ctx* c, const yep_rec_store* store) {
         case YEPTRIS_EV_SEQUENCE_START:
             v.kind = YEP_V_SEQ_OPEN;
             v.tag_id = r->tag_id;
+            if (r->tag_len != 0) {
+                /* the collection's explicit tag text rides the opens'
+                 * span fields (untagged containers keep off/len 0 —
+                 * the arena is not touched on the hot path): a host
+                 * constructor re-tags containers (!!set -> Python set,
+                 * !!omap -> pairs) without a second drain */
+                v.off = yep_val_arena_put(c, ra + r->tag_off, r->tag_len);
+                v.len = r->tag_len;
+            }
             yep_val_slot(c, &v);
             yep_val_put(c, &v);
             if (c->depth < YEP_V_MAX_DEPTH) {
@@ -186,6 +195,11 @@ static int transform(yep_value_ctx* c, const yep_rec_store* store) {
         case YEPTRIS_EV_MAPPING_START:
             v.kind = YEP_V_MAP_OPEN;
             v.tag_id = r->tag_id;
+            if (r->tag_len != 0) {
+                /* the set/omap tag text, exactly as the SEQ arm above */
+                v.off = yep_val_arena_put(c, ra + r->tag_off, r->tag_len);
+                v.len = r->tag_len;
+            }
             yep_val_slot(c, &v);
             yep_val_put(c, &v);
             if (c->depth < YEP_V_MAX_DEPTH) {
@@ -293,6 +307,16 @@ static int lin_node(yep_value_ctx* c, const yep_dom* d, uint32_t id) {
     }
     v.kind = n->kind == YEP_DOM_SEQUENCE ? YEP_V_SEQ_OPEN : YEP_V_MAP_OPEN;
     v.tag_id = n->tag_id;
+    if (n->tag.len != 0) {
+        /* route parity with the engine transform: the opens' span
+         * fields carry the explicit tag text there, so the linearizer
+         * must too (the routes stay byte-identical — values_priv.h's
+         * law). Marshal bails on tagged subtrees before this matters
+         * (#178); strict JSON carries no tags. */
+        yep_view tv = yep_dom_view(d, n->tag);
+        v.off = yep_val_arena_put(c, tv.p, (uint32_t)tv.len);
+        v.len = (uint32_t)tv.len;
+    }
     yep_val_slot(c, &v);
     yep_val_put(c, &v);
     if (c->depth < YEP_V_MAX_DEPTH) {